[NFC] Split mlir-tblgen tests into a `td` and an `mlir` folder

[jurahul]

Summary

• This enables segregation of tests that depend on just mlir-tblgen from tests that depend on mlir-opt

[mehdi_amini]

Fine with me, but can you include the motivation, it isn't straightforward from the current description.

[jurahul]

I think I found a way to achieve what I was trying to do without moving these files around. As such, abandoning this review.

mlir/test/mlir-tblgen/mlir/interfaces.mlir

 // RUN: mlir-opt -test-type-interfaces -allow-unregistered-dialect -verify-diagnostics %s
 
 // expected-remark@below {{'!test.test_type' - TestA}}
 // expected-remark@below {{'!test.test_type' - TestB}}
 // expected-remark@below {{'!test.test_type' - TestC}}
 // expected-remark@below {{'!test.test_type' - TestD}}
 // expected-remark@below {{'!test.test_type' - TestE}}
 %foo0 = "foo.test"() : () -> (!test.test_type)
 
 // Type without the test interface.
 %foo1 = "foo.test"() : () -> (i32)

mlir/test/mlir-tblgen/mlir/op-derived-attribute.mlir

 // RUN: mlir-opt -test-derived-attr -verify-diagnostics %s | FileCheck %s
 
 // CHECK-LABEL: verifyDerivedAttributes
 func @verifyDerivedAttributes() {
   // expected-remark @+2 {{element_dtype = f32}}
   // expected-remark @+1 {{size = 320}}
   %0 = "test.derived_type_attr"() : () -> tensor<10xf32>
   // expected-remark @+2 {{element_dtype = i79}}
   // expected-remark @+1 {{size = 948}}
   %1 = "test.derived_type_attr"() : () -> tensor<12xi79>
 
   return
 }

mlir/test/mlir-tblgen/mlir/op-format.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s | mlir-opt -allow-unregistered-dialect -verify-diagnostics | FileCheck %s
 
 // CHECK: %[[I64:.*]] =
 %i64 = "foo.op"() : () -> (i64)
 // CHECK: %[[MEMREF:.*]] =
 %memref = "foo.op"() : () -> (memref<1xf64>)
 
 // CHECK: test.format_literal_op keyword_$. -> :, = <> () [] {foo.some_attr}
 test.format_literal_op keyword_$. -> :, = <> () [] {foo.some_attr}
 
 // CHECK: test.format_attr_op 10
 // CHECK-NOT: {attr
 test.format_attr_op 10
 
 // CHECK: test.format_opt_attr_op(10)
 // CHECK-NOT: {opt_attr
 test.format_opt_attr_op(10)
 
 // CHECK: test.format_attr_dict_w_keyword attributes {attr = 10 : i64}
 test.format_attr_dict_w_keyword attributes {attr = 10 : i64}
 
 // CHECK: test.format_attr_dict_w_keyword attributes {attr = 10 : i64, opt_attr = 10 : i64}
 test.format_attr_dict_w_keyword attributes {attr = 10 : i64, opt_attr = 10 : i64}
 
 // CHECK: test.format_buildable_type_op %[[I64]]
 %ignored = test.format_buildable_type_op %i64
 
 //===----------------------------------------------------------------------===//
 // Format results
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_result_a_op memref<1xf64>
 %ignored_a:2 = test.format_result_a_op memref<1xf64>
 
 // CHECK: test.format_result_b_op i64, memref<1xf64>
 %ignored_b:2 = test.format_result_b_op i64, memref<1xf64>
 
 // CHECK: test.format_result_c_op (i64) -> memref<1xf64>
 %ignored_c:2 = test.format_result_c_op (i64) -> memref<1xf64>
 
 //===----------------------------------------------------------------------===//
 // Format operands
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_operand_a_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_a_op %i64, %memref : i64, memref<1xf64>
 
 // CHECK: test.format_operand_b_op %[[I64]], %[[MEMREF]] : memref<1xf64>
 test.format_operand_b_op %i64, %memref : memref<1xf64>
 
 // CHECK: test.format_operand_c_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_c_op %i64, %memref : i64, memref<1xf64>
 
 // CHECK: test.format_operand_d_op %[[I64]], %[[MEMREF]] : memref<1xf64>
 test.format_operand_d_op %i64, %memref : memref<1xf64>
 
 // CHECK: test.format_operand_e_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_e_op %i64, %memref : i64, memref<1xf64>
 
 //===----------------------------------------------------------------------===//
 // Format successors
 //===----------------------------------------------------------------------===//
 
 "foo.successor_test_region"() ( {
   ^bb0:
     // CHECK: test.format_successor_a_op ^bb1 {attr}
     test.format_successor_a_op ^bb1 {attr}
 
   ^bb1:
     // CHECK: test.format_successor_a_op ^bb1, ^bb2 {attr}
     test.format_successor_a_op ^bb1, ^bb2 {attr}
 
   ^bb2:
     // CHECK: test.format_successor_a_op {attr}
     test.format_successor_a_op {attr}
 
 }) { arg_names = ["i", "j", "k"] } : () -> ()
 
 //===----------------------------------------------------------------------===//
 // Format optional operands and results
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_optional_operand_result_a_op(%[[I64]] : i64) : i64
 test.format_optional_operand_result_a_op(%i64 : i64) : i64
 
 // CHECK: test.format_optional_operand_result_a_op( : ) : i64
 test.format_optional_operand_result_a_op( : ) : i64
 
 // CHECK: test.format_optional_operand_result_a_op(%[[I64]] : i64) :
 // CHECK-NOT: i64
 test.format_optional_operand_result_a_op(%i64 : i64) :
 
 // CHECK: test.format_optional_operand_result_a_op(%[[I64]] : i64) : [%[[I64]], %[[I64]]]
 test.format_optional_operand_result_a_op(%i64 : i64) : [%i64, %i64]
 
 // CHECK: test.format_optional_operand_result_b_op(%[[I64]] : i64) : i64
 test.format_optional_operand_result_b_op(%i64 : i64) : i64
 
 // CHECK: test.format_optional_operand_result_b_op : i64
 test.format_optional_operand_result_b_op( : ) : i64
 
 // CHECK: test.format_optional_operand_result_b_op : i64
 test.format_optional_operand_result_b_op : i64
 
 //===----------------------------------------------------------------------===//
 // Format trait type inference
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_infer_variadic_type_from_non_variadic %[[I64]], %[[I64]] : i64
 test.format_infer_variadic_type_from_non_variadic %i64, %i64 : i64
 
 //===----------------------------------------------------------------------===//
 // AllTypesMatch type inference
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_all_types_match_var %[[I64]], %[[I64]] : i64
 %ignored_res1 = test.format_all_types_match_var %i64, %i64 : i64
 
 // CHECK: test.format_all_types_match_attr 1 : i64, %[[I64]]
 %ignored_res2 = test.format_all_types_match_attr 1 : i64, %i64
 
 //===----------------------------------------------------------------------===//
 // TypesMatchWith type inference
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_types_match_var %[[I64]] : i64
 %ignored_res3 = test.format_types_match_var %i64 : i64
 
 // CHECK: test.format_types_match_attr 1 : i64
 %ignored_res4 = test.format_types_match_attr 1 : i64

mlir/test/mlir-tblgen/mlir/pattern.mlir

 // RUN: mlir-opt -test-patterns -mlir-print-debuginfo %s | FileCheck %s
 
 // CHECK-LABEL: verifyFusedLocs
 func @verifyFusedLocs(%arg0 : i32) -> i32 {
   %0 = "test.op_a"(%arg0) {attr = 10 : i32} : (i32) -> i32 loc("a")
   %result = "test.op_a"(%0) {attr = 20 : i32} : (i32) -> i32 loc("b")
 
   // CHECK: "test.op_b"(%arg0) {attr = 10 : i32} : (i32) -> i32 loc("a")
   // CHECK: "test.op_b"(%arg0) {attr = 20 : i32} : (i32) -> i32 loc(fused["b", "a"])
   return %result : i32
 }
 
 // CHECK-LABEL: verifyDesignatedLoc
 func @verifyDesignatedLoc(%arg0 : i32) -> i32 {
   %0 = "test.loc_src"(%arg0) : (i32) -> i32 loc("loc3")
   %1 = "test.loc_src"(%0) : (i32) -> i32 loc("loc2")
   %2 = "test.loc_src"(%1) : (i32) -> i32 loc("loc1")
 
   // CHECK: "test.loc_dst"({{.*}}) : (i32) -> i32 loc("loc1")
   // CHECK: "test.loc_dst"({{.*}}) : (i32) -> i32 loc("named")
   // CHECK: "test.loc_dst"({{.*}}) : (i32) -> i32 loc(fused<"fused">["loc2", "loc3"])
   return %1 : i32
 }
 
 // CHECK-LABEL: verifyZeroResult
 func @verifyZeroResult(%arg0 : i32) {
   // CHECK: "test.op_i"(%arg0) : (i32) -> ()
   "test.op_h"(%arg0) : (i32) -> ()
   return
 }
 
 // CHECK-LABEL: verifyZeroArg
 func @verifyZeroArg() -> i32 {
   // CHECK: "test.op_k"() : () -> i32
   %0 = "test.op_j"() : () -> i32
   return %0 : i32
 }
 
 // CHECK-LABEL: testIgnoreArgMatch
 // CHECK-SAME: (%{{[a-z0-9]*}}: i32, %[[ARG1:[a-z0-9]*]]: i32
 func @testIgnoreArgMatch(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: f32) {
   // CHECK: "test.ignore_arg_match_dst"(%[[ARG1]]) {f = 15 : i64}
   "test.ignore_arg_match_src"(%arg0, %arg1, %arg2) {d = 42, e = 24, f = 15} : (i32, i32, i32) -> ()
 
   // CHECK: test.ignore_arg_match_src
   // Not match because wrong type for $c.
   "test.ignore_arg_match_src"(%arg0, %arg1, %arg3) {d = 42, e = 24, f = 15} : (i32, i32, f32) -> ()
 
   // CHECK: test.ignore_arg_match_src
   // Not match because wrong type for $f.
   "test.ignore_arg_match_src"(%arg0, %arg1, %arg2) {d = 42 : i32, e = 24, f = 15} : (i32, i32, i32) -> ()
   return
 }
 
 // CHECK-LABEL: verifyInterleavedOperandAttribute
 // CHECK-SAME:    %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32
 func @verifyInterleavedOperandAttribute(%arg0: i32, %arg1: i32) {
   // CHECK: "test.interleaved_operand_attr2"(%[[ARG0]], %[[ARG1]]) {attr1 = 15 : i64, attr2 = 42 : i64}
   "test.interleaved_operand_attr1"(%arg0, %arg1) {attr1 = 15, attr2 = 42} : (i32, i32) -> ()
   return
 }
 
 // CHECK-LABEL: verifyBenefit
 func @verifyBenefit(%arg0 : i32) -> i32 {
   %0 = "test.op_d"(%arg0) : (i32) -> i32
   %1 = "test.op_g"(%arg0) : (i32) -> i32
   %2 = "test.op_g"(%1) : (i32) -> i32
 
   // CHECK: "test.op_f"(%arg0)
   // CHECK: "test.op_b"(%arg0) {attr = 34 : i32}
   return %0 : i32
 }
 
 // CHECK-LABEL: verifyNativeCodeCall
 func @verifyNativeCodeCall(%arg0: i32, %arg1: i32) -> (i32, i32) {
   // CHECK: %0 = "test.native_code_call2"(%arg0) {attr = [42, 24]} : (i32) -> i32
   // CHECK:  return %0, %arg1
   %0 = "test.native_code_call1"(%arg0, %arg1) {choice = true, attr1 = 42, attr2 = 24} : (i32, i32) -> (i32)
   %1 = "test.native_code_call1"(%arg0, %arg1) {choice = false, attr1 = 42, attr2 = 24} : (i32, i32) -> (i32)
   return %0, %1: i32, i32
 }
 
 // CHECK-LABEL: verifyAuxiliaryNativeCodeCall
 func @verifyAuxiliaryNativeCodeCall(%arg0: i32) -> (i32) {
   // CHECK: test.op_i
   // CHECK: test.op_k
   %0 = "test.native_code_call3"(%arg0) : (i32) -> (i32)
   return %0 : i32
 }
 
 // CHECK-LABEL: verifyAllAttrConstraintOf
 func @verifyAllAttrConstraintOf() -> (i32, i32, i32) {
   // CHECK: "test.all_attr_constraint_of2"
   %0 = "test.all_attr_constraint_of1"() {attr = [0, 1]} : () -> (i32)
   // CHECK: "test.all_attr_constraint_of1"
   %1 = "test.all_attr_constraint_of1"() {attr = [0, 2]} : () -> (i32)
   // CHECK: "test.all_attr_constraint_of1"
   %2 = "test.all_attr_constraint_of1"() {attr = [-1, 1]} : () -> (i32)
   return %0, %1, %2: i32, i32, i32
 }
 
 // CHECK-LABEL: verifyManyArgs
 // CHECK-SAME: (%[[ARG:.*]]: i32)
 func @verifyManyArgs(%arg: i32) {
   // CHECK: "test.many_arguments"(%[[ARG]], %[[ARG]], %[[ARG]], %[[ARG]], %[[ARG]], %[[ARG]], %[[ARG]], %[[ARG]], %[[ARG]])
   // CHECK-SAME: {attr1 = 24 : i64, attr2 = 42 : i64, attr3 = 42 : i64, attr4 = 42 : i64, attr5 = 42 : i64, attr6 = 42 : i64, attr7 = 42 : i64, attr8 = 42 : i64, attr9 = 42 : i64}
   "test.many_arguments"(%arg, %arg, %arg, %arg, %arg, %arg, %arg, %arg, %arg) {
     attr1 = 42, attr2 = 42, attr3 = 42, attr4 = 42, attr5 = 42,
     attr6 = 42, attr7 = 42, attr8 = 42, attr9 = 42
   } : (i32, i32, i32, i32, i32, i32, i32, i32, i32) -> ()
   return
 }
 
 //===----------------------------------------------------------------------===//
 // Test Symbol Binding
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: symbolBinding
 func @symbolBinding(%arg0: i32) -> i32 {
   // An op with one use is matched.
   // CHECK: %0 = "test.symbol_binding_b"(%arg0)
   // CHECK: %1 = "test.symbol_binding_c"(%0)
   // CHECK: %2 = "test.symbol_binding_d"(%0, %1) {attr = 42 : i64}
   %0 = "test.symbol_binding_a"(%arg0) {attr = 42} : (i32) -> (i32)
 
   // An op without any use is not matched.
   // CHECK: "test.symbol_binding_a"(%arg0)
   %1 = "test.symbol_binding_a"(%arg0) {attr = 42} : (i32) -> (i32)
 
   // CHECK: return %2
   return %0: i32
 }
 
 // CHECK-LABEL: symbolBindingNoResult
 func @symbolBindingNoResult(%arg0: i32) {
   // CHECK: test.symbol_binding_b
   "test.symbol_binding_no_result"(%arg0) : (i32) -> ()
   return
 }
 
 //===----------------------------------------------------------------------===//
 // Test Attributes
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: succeedMatchOpAttr
 func @succeedMatchOpAttr() -> i32 {
   // CHECK: "test.match_op_attribute2"() {default_valued_attr = 3 : i32, more_attr = 4 : i32, optional_attr = 2 : i32, required_attr = 1 : i32}
   %0 = "test.match_op_attribute1"() {required_attr = 1: i32, optional_attr = 2: i32, default_valued_attr = 3: i32, more_attr = 4: i32} : () -> (i32)
   return %0: i32
 }
 
 // CHECK-LABEL: succeedMatchMissingOptionalAttr
 func @succeedMatchMissingOptionalAttr() -> i32 {
   // CHECK: "test.match_op_attribute2"() {default_valued_attr = 3 : i32, more_attr = 4 : i32, required_attr = 1 : i32}
   %0 = "test.match_op_attribute1"() {required_attr = 1: i32, default_valued_attr = 3: i32, more_attr = 4: i32} : () -> (i32)
   return %0: i32
 }
 
 // CHECK-LABEL: succeedMatchMissingDefaultValuedAttr
 func @succeedMatchMissingDefaultValuedAttr() -> i32 {
   // CHECK: "test.match_op_attribute2"() {default_valued_attr = 42 : i32, more_attr = 4 : i32, optional_attr = 2 : i32, required_attr = 1 : i32}
   %0 = "test.match_op_attribute1"() {required_attr = 1: i32, optional_attr = 2: i32, more_attr = 4: i32} : () -> (i32)
   return %0: i32
 }
 
 // CHECK-LABEL: failedMatchAdditionalConstraintNotSatisfied
 func @failedMatchAdditionalConstraintNotSatisfied() -> i32 {
   // CHECK: "test.match_op_attribute1"()
   %0 = "test.match_op_attribute1"() {required_attr = 1: i32, optional_attr = 2: i32, more_attr = 5: i32} : () -> (i32)
   return %0: i32
 }
 
 // CHECK-LABEL: verifyConstantAttr
 func @verifyConstantAttr(%arg0 : i32) -> i32 {
   // CHECK: "test.op_b"(%arg0) {attr = 17 : i32} : (i32) -> i32 loc("a")
   %0 = "test.op_c"(%arg0) : (i32) -> i32 loc("a")
   return %0 : i32
 }
 
 // CHECK-LABEL: verifyUnitAttr
 func @verifyUnitAttr() -> (i32, i32) {
   // Unit attribute present in the matched op is propagated as attr2.
   // CHECK: "test.match_op_attribute4"() {attr1, attr2} : () -> i32
   %0 = "test.match_op_attribute3"() {attr} : () -> i32
 
   // Since the original op doesn't have the unit attribute, the new op
   // only has the constant-constructed unit attribute attr1.
   // CHECK: "test.match_op_attribute4"() {attr1} : () -> i32
   %1 = "test.match_op_attribute3"() : () -> i32
   return %0, %1 : i32, i32
 }
 
 //===----------------------------------------------------------------------===//
 // Test Enum Attributes
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: verifyStrEnumAttr
 func @verifyStrEnumAttr() -> i32 {
   // CHECK: "test.str_enum_attr"() {attr = "B"}
   %0 = "test.str_enum_attr"() {attr = "A"} : () -> i32
   return %0 : i32
 }
 
 // CHECK-LABEL: verifyI32EnumAttr
 func @verifyI32EnumAttr() -> i32 {
   // CHECK: "test.i32_enum_attr"() {attr = 10 : i32}
   %0 = "test.i32_enum_attr"() {attr = 5: i32} : () -> i32
   return %0 : i32
 }
 
 // CHECK-LABEL: verifyI64EnumAttr
 func @verifyI64EnumAttr() -> i32 {
   // CHECK: "test.i64_enum_attr"() {attr = 10 : i64}
   %0 = "test.i64_enum_attr"() {attr = 5: i64} : () -> i32
   return %0 : i32
 }
 
 //===----------------------------------------------------------------------===//
 // Test ElementsAttr
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: rewrite_i32elementsattr
 func @rewrite_i32elementsattr() -> () {
   // CHECK: attr = dense<0> : tensor<i32>
   "test.i32ElementsAttr"() {attr = dense<[3, 5]>:tensor<2xi32>} : () -> ()
   return
 }
 
 // CHECK-LABEL: rewrite_f64elementsattr
 func @rewrite_f64elementsattr() -> () {
   "test.float_elements_attr"() {
     // Should match
     // CHECK: scalar_f32_attr = dense<[5.000000e+00, 6.000000e+00]> : tensor<2xf32>
     scalar_f32_attr = dense<[3.0, 4.0]> : tensor<2xf32>,
     tensor_f64_attr = dense<6.0> : tensor<4x8xf64>
   } : () -> ()
 
   "test.float_elements_attr"() {
     // Should not match
     // CHECK: scalar_f32_attr = dense<7.000000e+00> : tensor<2xf32>
     scalar_f32_attr = dense<7.0> : tensor<2xf32>,
     tensor_f64_attr = dense<3.0> : tensor<4x8xf64>
   } : () -> ()
   return
 }
 
 //===----------------------------------------------------------------------===//
 // Test Multi-result Ops
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @useMultiResultOpToReplaceWhole
 func @useMultiResultOpToReplaceWhole() -> (i32, f32, f32) {
   // CHECK: %[[A:.*]], %[[B:.*]], %[[C:.*]] = "test.another_three_result"()
   // CHECK: return %[[A]], %[[B]], %[[C]]
   %0:3 = "test.three_result"() {kind = 1} : () -> (i32, f32, f32)
   return %0#0, %0#1, %0#2 : i32, f32, f32
 }
 
 // CHECK-LABEL: @useMultiResultOpToReplacePartial1
 func @useMultiResultOpToReplacePartial1() -> (i32, f32, f32) {
   // CHECK: %[[A:.*]], %[[B:.*]] = "test.two_result"()
   // CHECK: %[[C:.*]] = "test.one_result1"()
   // CHECK: return %[[A]], %[[B]], %[[C]]
   %0:3 = "test.three_result"() {kind = 2} : () -> (i32, f32, f32)
   return %0#0, %0#1, %0#2 : i32, f32, f32
 }
 
 // CHECK-LABEL: @useMultiResultOpToReplacePartial2
 func @useMultiResultOpToReplacePartial2() -> (i32, f32, f32) {
   // CHECK: %[[A:.*]] = "test.one_result2"()
   // CHECK: %[[B:.*]], %[[C:.*]] = "test.another_two_result"()
   // CHECK: return %[[A]], %[[B]], %[[C]]
   %0:3 = "test.three_result"() {kind = 3} : () -> (i32, f32, f32)
   return %0#0, %0#1, %0#2 : i32, f32, f32
 }
 
 // CHECK-LABEL: @useMultiResultOpResultsSeparately
 func @useMultiResultOpResultsSeparately() -> (i32, f32, f32) {
   // CHECK: %[[A:.*]], %[[B:.*]] = "test.two_result"()
   // CHECK: %[[C:.*]] = "test.one_result1"()
   // CHECK: %[[D:.*]], %[[E:.*]] = "test.two_result"()
   // CHECK: return %[[A]], %[[C]], %[[E]]
   %0:3 = "test.three_result"() {kind = 4} : () -> (i32, f32, f32)
   return %0#0, %0#1, %0#2 : i32, f32, f32
 }
 
 // CHECK-LABEL: @constraintOnSourceOpResult
 func @constraintOnSourceOpResult() -> (i32, f32, i32) {
   // CHECK: %[[A:.*]], %[[B:.*]] = "test.two_result"()
   // CHECK: %[[C:.*]] = "test.one_result2"()
   // CHECK: %[[D:.*]] = "test.one_result1"()
   // CHECK: return %[[A]], %[[B]], %[[C]]
   %0:2 = "test.two_result"() {kind = 5} : () -> (i32, f32)
   %1:2 = "test.two_result"() {kind = 5} : () -> (i32, f32)
   return %0#0, %0#1, %1#0 : i32, f32, i32
 }
 
 // CHECK-LABEL: @useAuxiliaryOpToReplaceMultiResultOp
 func @useAuxiliaryOpToReplaceMultiResultOp() -> (i32, f32, f32) {
   // An auxiliary op is generated to help building the op for replacing the
   // matched op.
   // CHECK: %[[A:.*]], %[[B:.*]] = "test.two_result"()
 
   // CHECK: %[[C:.*]] = "test.one_result3"(%[[B]])
   // CHECK: %[[D:.*]], %[[E:.*]] = "test.another_two_result"()
   // CHECK: return %[[C]], %[[D]], %[[E]]
   %0:3 = "test.three_result"() {kind = 6} : () -> (i32, f32, f32)
   return %0#0, %0#1, %0#2 : i32, f32, f32
 }
 
 //===----------------------------------------------------------------------===//
 // Test Multi-result Ops
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @replaceOneVariadicOutOneVariadicInOp
 func @replaceOneVariadicOutOneVariadicInOp(%arg0: i32, %arg1: i32, %arg2: i32) -> (i32, i32, i32, i32, i32, i32) {
   // CHECK: %[[cnt1:.*]] = "test.one_variadic_out_one_variadic_in2"(%arg0)
   // CHECK: %[[cnt2:.*]]:2 = "test.one_variadic_out_one_variadic_in2"(%arg0, %arg1)
   // CHECK: %[[cnt3:.*]]:3 = "test.one_variadic_out_one_variadic_in2"(%arg0, %arg1, %arg2)
   // CHECK: return %[[cnt1]], %[[cnt2]]#0, %[[cnt2]]#1, %[[cnt3]]#0, %[[cnt3]]#1, %[[cnt3]]#2
 
   %0   = "test.one_variadic_out_one_variadic_in1"(%arg0) : (i32) -> (i32)
   %1:2 = "test.one_variadic_out_one_variadic_in1"(%arg0, %arg1) : (i32, i32) -> (i32, i32)
   %2:3 = "test.one_variadic_out_one_variadic_in1"(%arg0, %arg1, %arg2) : (i32, i32, i32) -> (i32, i32, i32)
   return %0, %1#0, %1#1, %2#0, %2#1, %2#2 : i32, i32, i32, i32, i32, i32
 }
 
 // CHECK-LABEL: @replaceMixedVariadicInputOp
 func @replaceMixedVariadicInputOp(%arg0: i32, %arg1: f32, %arg2: i32) -> () {
   // CHECK: "test.mixed_variadic_in2"(%arg1)
   // CHECK: "test.mixed_variadic_in2"(%arg0, %arg1, %arg2)
   // CHECK: "test.mixed_variadic_in2"(%arg0, %arg0, %arg1, %arg2, %arg2)
 
   "test.mixed_variadic_in1"(%arg1) : (f32) -> ()
   "test.mixed_variadic_in1"(%arg0, %arg1, %arg2) : (i32, f32, i32) -> ()
   "test.mixed_variadic_in1"(%arg0, %arg0, %arg1, %arg2, %arg2) : (i32, i32, f32, i32, i32) -> ()
   return
 }
 
 // CHECK-LABEL: @replaceMixedVariadicOutputOp
 func @replaceMixedVariadicOutputOp() -> (f32, i32, f32, i32, i32, i32, f32, i32, i32) {
   // CHECK: %[[cnt1:.*]] = "test.mixed_variadic_out2"()
   // CHECK: %[[cnt3_a:.*]], %[[cnt3_b:.*]], %[[cnt3_c:.*]] = "test.mixed_variadic_out2"()
   // CHECK: %[[cnt5_a:.*]]:2, %[[cnt5_b:.*]], %[[cnt5_c:.*]]:2 = "test.mixed_variadic_out2"()
   // CHECK: return %[[cnt1]], %[[cnt3_a]], %[[cnt3_b]], %[[cnt3_c]], %[[cnt5_a]]#0, %[[cnt5_a]]#1, %[[cnt5_b]], %[[cnt5_c]]#0, %[[cnt5_c]]#1
 
   %0   = "test.mixed_variadic_out1"() : () -> (f32)
   %1:3 = "test.mixed_variadic_out1"() : () -> (i32, f32, i32)
   %2:5 = "test.mixed_variadic_out1"() : () -> (i32, i32, f32, i32, i32)
   return %0, %1#0, %1#1, %1#2, %2#0, %2#1, %2#2, %2#3, %2#4 : f32, i32, f32, i32, i32, i32, f32, i32, i32
 }
 
 // CHECK-LABEL: @generateVariadicOutputOpInNestedPattern
 func @generateVariadicOutputOpInNestedPattern() -> (i32) {
   // CHECK: %[[cnt5_a:.*]], %[[cnt5_b:.*]]:2, %[[cnt5_c:.*]]:2 = "test.mixed_variadic_out3"()
   // CHECK: %[[res:.*]] = "test.mixed_variadic_in3"(%[[cnt5_a]], %[[cnt5_b]]#0, %[[cnt5_b]]#1, %[[cnt5_c]]#0, %[[cnt5_c]]#1)
   // CHECK: return %[[res]]
 
   %0 = "test.one_i32_out"() : () -> (i32)
   return %0 : i32
 }
 
 //===----------------------------------------------------------------------===//
 // Test that natives calls are only called once during rewrites.
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: redundantTest
 func @redundantTest(%arg0: i32) -> i32 {
   %0 = "test.op_m"(%arg0) : (i32) -> i32
   // CHECK: "test.op_m"(%arg0) {optional_attr = 314159265 : i32} : (i32) -> i32
   return %0 : i32
 }

mlir/test/mlir-tblgen/mlir/return-types.mlir

 // RUN: mlir-opt %s -test-return-type -split-input-file -verify-diagnostics | FileCheck %s
 
 // CHECK-LABEL: testCreateFunctions
 // This function tests invoking the create method with different inference
 // methods. The attributes of the ops inside are used to test creation.
 func @testCreateFunctions(%arg0 : tensor<10xf32>, %arg1 : tensor<20xi32>) {
 // CHECK: "test.no_attributes"
   %good = "test.no_attributes"(%arg0, %arg0) : (tensor<10xf32>, tensor<10xf32>) -> tensor<10xf32>
 // CHECK: "test.op_with_shaped_type_infer_type_if"
 // CHECK-SAME: (tensor<10xf32>, tensor<10xf32>) -> tensor<10xi17>
 // CHECK: "test.op_with_shaped_type_infer_type_if"
 // CHECK-SAME: (tensor<10xf32>, tensor<20xi32>) -> tensor<10xi17>
 // CHECK: "test.op_with_shaped_type_infer_type_if"
 // CHECK-SAME: (tensor<20xi32>, tensor<10xf32>) -> tensor<20xi17>
 // CHECK: "test.op_with_shaped_type_infer_type_if"
 // CHECK-SAME: (tensor<20xi32>, tensor<20xi32>) -> tensor<20xi17>
 // CHECK: "test.op_with_infer_type_if"
 // CHECK-SAME: (tensor<10xf32>, tensor<10xf32>) -> tensor<10xf32>
 // CHECK: "test.op_with_infer_type_if"
 // CHECK-SAME: (tensor<20xi32>, tensor<20xi32>) -> tensor<20xi32>
   return
 }
 
 // -----
 
 func @testReturnTypeOpInterface(%arg0 : tensor<10xf32>) {
   // expected-error@+1 {{incompatible with return type}}
   %bad = "test.op_with_infer_type_if"(%arg0, %arg0) : (tensor<10xf32>, tensor<10xf32>) -> tensor<*xf32>
   return
 }
 
 // -----
 
 func @testReturnTypeOpInterfaceMismatch(%arg0 : tensor<10xf32>, %arg1 : tensor<20xf32>) {
   // expected-error@+1 {{operand type mismatch}}
   %bad = "test.op_with_infer_type_if"(%arg0, %arg1) : (tensor<10xf32>, tensor<20xf32>) -> tensor<*xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: testReifyFunctions
 func @testReifyFunctions(%arg0 : tensor<10xf32>, %arg1 : tensor<20xf32>) {
   // expected-remark@+1 {{constant 10}}
   %0 = "test.op_with_shaped_type_infer_type_if"(%arg0, %arg1) : (tensor<10xf32>, tensor<20xf32>) -> tensor<10xi17>
   // expected-remark@+1 {{constant 20}}
   %1 = "test.op_with_shaped_type_infer_type_if"(%arg1, %arg0) : (tensor<20xf32>, tensor<10xf32>) -> tensor<20xi17>
   return
 }

mlir/test/mlir-tblgen/mlir/types.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics | FileCheck %s
 
 func @correct_int_types_success() {
   "test.int_types"() : () -> (i16, si32, ui64, i8)
   "test.int_types"() : () -> (si16, si32, ui64, ui64)
   "test.int_types"() : () -> (ui16, si32, ui64, si128)
   return
 }
 
 // -----
 
 func @wrong_int_type_signedness_failure() {
   // expected-error @+1 {{result #1 must be 32-bit signed integer, but got 'ui32'}}
   "test.int_types"() : () -> (ui16, ui32, ui64, si8)
   return
 }
 
 // -----
 
 func @wrong_int_type_signedness_failure() {
   // expected-error @+1 {{result #2 must be 64-bit unsigned integer, but got 'si64'}}
   "test.int_types"() : () -> (ui16, si32, si64, ui8)
   return
 }
 
 // -----
 
 func @wrong_int_type_failure() {
   // expected-error @+1 {{result #0 must be 16-bit integer, but got 'f16'}}
   "test.int_types"() : () -> (f16, si32, ui64, i16)
   return
 }
 
 // -----
 
 func @wrong_int_type_failure() {
   // expected-error @+1 {{result #3 must be integer, but got 'f64'}}
   "test.int_types"() : () -> (i16, si32, ui64, f64)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @complex_f64_success
 func @complex_f64_success() {
   "test.complex_f64"() : () -> (complex<f64>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @complex_f64_tensor_success
 func @complex_f64_tensor_success() {
   "test.complex_f64_tensor"() : () -> (tensor<complex<f64>>)
   return
 }
 
 // -----
 
 func @complex_f64_failure() {
   // expected-error@+1 {{must be complex type with 64-bit float elements}}
   "test.complex_f64"() : () -> (f64)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @tuple_success
 func @tuple_success() {
   "test.tuple_32_bit"() : () -> (tuple<i32>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @tuple_mixed_success
 func @tuple_mixed_success() {
   "test.tuple_32_bit"() : () -> (tuple<i32, f32>)
   return
 }
 
 // -----
 
 func @tuple_empty_success() {
   "test.tuple_32_bit"() : () -> (tuple<>)
   return
 }
 
 // -----
 
 func @tuple_wrong_type_scalar() {
   // expected-error@+1 {{must be tuple with any combination of 32-bit signless integer or 32-bit float values}}
   "test.tuple_32_bit"() : () -> (tuple<i64>)
   return
 }
 
 // -----
 
 func @tuple_wrong_type_tensor() {
   // expected-error@+1 {{must be tuple with any combination of 32-bit signless integer or 32-bit float values}}
   "test.tuple_32_bit"() : () -> (tuple<tensor<i32>>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @nested_tuple_empty_success
 func @nested_tuple_empty_success() {
   "test.nested_tuple_32_bit"() : () -> (tuple<>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @nested_tuple_one_level_success
 func @nested_tuple_one_level_success() {
   "test.nested_tuple_32_bit"() : () -> (tuple<i32>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @nested_tuple_multi_level_success
 func @nested_tuple_multi_level_success() {
   "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<i32, tuple<i32>>>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @nested_tuple_multi_level_mixed_success
 func @nested_tuple_multi_level_mixed_success() {
   "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<f32, tuple<i32>>>)
   return
 }
 
 // -----
 
 func @nested_tuple_multi_level_wrong_type() {
   // expected-error@+1 {{must be nested tuple with any combination of 32-bit signless integer or 32-bit float values}}
   "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<i32, tuple<i64>>>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @rank_less_than_2_I8_F32_memref_success
 func @rank_less_than_2_I8_F32_memref_success() {
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<i8>)
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<3xi8>)
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<f32>)
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<1xf32>)
   return
 }
 
 // -----
 
 func @rank_less_than_2_I8_F32_memref_bad_type() {
   // expected-error@+1 {{must be 0D/1D memref of 8-bit signless integer or 32-bit float values}}
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<i16>)
   return
 }
 
 // -----
 
 func @rank_less_than_2_I8_F32_memref_bad_rank() {
   // expected-error@+1 {{must be 0D/1D memref of 8-bit signless integer or 32-bit float values}}
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<1x2xi8>)
   return
 }
 
 // -----
 
 func @nd_tensor_of_success(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi16>) {
   "test.nd_tensor_of"(%arg0, %arg1, %arg2, %arg3, %arg4) : (tensor<f32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<70x80x90x100xi16>) -> ()
   return
 }
 
 // -----
 
 func @nd_tensor_of_success_wrong_type_0d(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi32>) {
   // expected-error @+1 {{'test.nd_tensor_of' op operand #0 must be 0D tensor of 32-bit float values}}
   "test.nd_tensor_of"(%arg1, %arg1, %arg2, %arg3, %arg4) : (tensor<10xf32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<70x80x90x100xi32>) -> ()
   return
 }
 
 // -----
 
 func @nd_tensor_of_success_wrong_type_4d(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi32>) {
   // expected-error @+1 {{'test.nd_tensor_of' op operand #4 must be 4D tensor of 16-bit signless integer values}}
   "test.nd_tensor_of"(%arg0, %arg1, %arg2, %arg3, %arg3) : (tensor<f32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<40x50x60xi16>) -> ()
   return
 }
 
 // -----
 
 func @ranked_tensor_success(%arg0: tensor<i8>, %arg1: tensor<1xi32>, %arg2: tensor<?x?xf32>) {
   "test.ranked_tensor_op"(%arg0) : (tensor<i8>) -> ()
   "test.ranked_tensor_op"(%arg1) : (tensor<1xi32>) -> ()
   "test.ranked_tensor_op"(%arg2) : (tensor<?x?xf32>) -> ()
   return
 }
 
 // -----
 
 func @ranked_tensor_success(%arg0: tensor<*xf32>) {
   // expected-error @+1 {{must be ranked tensor of any type values}}
   "test.ranked_tensor_op"(%arg0) : (tensor<*xf32>) -> ()
   return
 }
 
 // -----
 
 func @ranked_tensor_success(%arg0: vector<2xf32>) {
   // expected-error @+1 {{must be ranked tensor of any type values}}
   "test.ranked_tensor_op"(%arg0) : (vector<2xf32>) -> ()
   return
 }
 
 // -----
 
 func @multi_tensor_rank_of_success(%arg0: tensor<i8>, %arg1: tensor<i32>, %arg2: tensor<f32>, %arg3: tensor<1xi8>, %arg4: tensor<1xi32>, %arg5: tensor<1xf32>) {
   "test.multi_tensor_rank_of"(%arg0) : (tensor<i8>) -> ()
   "test.multi_tensor_rank_of"(%arg1) : (tensor<i32>) -> ()
   "test.multi_tensor_rank_of"(%arg2) : (tensor<f32>) -> ()
   "test.multi_tensor_rank_of"(%arg3) : (tensor<1xi8>) -> ()
   "test.multi_tensor_rank_of"(%arg4) : (tensor<1xi32>) -> ()
   "test.multi_tensor_rank_of"(%arg5) : (tensor<1xf32>) -> ()
   return
 }
 
 // -----
 
 func @multi_tensor_rank_of_wrong_unranked_type(%arg0: tensor<2x2xi8>) {
   // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit signless integer or 32-bit signless integer or 32-bit float values}}
   "test.multi_tensor_rank_of"(%arg0) : (tensor<2x2xi8>) -> ()
   return
 }
 
 // -----
 
 func @multi_tensor_rank_of_wrong_element_type(%arg0: tensor<2xi16>) {
   // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit signless integer or 32-bit signless integer or 32-bit float values}}
   "test.multi_tensor_rank_of"(%arg0) : (tensor<2xi16>) -> ()
   return
 }
 
 // -----
 
 // CHECK-LABEL: @fixed_element_types
 func @fixed_element_types(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>, %mi32 : memref<2x3xi32>, %vf32 : vector<2xf32>) {
   "test.arg_and_res_have_fixed_element_types"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i16>
   "test.arg_and_res_have_fixed_element_types"(%mi32, %vf32) : (memref<2x3xi32>, vector<2xf32>) -> memref<1x2xi16>
   return
 }
 
 // -----
 
 func @fixed_element_types(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
   // expected-error@+1 {{'res' is 16-bit signless integer}}
   "test.arg_and_res_have_fixed_element_types"(%arg0, %arg1) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i32>
   return
 }
 
 // -----
 
 func @fixed_element_types(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
   // expected-error@+1 {{fixed type combination}}
   "test.arg_and_res_have_fixed_element_types"(%arg1, %arg0) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x i16>
   return
 }
 
 // -----
 
 // CHECK-LABEL: same_element_types_success
 func @same_element_types_success(%ti32: tensor<* x i32>, %i32 : i32, %mi32 : memref<2x3xi32>) {
   "test.operands_have_same_element_type"(%ti32, %ti32): (tensor<* x i32>, tensor<* x i32>) -> ()
   "test.operands_have_same_element_type"(%i32, %ti32): (i32, tensor<* x i32>) -> ()
   "test.operands_have_same_element_type"(%i32, %mi32): (i32, memref<2x3xi32>) -> ()
   return
 }
 
 
 // -----
 
 func @same_element_types_failure(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
   // expected-error@+1 {{verify that all of {x, y} have same element type}}
   "test.operands_have_same_element_type"(%arg1, %arg0): (tensor<* x f32>, tensor<* x i32>) -> ()
   return
 }
 
 // -----
 
 // CHECK-LABEL: same_element_types_success
 func @same_element_types_success(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
   "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x f32>
   "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> memref<2x3xf32>
   "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> f32
   return
 }
 
 // -----
 
 func @same_element_types_failure(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
   // expected-error@+1 {{all of {x, res} have same element type}}
   "test.operand0_and_result_have_same_element_type"(%arg1, %arg0) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x i32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: same_types
 func @same_types(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
   "test.operands_have_same_type"(%ti32, %ti32) : (tensor<* x i32>, tensor<* x i32>) -> ()
   "test.operand0_and_result_have_same_type"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i32>
   return
 }
 
 // -----
 
 func @same_types_failure(%ti32: tensor<* x i32>, %i32: i32) {
   // expected-error@+1 {{all of {x, y} have same type}}
   "test.operands_have_same_type"(%ti32, %i32) : (tensor<* x i32>, i32) -> ()
   return
 }
 
 // -----
 
 func @same_types_element_mismatch(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
   // expected-error@+1 {{all of {x, y} have same type}}
   "test.operands_have_same_type"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> ()
   return
 }
 
 // -----
 
 func @same_types_shape_mismatch(%arg0: tensor<1x2xi32>, %arg1: tensor<2x1xi32>) {
   // expected-error@+1 {{all of {x, y} have same type}}
   "test.operands_have_same_type"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<2x1xi32>) -> ()
   return
 }
 
 // -----
 
 // CHECK-LABEL: same_rank_success
 func @same_rank_success(%t1xi : tensor<1xi32>, %t2xf : tensor<2xf32>, %m3xi : memref<3xi32>, %t1x2xf : tensor<1x2xf32>, %t1x2xi : tensor<1x2xi32>) {
   "test.operands_have_same_rank"(%t1xi, %t2xf) : (tensor<1xi32>, tensor<2xf32>) -> ()
   "test.operands_have_same_rank"(%t1xi, %m3xi) : (tensor<1xi32>, memref<3xi32>) -> ()
   "test.operand0_and_result_have_same_rank"(%t1xi, %t1x2xf) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<3xf32>)
   "test.operand0_and_result_have_same_rank"(%t1x2xi, %t1x2xf) : (tensor<1x2xi32>, tensor<1x2xf32>) -> (tensor<3x3xf64>)
   return
 }
 
 // -----
 
 func @same_rank_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
   // expected-error@+1 {{all of {x, y} have same rank}}
   "test.operands_have_same_rank"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> ()
   return
 }
 
 // -----
 
 func @same_rank_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
   // expected-error@+1 {{all of {x, res} have same rank}}
   "test.operand0_and_result_have_same_rank"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<i32>)
   return
 }
 
 // -----
 
 func @same_rank_failure(%arg0: tensor<1x2xi32>, %arg1: tensor<1x2xf32>) {
   // expected-error@+1 {{all of {x, res} have same rank}}
   "test.operand0_and_result_have_same_rank"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<1x2xf32>) -> (tensor<3xi32>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: same_shape_success
 func @same_shape_success(%t2x3: tensor<2x3xi32>, %m2x3: memref<2x3xf32>, %v2x3 : vector<2x3xi32>, %t4x5 : tensor<4x5xi32>) {
   "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (tensor<2x3xf32>)
   "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (memref<2x3xf32>)
   "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (vector<2x3xf32>)
   return
 }
 
 // -----
 
 func @same_shape_failure(%t2x3: tensor<2x3xi32>, %t4x5 : tensor<4x5xi32>) {
   // expected-error@+1 {{all of {x, res} have same shape}}
   "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (tensor<1x3xf32>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: same_element_count_success
 func @same_element_count_success(%arg0: tensor<36xi32>, %arg1: tensor<1x2xf32>, %arg3: tensor<f32>) {
   "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<36xi32>, tensor<1x2xf32>) -> (tensor<3x4x3xf32>)
   "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<36xi32>, tensor<1x2xf32>) -> (tensor<3x12xf64>)
   "test.operand0_and_result_have_same_element_count"(%arg3, %arg1) : (tensor<f32>, tensor<1x2xf32>) -> (memref<1x1x1xi32>)
   return
 }
 
 // -----
 
 func @same_element_count_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
   // expected-error@+1 {{all of {x, res} have same element count}}
   "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<2xi32>)
   return
 }
 
 // -----
 
 func @four_equals_five() {
   // expected-error@+1 {{failed to verify that 4 equals 5}}
   "test.four_equals_five"() : () -> ()
   return
 }
 
 // -----
 
 func @operand_rank_equals_result_size_success(%arg : tensor<1x2x3x4xi32>) {
   "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> tensor<4xi32>
   "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> memref<2x2xf32>
   return
 }
 
 // -----
 
 func @operand_rank_equals_result_size_failure(%arg : tensor<1x2x3x4xi32>) {
   // expected-error@+1 {{failed to verify that operand rank equals result size}}
   "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> tensor<2xi32>
   return
 }
 
 // -----
 
 func @same_types_element_mismatch(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
   // expected-error@+1 {{type incompatible with return type of operation}}
   "test.operand0_and_result_have_same_type"(%arg0, %arg1) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x f32>
   return
 }
 
 // -----
 
 func @same_types_shape_mismatch(%arg0: tensor<1x2xi32>, %arg1: tensor<2x1xi32>) {
   // expected-error@+1 {{type incompatible with return type of operation}}
   "test.operand0_and_result_have_same_type"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<2x1xi32>
   return
 }
 
 // -----
 
 func @does_not_have_i32(%arg0: tensor<1x2xi32>, %arg1: none) {
   // expected-error@+1 {{either both none type operands or first is not none}}
   "test.if_first_operand_is_none_then_so_is_second"(%arg1, %arg0) : (none, tensor<1x2xi32>) -> ()
   return
 }
 
 // -----
 
 func @does_not_have_static_memref(%arg0: memref<?xi32>) {
   // expected-error@+1 {{'test.takes_static_memref' op operand #0 must be statically shaped memref of any type values}}
   "test.takes_static_memref"(%arg0) : (memref<?xi32>) -> ()
 }
 
 // -----
 
 func @elements_attr_not_i32_f32() {
   // expected-error@+1 {{32-bit signless integer elements attribute}}
   "test.i32ElementsAttr"() {attr = dense<[1.0, 20.0]>:tensor<2xf32>} : () -> ()
   return
 }
 
 // -----
 
 func @elements_attr_not_i32_i64() {
   // expected-error@+1 {{32-bit signless integer elements attribute}}
   "test.i32ElementsAttr"() {attr = dense<[1, 20]>:tensor<2xi64>} : () -> ()
   return
 }
 
 
 // -----
 
 func @elements_attr_i32(%arg0: tensor<1x2xi32>) {
   "test.i32ElementsAttr"() {attr = dense<[1, 2]>:tensor<2xi32>} : () -> ()
   return
 }
 
 // -----
 
 func @elements_attr_index() {
   "test.indexElementsAttr"() {attr = dense<[1, 2]>:tensor<2xindex>} : () -> ()
   return
 }
 
 // -----
 
 func @elements_attr_not_index() {
   // expected-error@+1 {{index elements attribute}}
   "test.indexElementsAttr"() {attr = dense<[1, 2]>:tensor<2xi32>} : () -> ()
   return
 }

mlir/test/mlir-tblgen/td/dialect.td

-// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
-// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
+// RUN: mlir-tblgen -gen-op-decls -I %S/../../../include %s | FileCheck %s --check-prefix=DECL
+// RUN: mlir-tblgen -gen-op-defs -I %S/../../../include %s | FileCheck %s --check-prefix=DEF
 
 include "mlir/IR/OpBase.td"
 
 // Check using the dialect name as the namespace
 def A_Dialect : Dialect {
   let name = "a";
 }
 

mlir/test/mlir-tblgen/td/expect-symbol.td

-// RUN: not mlir-tblgen -gen-rewriters -I %S/../../include %s 2>&1 | FileCheck %s
+// RUN: not mlir-tblgen -gen-rewriters -I %S/../../../include %s 2>&1 | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 
 def OpA : Op<Test_Dialect, "a"> {

mlir/test/mlir-tblgen/td/llvm-intrinsics.td

 // This checks that we can consume LLVM's Intrinsic definitions from TableGen
 // files and produce ODS. Unlike MLIR, LLVM's main Intrinsics.td file that
 // contains the definition of the Intrinsic class also includes files for
 // platform-specific intrinsics, so we need to give it to TableGen instead of
 // writing a local test source. We filter out platform-specific intrinsic
 // includes from the main file to avoid unnecessary dependencies and decrease
 // the test cost. The command-line flags further ensure a specific intrinsic is
 // processed and we only check the output below.
 // We also verify emission of type specialization for overloadable intrinsics.
 //
-// RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
+// RUN: cat %S/../../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
-// RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask \
+// RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask \
 // RUN: | FileCheck %s
 
 // CHECK-LABEL: def LLVM_ptrmask
 // CHECK: LLVM_IntrOp<"ptrmask
 // The result of this intrinsic result is overloadable.
 // CHECK: [0]
 // The second operand is overloadable, but the first operand needs to
 // match the result type.
 // CHECK: [1]
 // It has no additional traits.
 // CHECK: []
 // It has a result.
 // CHECK: 1>
 // CHECK: Arguments<(ins LLVM_Type, LLVM_Type
 
 //---------------------------------------------------------------------------//
 
 // This checks that the ODS we produce can be consumed by MLIR tablegen. We only
 // make sure the entire process does not fail and produces some C++. The shape
 // of this C++ code is tested by ODS tests.
 
-// RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
+// RUN: cat %S/../../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
-// RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=vastart \
-// RUN: | mlir-tblgen -gen-op-decls -I %S/../../include \
+// RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../../llvm/include/ --llvmir-intrinsics-filter=vastart \
+// RUN: | mlir-tblgen -gen-op-decls -I %S/../../../include \
 // RUN: | FileCheck --check-prefix=ODS %s
 
 // ODS-LABEL: class vastart
 
-// RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
+// RUN: cat %S/../../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
-// RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask -dialect-opclass-base My_OpBase \
+// RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask -dialect-opclass-base My_OpBase \
 // RUN: | FileCheck %s --check-prefix=DIALECT-OPBASE
 
 // DIALECT-OPBASE-LABEL: def LLVM_ptrmask
 // DIALECT-OPBASE: My_OpBase<"ptrmask

mlir/test/mlir-tblgen/td/op-attribute.td

-// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
-// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
-// RUN: mlir-tblgen -print-records -I %S/../../include %s | FileCheck %s --check-prefix=RECORD
+// RUN: mlir-tblgen -gen-op-decls -I %S/../../../include %s | FileCheck %s --check-prefix=DECL
+// RUN: mlir-tblgen -gen-op-defs -I %S/../../../include %s | FileCheck %s --check-prefix=DEF
+// RUN: mlir-tblgen -print-records -I %S/../../../include %s | FileCheck %s --check-prefix=RECORD
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :
     Op<Test_Dialect, mnemonic, traits>;

mlir/test/mlir-tblgen/td/op-decl.td

-// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck  %s
-// RUN: mlir-tblgen -gen-op-decls -op-include-regex="test.a_op" -I %S/../../include %s | FileCheck  %s --check-prefix=REDUCE_INC
-// RUN: mlir-tblgen -gen-op-decls -op-exclude-regex="test.a_op" -I %S/../../include %s | FileCheck  %s --check-prefix=REDUCE_EXC
+// RUN: mlir-tblgen -gen-op-decls -I %S/../../../include %s | FileCheck  %s
+// RUN: mlir-tblgen -gen-op-decls -op-include-regex="test.a_op" -I %S/../../../include %s | FileCheck  %s --check-prefix=REDUCE_INC
+// RUN: mlir-tblgen -gen-op-decls -op-exclude-regex="test.a_op" -I %S/../../../include %s | FileCheck  %s --check-prefix=REDUCE_EXC
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "NS";

mlir/test/mlir-tblgen/td/op-format-spec.td

-// RUN: mlir-tblgen -gen-op-decls -asmformat-error-is-fatal=false -I %S/../../include %s -o=%t 2>&1 | FileCheck %s
+// RUN: mlir-tblgen -gen-op-decls -asmformat-error-is-fatal=false -I %S/../../../include %s -o=%t 2>&1 | FileCheck %s
 
 // This file contains tests for the specification of the declarative op format.
 
 include "mlir/IR/OpBase.td"
 
 def TestDialect : Dialect {
   let name = "test";
 }

mlir/test/mlir-tblgen/td/op-interface.td

-// RUN: mlir-tblgen -gen-op-interface-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
-// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=OP_DECL
+// RUN: mlir-tblgen -gen-op-interface-decls -I %S/../../../include %s | FileCheck %s --check-prefix=DECL
+// RUN: mlir-tblgen -gen-op-decls -I %S/../../../include %s | FileCheck %s --check-prefix=OP_DECL
 
 include "mlir/IR/OpBase.td"
 
 def TestOpInterface : OpInterface<"TestOpInterface"> {
   let description = [{some op interface description}];
 
   let methods = [
     InterfaceMethod<

mlir/test/mlir-tblgen/td/op-operand.td

-// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
+// RUN: mlir-tblgen -gen-op-defs -I %S/../../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :
     Op<Test_Dialect, mnemonic, traits>;

mlir/test/mlir-tblgen/td/op-result.td

-// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
+// RUN: mlir-tblgen -gen-op-defs -I %S/../../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :

mlir/test/mlir-tblgen/td/op-side-effects.td

-// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
+// RUN: mlir-tblgen -gen-op-defs -I %S/../../../include %s | FileCheck %s
 
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def TEST_Dialect : Dialect {
   let name = "test";
 }
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<TEST_Dialect, mnemonic, traits>;

mlir/test/mlir-tblgen/td/predicate.td

-// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
+// RUN: mlir-tblgen -gen-op-defs -I %S/../../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :
     Op<Test_Dialect, mnemonic, traits>;