You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
146 lines
5.0 KiB
146 lines
5.0 KiB
// RUN: mlir-opt -split-input-file -convert-pdl-to-pdl-interp %s | FileCheck %s
|
|
|
|
// CHECK-LABEL: module @empty_module
|
|
module @empty_module {
|
|
// CHECK: func @matcher(%{{.*}}: !pdl.operation)
|
|
// CHECK-NEXT: pdl_interp.finalize
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: module @simple
|
|
module @simple {
|
|
// CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
|
|
// CHECK: pdl_interp.check_operation_name of %[[ROOT]] is "foo.op" -> ^bb2, ^bb1
|
|
// CHECK: ^bb1:
|
|
// CHECK: pdl_interp.finalize
|
|
// CHECK: ^bb2:
|
|
// CHECK: pdl_interp.check_operand_count of %[[ROOT]] is 0 -> ^bb3, ^bb1
|
|
// CHECK: ^bb3:
|
|
// CHECK: pdl_interp.check_result_count of %[[ROOT]] is 0 -> ^bb4, ^bb1
|
|
// CHECK: ^bb4:
|
|
// CHECK: pdl_interp.record_match @rewriters::@pdl_generated_rewriter
|
|
// CHECK-SAME: benefit(1), loc([%[[ROOT]]]), root("foo.op") -> ^bb1
|
|
|
|
// CHECK: module @rewriters
|
|
// CHECK: func @pdl_generated_rewriter(%[[REWRITE_ROOT:.*]]: !pdl.operation)
|
|
// CHECK: pdl_interp.apply_rewrite "rewriter" on %[[REWRITE_ROOT]]
|
|
// CHECK: pdl_interp.finalize
|
|
pdl.pattern : benefit(1) {
|
|
%root = pdl.operation "foo.op"()
|
|
pdl.rewrite %root with "rewriter"
|
|
}
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: module @attributes
|
|
module @attributes {
|
|
// CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
|
|
// Check the value of "attr".
|
|
// CHECK-DAG: %[[ATTR:.*]] = pdl_interp.get_attribute "attr" of %[[ROOT]]
|
|
// CHECK-DAG: pdl_interp.is_not_null %[[ATTR]] : !pdl.attribute
|
|
// CHECK-DAG: pdl_interp.check_attribute %[[ATTR]] is 10 : i64
|
|
|
|
// Check the type of "attr1".
|
|
// CHECK-DAG: %[[ATTR1:.*]] = pdl_interp.get_attribute "attr1" of %[[ROOT]]
|
|
// CHECK-DAG: pdl_interp.is_not_null %[[ATTR1]] : !pdl.attribute
|
|
// CHECK-DAG: %[[ATTR1_TYPE:.*]] = pdl_interp.get_attribute_type of %[[ATTR1]]
|
|
// CHECK-DAG: pdl_interp.check_type %[[ATTR1_TYPE]] is i64
|
|
pdl.pattern : benefit(1) {
|
|
%type = pdl.type : i64
|
|
%attr = pdl.attribute 10 : i64
|
|
%attr1 = pdl.attribute : %type
|
|
%root = pdl.operation {"attr" = %attr, "attr1" = %attr1}
|
|
pdl.rewrite %root with "rewriter"
|
|
}
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: module @constraints
|
|
module @constraints {
|
|
// CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
|
|
// CHECK-DAG: %[[INPUT:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
|
|
// CHECK-DAG: %[[INPUT1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
|
|
// CHECK: pdl_interp.apply_constraint "multi_constraint" [true](%[[INPUT]], %[[INPUT1]] : !pdl.value, !pdl.value)
|
|
|
|
pdl.pattern : benefit(1) {
|
|
%input0 = pdl.input
|
|
%input1 = pdl.input
|
|
|
|
pdl.apply_constraint "multi_constraint"[true](%input0, %input1 : !pdl.value, !pdl.value)
|
|
|
|
%root = pdl.operation(%input0, %input1)
|
|
pdl.rewrite %root with "rewriter"
|
|
}
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: module @inputs
|
|
module @inputs {
|
|
// CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
|
|
// CHECK-DAG: pdl_interp.check_operand_count of %[[ROOT]] is 2
|
|
|
|
// Get the input and check the type.
|
|
// CHECK-DAG: %[[INPUT:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
|
|
// CHECK-DAG: pdl_interp.is_not_null %[[INPUT]] : !pdl.value
|
|
// CHECK-DAG: %[[INPUT_TYPE:.*]] = pdl_interp.get_value_type of %[[INPUT]]
|
|
// CHECK-DAG: pdl_interp.check_type %[[INPUT_TYPE]] is i64
|
|
|
|
// Get the second operand and check that it is equal to the first.
|
|
// CHECK-DAG: %[[INPUT1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
|
|
// CHECK-DAG: pdl_interp.are_equal %[[INPUT]], %[[INPUT1]] : !pdl.value
|
|
pdl.pattern : benefit(1) {
|
|
%type = pdl.type : i64
|
|
%input = pdl.input : %type
|
|
%root = pdl.operation(%input, %input)
|
|
pdl.rewrite %root with "rewriter"
|
|
}
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: module @results
|
|
module @results {
|
|
// CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
|
|
// CHECK: pdl_interp.check_result_count of %[[ROOT]] is 2
|
|
|
|
// Get the input and check the type.
|
|
// CHECK-DAG: %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
|
|
// CHECK-DAG: pdl_interp.is_not_null %[[RESULT]] : !pdl.value
|
|
// CHECK-DAG: %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
|
|
// CHECK-DAG: pdl_interp.check_type %[[RESULT_TYPE]] is i32
|
|
|
|
// Get the second operand and check that it is equal to the first.
|
|
// CHECK-DAG: %[[RESULT1:.*]] = pdl_interp.get_result 1 of %[[ROOT]]
|
|
// CHECK-NOT: pdl_interp.get_value_type of %[[RESULT1]]
|
|
pdl.pattern : benefit(1) {
|
|
%type1 = pdl.type : i32
|
|
%type2 = pdl.type
|
|
%root, %results:2 = pdl.operation -> %type1, %type2
|
|
pdl.rewrite %root with "rewriter"
|
|
}
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: module @switch_result_types
|
|
module @switch_result_types {
|
|
// CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
|
|
// CHECK: %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
|
|
// CHECK: %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
|
|
// CHECK: pdl_interp.switch_type %[[RESULT_TYPE]] to [i32, i64]
|
|
pdl.pattern : benefit(1) {
|
|
%type = pdl.type : i32
|
|
%root, %result = pdl.operation -> %type
|
|
pdl.rewrite %root with "rewriter"
|
|
}
|
|
pdl.pattern : benefit(1) {
|
|
%type = pdl.type : i64
|
|
%root, %result = pdl.operation -> %type
|
|
pdl.rewrite %root with "rewriter"
|
|
}
|
|
}
|