[MLIR][SPIRVToLLVM] Indentation and style fix in tests

[georgemitenkov]

Summary

Second patch with test fixes. Redundant %{{.*}} =
removed, label checks added, tabs converted to spaces and
some namings are changed to match the convention.

Fixed tests:

• constant-op-to-llvm
• func-ops-to-llvm (renamed)
• memory-ops-to-llvm
• misc-ops-to-llvm
• module-ops-to-llvm
• shift-ops-to-llvm (renamed)
• spirv-types-to-llvm-invalid (renamed)

[georgemitenkov]

Added missing labels.

[ftynse]

Please be advised that I landed the diff that changes the LLVM dialect type syntax so this will need a rebase and a fair share of conflict resolution.

[georgemitenkov]

In D85206#2193224, @ftynse wrote:

Please be advised that I landed the diff that changes the LLVM dialect type syntax so this will need a rebase and a fair share of conflict resolution.

Great! Thanks for letting know

[georgemitenkov]

Rebase

[rriddle]

Thanks!

mlir/test/Conversion/SPIRVToLLVM/constant-op-to-llvm.mlir

 // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // spv.constant
 //===----------------------------------------------------------------------===//
 
+// CHECK-LABEL: @bool_constant_scalar
 func @bool_constant_scalar() {
-  // CHECK: {{.*}} = llvm.mlir.constant(true) : !llvm.i1
+  // CHECK: llvm.mlir.constant(true) : !llvm.i1
   %0 = spv.constant true
-  // CHECK: {{.*}} = llvm.mlir.constant(false) : !llvm.i1
+  // CHECK: llvm.mlir.constant(false) : !llvm.i1
   %1 = spv.constant false
   return
 }
 
+// CHECK-LABEL: @bool_constant_vector
 func @bool_constant_vector() {
-  // CHECK: {{.*}} = llvm.mlir.constant(dense<[true, false]> : vector<2xi1>) : !llvm.vec<2 x i1>
+  // CHECK: llvm.mlir.constant(dense<[true, false]> : vector<2xi1>) : !llvm.vec<2 x i1>
   %0 = constant dense<[true, false]> : vector<2xi1>
-  // CHECK: {{.*}} = llvm.mlir.constant(dense<false> : vector<3xi1>) : !llvm.vec<3 x i1>
+  // CHECK: llvm.mlir.constant(dense<false> : vector<3xi1>) : !llvm.vec<3 x i1>
   %1 = constant dense<false> : vector<3xi1>
   return
 }
 
+// CHECK-LABEL: @integer_constant_scalar
 func @integer_constant_scalar() {
-  // CHECK: {{.*}} = llvm.mlir.constant(0 : i8) : !llvm.i8
+  // CHECK: llvm.mlir.constant(0 : i8) : !llvm.i8
   %0 = spv.constant  0 : i8
-  // CHECK: {{.*}} = llvm.mlir.constant(-5 : i64) : !llvm.i64
+  // CHECK: llvm.mlir.constant(-5 : i64) : !llvm.i64
   %1 = spv.constant -5 : si64
-  // CHECK: {{.*}} = llvm.mlir.constant(10 : i16) : !llvm.i16
+  // CHECK: llvm.mlir.constant(10 : i16) : !llvm.i16
   %2 = spv.constant  10 : ui16
   return
 }
 
+// CHECK-LABEL: @integer_constant_vector
 func @integer_constant_vector() {
-  // CHECK: {{.*}} = llvm.mlir.constant(dense<[2, 3]> : vector<2xi32>) : !llvm.vec<2 x i32>
+  // CHECK: llvm.mlir.constant(dense<[2, 3]> : vector<2xi32>) : !llvm.vec<2 x i32>
   %0 = spv.constant dense<[2, 3]> : vector<2xi32>
-  // CHECK: {{.*}} = llvm.mlir.constant(dense<-4> : vector<2xi32>) : !llvm.vec<2 x i32>
+  // CHECK: llvm.mlir.constant(dense<-4> : vector<2xi32>) : !llvm.vec<2 x i32>
   %1 = spv.constant dense<-4> : vector<2xsi32>
-  // CHECK: {{.*}} = llvm.mlir.constant(dense<[2, 3, 4]> : vector<3xi32>) : !llvm.vec<3 x i32>
+  // CHECK: llvm.mlir.constant(dense<[2, 3, 4]> : vector<3xi32>) : !llvm.vec<3 x i32>
   %2 = spv.constant dense<[2, 3, 4]> : vector<3xui32>
   return
 }
 
+// CHECK-LABEL: @float_constant_scalar
 func @float_constant_scalar() {
-  // CHECK: {{.*}} = llvm.mlir.constant(5.000000e+00 : f16) : !llvm.half
+  // CHECK: llvm.mlir.constant(5.000000e+00 : f16) : !llvm.half
   %0 = spv.constant 5.000000e+00 : f16
-  // CHECK: {{.*}} = llvm.mlir.constant(5.000000e+00 : f64) : !llvm.double
+  // CHECK: llvm.mlir.constant(5.000000e+00 : f64) : !llvm.double
   %1 = spv.constant 5.000000e+00 : f64
   return
 }
 
+// CHECK-LABEL: @float_constant_vector
 func @float_constant_vector() {
-  // CHECK: {{.*}} = llvm.mlir.constant(dense<[2.000000e+00, 3.000000e+00]> : vector<2xf32>) : !llvm.vec<2 x float>
+  // CHECK: llvm.mlir.constant(dense<[2.000000e+00, 3.000000e+00]> : vector<2xf32>) : !llvm.vec<2 x float>
   %0 = spv.constant dense<[2.000000e+00, 3.000000e+00]> : vector<2xf32>
   return
 }

mlir/test/Conversion/SPIRVToLLVM/func-ops-to-llvm.mlir

 // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // spv.Return
 //===----------------------------------------------------------------------===//
 
+// CHECK-LABEL: @return
 func @return() {
-  // CHECK: llvm.return
-  spv.Return
+  // CHECK: llvm.return
+  spv.Return
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ReturnValue
 //===----------------------------------------------------------------------===//
 
+// CHECK-LABEL: @return_value
 func @return_value(%arg: i32) {
-  // CHECK: llvm.return %{{.*}} : !llvm.i32
-  spv.ReturnValue %arg : i32
+  // CHECK: llvm.return %{{.*}} : !llvm.i32
+  spv.ReturnValue %arg : i32
 }
 
 //===----------------------------------------------------------------------===//
 // spv.func
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: llvm.func @none()
 spv.func @none() -> () "None" {
-  spv.Return
+  spv.Return
 }
 
 // CHECK-LABEL: llvm.func @inline() attributes {passthrough = ["alwaysinline"]}
 spv.func @inline() -> () "Inline" {
-  spv.Return
+  spv.Return
 }
 
 // CHECK-LABEL: llvm.func @dont_inline() attributes {passthrough = ["noinline"]}
 spv.func @dont_inline() -> () "DontInline" {
-  spv.Return
+  spv.Return
 }
 
 // CHECK-LABEL: llvm.func @pure() attributes {passthrough = ["readonly"]}
 spv.func @pure() -> () "Pure" {
-  spv.Return
+  spv.Return
 }
 
 // CHECK-LABEL: llvm.func @const() attributes {passthrough = ["readnone"]}
 spv.func @const() -> () "Const" {
-  spv.Return
+  spv.Return
 }
 
 // CHECK-LABEL: llvm.func @scalar_types(%arg0: !llvm.i32, %arg1: !llvm.i1, %arg2: !llvm.double, %arg3: !llvm.float)
 spv.func @scalar_types(%arg0: i32, %arg1: i1, %arg2: f64, %arg3: f32) -> () "None" {
-  spv.Return
+  spv.Return
 }
 
 // CHECK-LABEL: llvm.func @vector_types(%arg0: !llvm.vec<2 x i64>, %arg1: !llvm.vec<2 x i64>) -> !llvm.vec<2 x i64>
 spv.func @vector_types(%arg0: vector<2xi64>, %arg1: vector<2xi64>) -> vector<2xi64> "None" {
-  %0 = spv.IAdd %arg0, %arg1 : vector<2xi64>
-  spv.ReturnValue %0 : vector<2xi64>
+  %0 = spv.IAdd %arg0, %arg1 : vector<2xi64>
+  spv.ReturnValue %0 : vector<2xi64>
 }
 
 //===----------------------------------------------------------------------===//
 // spv.FunctionCall
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: llvm.func @function_calls
 // CHECK-SAME: %[[ARG0:.*]]: !llvm.i32, %[[ARG1:.*]]: !llvm.i1, %[[ARG2:.*]]: !llvm.double, %[[ARG3:.*]]: !llvm.vec<2 x i64>, %[[ARG4:.*]]: !llvm.vec<2 x float>
 spv.func @function_calls(%arg0: i32, %arg1: i1, %arg2: f64, %arg3: vector<2xi64>, %arg4: vector<2xf32>) -> () "None" {
-  // CHECK: llvm.call @void_1() : () -> ()
-  spv.FunctionCall @void_1() : () -> ()
-  // CHECK: llvm.call @void_2(%[[ARG3]]) : (!llvm.vec<2 x i64>) -> ()
-  spv.FunctionCall @void_2(%arg3) : (vector<2xi64>) -> ()
-  // CHECK: %{{.*}} = llvm.call @value_scalar(%[[ARG0]], %[[ARG1]], %[[ARG2]]) : (!llvm.i32, !llvm.i1, !llvm.double) -> !llvm.i32
-  %0 = spv.FunctionCall @value_scalar(%arg0, %arg1, %arg2) : (i32, i1, f64) -> i32
-  // CHECK: %{{.*}} = llvm.call @value_vector(%[[ARG3]], %[[ARG4]]) : (!llvm.vec<2 x i64>, !llvm.vec<2 x float>) -> !llvm.vec<2 x float>
-  %1 = spv.FunctionCall @value_vector(%arg3, %arg4) : (vector<2xi64>, vector<2xf32>) -> vector<2xf32>
-  spv.Return
+  // CHECK: llvm.call @void_1() : () -> ()
+  // CHECK: llvm.call @void_2(%[[ARG3]]) : (!llvm.vec<2 x i64>) -> ()
+  // CHECK: llvm.call @value_scalar(%[[ARG0]], %[[ARG1]], %[[ARG2]]) : (!llvm.i32, !llvm.i1, !llvm.double) -> !llvm.i32
+  // CHECK: llvm.call @value_vector(%[[ARG3]], %[[ARG4]]) : (!llvm.vec<2 x i64>, !llvm.vec<2 x float>) -> !llvm.vec<2 x float>
+  spv.FunctionCall @void_1() : () -> ()
+  spv.FunctionCall @void_2(%arg3) : (vector<2xi64>) -> ()
+  %0 = spv.FunctionCall @value_scalar(%arg0, %arg1, %arg2) : (i32, i1, f64) -> i32
+  %1 = spv.FunctionCall @value_vector(%arg3, %arg4) : (vector<2xi64>, vector<2xf32>) -> vector<2xf32>
+  spv.Return
 }
 
 spv.func @void_1() -> () "None" {
   spv.Return
 }
 
 spv.func @void_2(%arg0: vector<2xi64>) -> () "None" {
   spv.Return

mlir/test/Conversion/SPIRVToLLVM/memory-ops-to-llvm.mlir

 // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // spv.Load
 //===----------------------------------------------------------------------===//
 
+// CHECK-LABEL: @load
 func @load() {
   %0 = spv.Variable : !spv.ptr<f32, Function>
-  //  CHECK: %{{.*}} = llvm.load %{{.*}} : !llvm.ptr<float>
+  //  CHECK: llvm.load %{{.*}} : !llvm.ptr<float>
   %1 = spv.Load "Function" %0 : f32
   return
 }
 
+// CHECK-LABEL: @load_none
 func @load_none() {
   %0 = spv.Variable : !spv.ptr<f32, Function>
-  //  CHECK: %{{.*}} = llvm.load %{{.*}} : !llvm.ptr<float>
+  //  CHECK: llvm.load %{{.*}} : !llvm.ptr<float>
   %1 = spv.Load "Function" %0 ["None"] : f32
   return
 }
 
+// CHECK-LABEL: @load_with_alignment
 func @load_with_alignment() {
   %0 = spv.Variable : !spv.ptr<f32, Function>
-  // CHECK: %{{.*}} = llvm.load %{{.*}} {alignment = 4 : i64} : !llvm.ptr<float>
+  // CHECK: llvm.load %{{.*}} {alignment = 4 : i64} : !llvm.ptr<float>
   %1 = spv.Load "Function" %0 ["Aligned", 4] : f32
   return
 }
 
+// CHECK-LABEL: @load_volatile
 func @load_volatile() {
   %0 = spv.Variable : !spv.ptr<f32, Function>
-  // CHECK: %{{.*}} = llvm.load volatile %{{.*}} : !llvm.ptr<float>
+  // CHECK: llvm.load volatile %{{.*}} : !llvm.ptr<float>
   %1 = spv.Load "Function" %0 ["Volatile"] : f32
   return
 }
 
+// CHECK-LABEL: @load_nontemporal
 func @load_nontemporal() {
   %0 = spv.Variable : !spv.ptr<f32, Function>
-  // CHECK: %{{.*}} = llvm.load %{{.*}} {nontemporal} : !llvm.ptr<float>
+  // CHECK: llvm.load %{{.*}} {nontemporal} : !llvm.ptr<float>
   %1 = spv.Load "Function" %0 ["Nontemporal"] : f32
   return
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Store
 //===----------------------------------------------------------------------===//
 
+// CHECK-LABEL: @store
 func @store(%arg0 : f32) -> () {
   %0 = spv.Variable : !spv.ptr<f32, Function>
   // CHECK: llvm.store %{{.*}}, %{{.*}} : !llvm.ptr<float>
   spv.Store "Function" %0, %arg0 : f32
   return
 }
 
+// CHECK-LABEL: @store_composite
 func @store_composite(%arg0 : !spv.struct<f64>) -> () {
   %0 = spv.Variable : !spv.ptr<!spv.struct<f64>, Function>
   // CHECK: llvm.store %{{.*}}, %{{.*}} : !llvm.ptr<struct<packed (double)>>
   spv.Store "Function" %0, %arg0 : !spv.struct<f64>
   return
 }
 
+// CHECK-LABEL: @store_with_alignment
 func @store_with_alignment(%arg0 : f32) -> () {
   %0 = spv.Variable : !spv.ptr<f32, Function>
   // CHECK: llvm.store %{{.*}}, %{{.*}} {alignment = 4 : i64} : !llvm.ptr<float>
   spv.Store "Function" %0, %arg0 ["Aligned", 4] : f32
   return
 }
 
+// CHECK-LABEL: @store_volatile
 func @store_volatile(%arg0 : f32) -> () {
   %0 = spv.Variable : !spv.ptr<f32, Function>
   // CHECK: llvm.store volatile %{{.*}}, %{{.*}} : !llvm.ptr<float>
   spv.Store "Function" %0, %arg0 ["Volatile"] : f32
   return
 }
 
+// CHECK-LABEL: @store_nontemporal
 func @store_nontemporal(%arg0 : f32) -> () {
   %0 = spv.Variable : !spv.ptr<f32, Function>
   // CHECK: llvm.store %{{.*}}, %{{.*}} {nontemporal} : !llvm.ptr<float>
   spv.Store "Function" %0, %arg0 ["Nontemporal"] : f32
   return
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Variable
 //===----------------------------------------------------------------------===//
 
+// CHECK-LABEL: @variable_scalar
 func @variable_scalar() {
   // CHECK: %[[SIZE1:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32
-  // CHECK: %{{.*}} = llvm.alloca %[[SIZE1]] x !llvm.float : (!llvm.i32) -> !llvm.ptr<float>
+  // CHECK: llvm.alloca %[[SIZE1]] x !llvm.float : (!llvm.i32) -> !llvm.ptr<float>
   %0 = spv.Variable : !spv.ptr<f32, Function>
   // CHECK: %[[SIZE2:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32
-  // CHECK: %{{.*}} = llvm.alloca %[[SIZE2]] x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8>
+  // CHECK: llvm.alloca %[[SIZE2]] x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8>
   %1 = spv.Variable : !spv.ptr<i8, Function>
   return
 }
 
+// CHECK-LABEL: @variable_scalar_with_initialization
 func @variable_scalar_with_initialization() {
   // CHECK: %[[VALUE:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64
   // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32
   // CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x !llvm.i64 : (!llvm.i32) -> !llvm.ptr<i64>
   // CHECK: llvm.store %[[VALUE]], %[[ALLOCATED]] : !llvm.ptr<i64>
   %c = spv.constant 0 : i64
   %0 = spv.Variable init(%c) : !spv.ptr<i64, Function>
   return
 }
 
+// CHECK-LABEL: @variable_vector
 func @variable_vector() {
   // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32
-  // CHECK: %{{.*}} = llvm.alloca  %[[SIZE]] x !llvm.vec<3 x float> : (!llvm.i32) -> !llvm.ptr<vec<3 x float>>
+  // CHECK: llvm.alloca  %[[SIZE]] x !llvm.vec<3 x float> : (!llvm.i32) -> !llvm.ptr<vec<3 x float>>
   %0 = spv.Variable : !spv.ptr<vector<3xf32>, Function>
   return
 }
 
+// CHECK-LABEL: @variable_vector_with_initialization
 func @variable_vector_with_initialization() {
   // CHECK: %[[VALUE:.*]] = llvm.mlir.constant(dense<false> : vector<3xi1>) : !llvm.vec<3 x i1>
   // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32
   // CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x !llvm.vec<3 x i1> : (!llvm.i32) -> !llvm.ptr<vec<3 x i1>>
   // CHECK: llvm.store %[[VALUE]], %[[ALLOCATED]] : !llvm.ptr<vec<3 x i1>>
   %c = spv.constant dense<false> : vector<3xi1>
   %0 = spv.Variable init(%c) : !spv.ptr<vector<3xi1>, Function>
   return
 }
 
+// CHECK-LABEL: @variable_array
 func @variable_array() {
   // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32
-  // CHECK: %{{.*}} = llvm.alloca %[[SIZE]] x !llvm.array<10 x i32> : (!llvm.i32) -> !llvm.ptr<array<10 x i32>>
+  // CHECK: llvm.alloca %[[SIZE]] x !llvm.array<10 x i32> : (!llvm.i32) -> !llvm.ptr<array<10 x i32>>
   %0 = spv.Variable : !spv.ptr<!spv.array<10 x i32>, Function>
   return
 }

mlir/test/Conversion/SPIRVToLLVM/misc-ops-to-llvm.mlir

 // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // spv.Select
 //===----------------------------------------------------------------------===//
 
+// CHECK-LABEL: @select_scalar
 func @select_scalar(%arg0: i1, %arg1: vector<3xi32>, %arg2: f32) {
-  // CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.vec<3 x i32>
-  %0 = spv.Select %arg0, %arg1, %arg1 : i1, vector<3xi32>
-  // CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.float
-  %1 = spv.Select %arg0, %arg2, %arg2 : i1, f32
+  // CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.vec<3 x i32>
+  %0 = spv.Select %arg0, %arg1, %arg1 : i1, vector<3xi32>
+  // CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.float
+  %1 = spv.Select %arg0, %arg2, %arg2 : i1, f32
   return
 }
 
+// CHECK-LABEL: @select_vector
 func @select_vector(%arg0: vector<2xi1>, %arg1: vector<2xi32>) {
-  // CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.vec<2 x i1>, !llvm.vec<2 x i32>
-  %0 = spv.Select %arg0, %arg1, %arg1 : vector<2xi1>, vector<2xi32>
+  // CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.vec<2 x i1>, !llvm.vec<2 x i32>
+  %0 = spv.Select %arg0, %arg1, %arg1 : vector<2xi1>, vector<2xi32>
   return
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Undef
 //===----------------------------------------------------------------------===//
 
+// CHECK-LABEL: @undef_scalar
 func @undef_scalar() {
-  // CHECK: %{{.*}} = llvm.mlir.undef : !llvm.float
-  %0 = spv.undef : f32
-  return
+  // CHECK: llvm.mlir.undef : !llvm.float
+  %0 = spv.undef : f32
+  return
 }
 
+// CHECK-LABEL: @undef_vector
 func @undef_vector() {
-  // CHECK: %{{.*}} = llvm.mlir.undef : !llvm.vec<2 x i32>
-  %0 = spv.undef : vector<2xi32>
-  return
+  // CHECK: llvm.mlir.undef : !llvm.vec<2 x i32>
+  %0 = spv.undef : vector<2xi32>
+  return
 }

mlir/test/Conversion/SPIRVToLLVM/shift-ops-to-llvm.mlir

+// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
+
+//===----------------------------------------------------------------------===//
+// spv.ShiftRightArithmetic
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @shift_right_arithmetic_scalar
+func @shift_right_arithmetic_scalar(%arg0: i32, %arg1: si32, %arg2 : i16, %arg3 : ui16) {
+  // CHECK: llvm.ashr %{{.*}}, %{{.*}} : !llvm.i32
+  %0 = spv.ShiftRightArithmetic %arg0, %arg0 : i32, i32
+
+  // CHECK: llvm.ashr %{{.*}}, %{{.*}} : !llvm.i32
+  %1 = spv.ShiftRightArithmetic %arg0, %arg1 : i32, si32
+
+  // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32
+  // CHECK: llvm.ashr %{{.*}}, %[[SEXT]] : !llvm.i32
+  %2 = spv.ShiftRightArithmetic %arg0, %arg2 : i32, i16
+
+  // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32
+  // CHECK: llvm.ashr %{{.*}}, %[[ZEXT]] : !llvm.i32
+  %3 = spv.ShiftRightArithmetic %arg0, %arg3 : i32, ui16
+  return
+}
+
+// CHECK-LABEL: @shift_right_arithmetic_vector
+func @shift_right_arithmetic_vector(%arg0: vector<4xi64>, %arg1: vector<4xui64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) {
+  // CHECK: llvm.ashr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
+  %0 = spv.ShiftRightArithmetic %arg0, %arg0 : vector<4xi64>, vector<4xi64>
+
+  // CHECK: llvm.ashr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
+  %1 = spv.ShiftRightArithmetic %arg0, %arg1 : vector<4xi64>, vector<4xui64>
+
+  // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
+  // CHECK: llvm.ashr %{{.*}}, %[[SEXT]] : !llvm.vec<4 x i64>
+  %2 = spv.ShiftRightArithmetic %arg0, %arg2 : vector<4xi64>,  vector<4xi32>
+
+  // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
+  // CHECK: llvm.ashr %{{.*}}, %[[ZEXT]] : !llvm.vec<4 x i64>
+  %3 = spv.ShiftRightArithmetic %arg0, %arg3 : vector<4xi64>, vector<4xui32>
+  return
+}
+
+//===----------------------------------------------------------------------===//
+// spv.ShiftRightLogical
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @shift_right_logical_scalar
+func @shift_right_logical_scalar(%arg0: i32, %arg1: si32, %arg2 : si16, %arg3 : ui16) {
+  // CHECK: llvm.lshr %{{.*}}, %{{.*}} : !llvm.i32
+  %0 = spv.ShiftRightLogical %arg0, %arg0 : i32, i32
+
+  // CHECK: llvm.lshr %{{.*}}, %{{.*}} : !llvm.i32
+  %1 = spv.ShiftRightLogical %arg0, %arg1 : i32, si32
+
+  // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32
+  // CHECK: llvm.lshr %{{.*}}, %[[SEXT]] : !llvm.i32
+  %2 = spv.ShiftRightLogical %arg0, %arg2 : i32, si16
+
+  // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32
+  // CHECK: llvm.lshr %{{.*}}, %[[ZEXT]] : !llvm.i32
+  %3 = spv.ShiftRightLogical %arg0, %arg3 : i32, ui16
+  return
+}
+
+// CHECK-LABEL: @shift_right_logical_vector
+func @shift_right_logical_vector(%arg0: vector<4xi64>, %arg1: vector<4xsi64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) {
+  // CHECK: llvm.lshr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
+  %0 = spv.ShiftRightLogical %arg0, %arg0 : vector<4xi64>, vector<4xi64>
+
+  // CHECK: llvm.lshr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
+  %1 = spv.ShiftRightLogical %arg0, %arg1 : vector<4xi64>, vector<4xsi64>
+
+  // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
+  // CHECK: llvm.lshr %{{.*}}, %[[SEXT]] : !llvm.vec<4 x i64>
+  %2 = spv.ShiftRightLogical %arg0, %arg2 : vector<4xi64>,  vector<4xi32>
+
+  // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
+  // CHECK: llvm.lshr %{{.*}}, %[[ZEXT]] : !llvm.vec<4 x i64>
+  %3 = spv.ShiftRightLogical %arg0, %arg3 : vector<4xi64>, vector<4xui32>
+  return
+}
+
+//===----------------------------------------------------------------------===//
+// spv.ShiftLeftLogical
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @shift_left_logical_scalar
+func @shift_left_logical_scalar(%arg0: i32, %arg1: si32, %arg2 : i16, %arg3 : ui16) {
+  // CHECK: llvm.shl %{{.*}}, %{{.*}} : !llvm.i32
+  %0 = spv.ShiftLeftLogical %arg0, %arg0 : i32, i32
+
+  // CHECK: llvm.shl %{{.*}}, %{{.*}} : !llvm.i32
+  %1 = spv.ShiftLeftLogical %arg0, %arg1 : i32, si32
+
+  // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32
+  // CHECK: llvm.shl %{{.*}}, %[[SEXT]] : !llvm.i32
+  %2 = spv.ShiftLeftLogical %arg0, %arg2 : i32, i16
+
+  // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32
+  // CHECK: llvm.shl %{{.*}}, %[[ZEXT]] : !llvm.i32
+  %3 = spv.ShiftLeftLogical %arg0, %arg3 : i32, ui16
+  return
+}
+
+// CHECK-LABEL: @shift_left_logical_vector
+func @shift_left_logical_vector(%arg0: vector<4xi64>, %arg1: vector<4xsi64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) {
+  // CHECK: llvm.shl %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
+  %0 = spv.ShiftLeftLogical %arg0, %arg0 : vector<4xi64>, vector<4xi64>
+
+  // CHECK: llvm.shl %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
+  %1 = spv.ShiftLeftLogical %arg0, %arg1 : vector<4xi64>, vector<4xsi64>
+
+  // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
+  // CHECK: llvm.shl %{{.*}}, %[[SEXT]] : !llvm.vec<4 x i64>
+  %2 = spv.ShiftLeftLogical %arg0, %arg2 : vector<4xi64>,  vector<4xi32>
+
+  // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
+  // CHECK: llvm.shl %{{.*}}, %[[ZEXT]] : !llvm.vec<4 x i64>
+  %3 = spv.ShiftLeftLogical %arg0, %arg3 : vector<4xi64>, vector<4xui32>
+  return
+}

mlir/test/Conversion/SPIRVToLLVM/shifts-to-llvm.mlir

-// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
-
-//===----------------------------------------------------------------------===//
-// spv.ShiftRightArithmetic
-//===----------------------------------------------------------------------===//
-
-func @shift_right_arithmetic_scalar(%arg0: i32, %arg1: si32, %arg2 : i16, %arg3 : ui16) {
-  // CHECK: %{{.*}} = llvm.ashr %{{.*}}, %{{.*}} : !llvm.i32
-  %0 = spv.ShiftRightArithmetic %arg0, %arg0 : i32, i32
-
-    // CHECK: %{{.*}} = llvm.ashr %{{.*}}, %{{.*}} : !llvm.i32
-  %1 = spv.ShiftRightArithmetic %arg0, %arg1 : i32, si32
-
-    // CHECK: %[[EXT1:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32
-    // CHECK: %{{.*}} = llvm.ashr %{{.*}}, %[[EXT1:.*]]: !llvm.i32
-  %2 = spv.ShiftRightArithmetic %arg0, %arg2 : i32, i16
-
-    // CHECK: %[[EXT2:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32
-    // CHECK: %{{.*}} = llvm.ashr %{{.*}}, %[[EXT2:.*]]: !llvm.i32
-  %3 = spv.ShiftRightArithmetic %arg0, %arg3 : i32, ui16
-  return
-}
-
-func @shift_right_arithmetic_vector(%arg0: vector<4xi64>, %arg1: vector<4xui64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) {
-  // CHECK: %{{.*}} = llvm.ashr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
-  %0 = spv.ShiftRightArithmetic %arg0, %arg0 : vector<4xi64>, vector<4xi64>
-
-    // CHECK: %{{.*}} = llvm.ashr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
-  %1 = spv.ShiftRightArithmetic %arg0, %arg1 : vector<4xi64>, vector<4xui64>
-
-    // CHECK: %[[EXT1:.*]] = llvm.sext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
-    // CHECK: %{{.*}} = llvm.ashr %{{.*}}, %[[EXT1:.*]]: !llvm.vec<4 x i64>
-  %2 = spv.ShiftRightArithmetic %arg0, %arg2 : vector<4xi64>,  vector<4xi32>
-
-    // CHECK: %[[EXT2:.*]] = llvm.zext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
-    // CHECK: %{{.*}} = llvm.ashr %{{.*}}, %[[EXT2:.*]]: !llvm.vec<4 x i64>
-  %3 = spv.ShiftRightArithmetic %arg0, %arg3 : vector<4xi64>, vector<4xui32>
-  return
-}
-
-//===----------------------------------------------------------------------===//
-// spv.ShiftRightLogical
-//===----------------------------------------------------------------------===//
-
-func @shift_right_logical_scalar(%arg0: i32, %arg1: si32, %arg2 : si16, %arg3 : ui16) {
-  // CHECK: %{{.*}} = llvm.lshr %{{.*}}, %{{.*}} : !llvm.i32
-  %0 = spv.ShiftRightLogical %arg0, %arg0 : i32, i32
-
-    // CHECK: %{{.*}} = llvm.lshr %{{.*}}, %{{.*}} : !llvm.i32
-  %1 = spv.ShiftRightLogical %arg0, %arg1 : i32, si32
-
-    // CHECK: %[[EXT1:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32
-    // CHECK: %{{.*}} = llvm.lshr %{{.*}}, %[[EXT1:.*]]: !llvm.i32
-  %2 = spv.ShiftRightLogical %arg0, %arg2 : i32, si16
-
-    // CHECK: %[[EXT2:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32
-    // CHECK: %{{.*}} = llvm.lshr %{{.*}}, %[[EXT2:.*]]: !llvm.i32
-  %3 = spv.ShiftRightLogical %arg0, %arg3 : i32, ui16
-  return
-}
-
-func @shift_right_logical_vector(%arg0: vector<4xi64>, %arg1: vector<4xsi64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) {
-  // CHECK: %{{.*}} = llvm.lshr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
-  %0 = spv.ShiftRightLogical %arg0, %arg0 : vector<4xi64>, vector<4xi64>
-
-    // CHECK: %{{.*}} = llvm.lshr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
-  %1 = spv.ShiftRightLogical %arg0, %arg1 : vector<4xi64>, vector<4xsi64>
-
-    // CHECK: %[[EXT1:.*]] = llvm.sext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
-    // CHECK: %{{.*}} = llvm.lshr %{{.*}}, %[[EXT1:.*]]: !llvm.vec<4 x i64>
-  %2 = spv.ShiftRightLogical %arg0, %arg2 : vector<4xi64>,  vector<4xi32>
-
-    // CHECK: %[[EXT2:.*]] = llvm.zext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
-    // CHECK: %{{.*}} = llvm.lshr %{{.*}}, %[[EXT2:.*]]: !llvm.vec<4 x i64>
-  %3 = spv.ShiftRightLogical %arg0, %arg3 : vector<4xi64>, vector<4xui32>
-  return
-}
-
-//===----------------------------------------------------------------------===//
-// spv.ShiftLeftLogical
-//===----------------------------------------------------------------------===//
-
-func @shift_left_logical_scalar(%arg0: i32, %arg1: si32, %arg2 : i16, %arg3 : ui16) {
-  // CHECK: %{{.*}} = llvm.shl %{{.*}}, %{{.*}} : !llvm.i32
-  %0 = spv.ShiftLeftLogical %arg0, %arg0 : i32, i32
-
-    // CHECK: %{{.*}} = llvm.shl %{{.*}}, %{{.*}} : !llvm.i32
-  %1 = spv.ShiftLeftLogical %arg0, %arg1 : i32, si32
-
-    // CHECK: %[[EXT1:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32
-    // CHECK: %{{.*}} = llvm.shl %{{.*}}, %[[EXT1:.*]]: !llvm.i32
-  %2 = spv.ShiftLeftLogical %arg0, %arg2 : i32, i16
-
-    // CHECK: %[[EXT2:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32
-    // CHECK: %{{.*}} = llvm.shl %{{.*}}, %[[EXT2:.*]]: !llvm.i32
-  %3 = spv.ShiftLeftLogical %arg0, %arg3 : i32, ui16
-  return
-}
-
-func @shift_left_logical_vector(%arg0: vector<4xi64>, %arg1: vector<4xsi64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) {
-  // CHECK: %{{.*}} = llvm.shl %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
-  %0 = spv.ShiftLeftLogical %arg0, %arg0 : vector<4xi64>, vector<4xi64>
-
-    // CHECK: %{{.*}} = llvm.shl %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
-  %1 = spv.ShiftLeftLogical %arg0, %arg1 : vector<4xi64>, vector<4xsi64>
-
-    // CHECK: %[[EXT1:.*]] = llvm.sext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
-    // CHECK: %{{.*}} = llvm.shl %{{.*}}, %[[EXT1:.*]]: !llvm.vec<4 x i64>
-  %2 = spv.ShiftLeftLogical %arg0, %arg2 : vector<4xi64>,  vector<4xi32>
-
-    // CHECK: %[[EXT2:.*]] = llvm.zext %{{.*}} : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
-    // CHECK: %{{.*}} = llvm.shl %{{.*}}, %[[EXT2:.*]]: !llvm.vec<4 x i64>
-  %3 = spv.ShiftLeftLogical %arg0, %arg3 : vector<4xi64>, vector<4xui32>
-  return
-}

mlir/test/Conversion/SPIRVToLLVM/spirv-types-to-llvm-invalid.mlir

 // RUN: mlir-opt %s -convert-spirv-to-llvm -verify-diagnostics -split-input-file
 
 // expected-error@+1 {{failed to legalize operation 'spv.func' that was explicitly marked illegal}}
 spv.func @array_with_stride(%arg: !spv.array<4 x f32, stride=4>) -> () "None" {
   spv.Return
 }
 
 // -----
 
 // expected-error@+1 {{failed to legalize operation 'spv.func' that was explicitly marked illegal}}
 spv.func @struct_with_offset1(%arg: !spv.struct<i32[0], i32[4]>) -> () "None" {
   spv.Return
 }
 
 // -----
 
 // expected-error@+1 {{failed to legalize operation 'spv.func' that was explicitly marked illegal}}
 spv.func @struct_with_offset2(%arg: !spv.struct<i32[0], i32[8]>) -> () "None" {
   spv.Return
 }
 
 // -----
 
 // expected-error@+1 {{failed to legalize operation 'spv.func' that was explicitly marked illegal}}
 spv.func @struct_with_decorations(%arg: !spv.struct<f32 [RelaxedPrecision]>) -> () "None" {
   spv.Return
 }