316 lines · plain
1// RUN: mlir-pdll %s -I %S -I %S/../../../include -split-input-file | FileCheck %s2 3//===----------------------------------------------------------------------===//4// AttrExpr5//===----------------------------------------------------------------------===//6 7// CHECK: Module8// CHECK: `-AttributeExpr {{.*}} Value<"10: i32">9Pattern {10 let attr = attr<"10: i32">;11 12 erase _: Op;13}14 15// -----16 17//===----------------------------------------------------------------------===//18// CallExpr19//===----------------------------------------------------------------------===//20 21// CHECK: Module22// CHECK: |-UserConstraintDecl {{.*}} Name<MakeRootOp> ResultType<Op<my_dialect.foo>>23// CHECK: `-CallExpr {{.*}} Type<Op<my_dialect.foo>>24// CHECK: `-DeclRefExpr {{.*}} Type<Constraint>25// CHECK: `-UserConstraintDecl {{.*}} Name<MakeRootOp> ResultType<Op<my_dialect.foo>>26Constraint MakeRootOp() => op<my_dialect.foo>;27 28Pattern {29 erase MakeRootOp();30}31 32// -----33 34// CHECK: Module35// CHECK: |-UserRewriteDecl {{.*}} Name<CreateNewOp> ResultType<Op<my_dialect.foo>>36// CHECK: `-PatternDecl {{.*}}37// CHECK: `-CallExpr {{.*}} Type<Op<my_dialect.foo>>38// CHECK: `-DeclRefExpr {{.*}} Type<Rewrite>39// CHECK: `-UserRewriteDecl {{.*}} Name<CreateNewOp> ResultType<Op<my_dialect.foo>>40// CHECK: `Arguments`41// CHECK: `-MemberAccessExpr {{.*}} Member<$results> Type<ValueRange>42// CHECK: `-DeclRefExpr {{.*}} Type<Op<my_dialect.bar>>43// CHECK: `-VariableDecl {{.*}} Name<inputOp> Type<Op<my_dialect.bar>>44Rewrite CreateNewOp(inputs: ValueRange) => op<my_dialect.foo>(inputs);45 46Pattern {47 let inputOp = op<my_dialect.bar>;48 replace op<my_dialect.bar>(inputOp) with CreateNewOp(inputOp);49}50 51// -----52 53// CHECK: Module {{.*}}54// CHECK: -UserConstraintDecl {{.*}} Name<TestConstraint> ResultType<Tuple<>>55// CHECK: `-PatternDecl {{.*}}56// CHECK: -CallExpr {{.*}} Type<Tuple<>> Negated57// CHECK: `-DeclRefExpr {{.*}} Type<Constraint>58// CHECK: `-UserConstraintDecl {{.*}} Name<TestConstraint> ResultType<Tuple<>>59Constraint TestConstraint(op: Op);60 61Pattern {62 let inputOp = op<my_dialect.bar>;63 not TestConstraint(inputOp);64 erase inputOp;65}66 67// -----68 69//===----------------------------------------------------------------------===//70// MemberAccessExpr71//===----------------------------------------------------------------------===//72 73// CHECK: Module74// CHECK: `-VariableDecl {{.*}} Name<firstEltIndex> Type<Op>75// CHECK: `-MemberAccessExpr {{.*}} Member<0> Type<Op>76// CHECK: `-DeclRefExpr {{.*}} Type<Tuple<firstElt: Op>>77// CHECK: `-VariableDecl {{.*}} Name<firstEltName> Type<Op>78// CHECK: `-MemberAccessExpr {{.*}} Member<firstElt> Type<Op>79// CHECK: `-DeclRefExpr {{.*}} Type<Tuple<firstElt: Op>>80Pattern {81 let tuple = (firstElt = _: Op);82 let firstEltIndex = tuple.0;83 let firstEltName = tuple.firstElt;84 85 erase _: Op;86}87 88// -----89 90#include "include/ops.td"91 92// CHECK: Module93// CHECK: `-VariableDecl {{.*}} Name<firstEltIndex> Type<Value>94// CHECK: `-MemberAccessExpr {{.*}} Member<0> Type<Value>95// CHECK: `-DeclRefExpr {{.*}} Type<Op<test.all_single>>96// CHECK: `-VariableDecl {{.*}} Name<firstEltName> Type<Value>97// CHECK: `-MemberAccessExpr {{.*}} Member<result> Type<Value>98// CHECK: `-DeclRefExpr {{.*}} Type<Op<test.all_single>>99Pattern {100 let op: Op<test.all_single>;101 let firstEltIndex = op.0;102 let firstEltName = op.result;103 104 erase op;105}106 107// -----108 109// CHECK: Module110// CHECK: `-VariableDecl {{.*}} Name<op> Type<Op<my_dialect.unregistered_foo>>111// CHECK: `-OperationExpr {{.*}} Type<Op<my_dialect.unregistered_foo>>112// CHECK: `-OpNameDecl {{.*}} Name<my_dialect.unregistered_foo>113// CHECK: `Operands`114// CHECK: `-MemberAccessExpr {{.*}} Member<0> Type<Value>115// CHECK: `-OperationExpr {{.*}} Type<Op<my_dialect.unregistered_bar>>116// CHECK: `-OpNameDecl {{.*}} Name<my_dialect.unregistered_bar>117// CHECK: `Operands`118// CHECK: `-DeclRefExpr {{.*}} Type<ValueRange>119// CHECK: `-VariableDecl {{.*}} Name<_> Type<ValueRange>120// CHECK: `Constraints`121// CHECK: `-ValueRangeConstraintDecl122Pattern {123 let op = op<my_dialect.unregistered_foo>(op<my_dialect.unregistered_bar>.0);124 erase op;125}126 127// -----128 129//===----------------------------------------------------------------------===//130// OperationExpr131//===----------------------------------------------------------------------===//132 133// Test a non-constrained operation expression, and ensure that we don't treat134// unconstrained as "not present"(e.g. zero operands).135 136// CHECK: Module137// CHECK: `-OperationExpr {{.*}} Type<Op>138// CHECK: `-OpNameDecl139// CHECK: `Operands`140// CHECK: `-DeclRefExpr {{.*}} Type<ValueRange>141// CHECK: `-VariableDecl {{.*}} Name<_> Type<ValueRange>142// CHECK: `Constraints`143// CHECK: `-ValueRangeConstraintDecl144// CHECK: `Result Types`145// CHECK: `-DeclRefExpr {{.*}} Type<TypeRange>146// CHECK: `-VariableDecl {{.*}} Name<_> Type<TypeRange>147// CHECK: `Constraints`148// CHECK: `-TypeRangeConstraintDecl149Pattern {150 erase op<>;151}152 153// -----154 155// Test explicitly empty operand/result/etc. lists, which are different from the 156// "unconstrained" examples above.157 158// CHECK: Module159// CHECK: `-OperationExpr {{.*}} Type<Op>160// CHECK: `-OpNameDecl161// CHECK-NOT: `Operands`162// CHECK-NOT: `Result Types`163Pattern {164 erase op<>() -> ();165}166 167// -----168 169// CHECK: Module170// CHECK: `-OperationExpr {{.*}} Type<Op<my_dialect.foo>>171// CHECK: `-OpNameDecl {{.*}} Name<my_dialect.foo>172Pattern {173 erase op<my_dialect.foo>;174}175 176// -----177 178// CHECK: Module179// CHECK: `-OperationExpr {{.*}} Type<Op>180// CHECK: `-OpNameDecl181// CHECK: `Operands`182// CHECK: |-DeclRefExpr {{.*}} Type<Value>183// CHECK: |-DeclRefExpr {{.*}} Type<ValueRange>184// CHECK: `-DeclRefExpr {{.*}} Type<Value>185Pattern {186 erase op<>(_: Value, _: ValueRange, _: Value);187}188 189// -----190 191// CHECK: Module192// CHECK: `-OperationExpr {{.*}} Type<Op>193// CHECK: `-OpNameDecl194// CHECK: `Operands`195// CHECK: `-MemberAccessExpr {{.*}} Member<$results> Type<ValueRange>196// CHECK: `-OperationExpr {{.*}} Type<Op<my_dialect.bar>>197// CHECK: `-OpNameDecl {{.*}} Name<my_dialect.bar>198Pattern {199 erase op<>(op<my_dialect.bar>);200}201 202// -----203 204// CHECK: Module205// CHECK: `-OperationExpr {{.*}} Type<Op>206// CHECK: `-OpNameDecl207// CHECK: `Attributes`208// CHECK: |-NamedAttributeDecl {{.*}} Name<unitAttr>209// CHECK: `-AttributeExpr {{.*}} Value<"unit">210// CHECK: `-NamedAttributeDecl {{.*}} Name<normal$Attr>211// CHECK: `-DeclRefExpr {{.*}} Type<Attr>212 213Pattern {214 erase op<> {unitAttr, "normal$Attr" = _: Attr};215}216 217// -----218 219// CHECK: Module220// CHECK: `-OperationExpr {{.*}} Type<Op>221// CHECK: `-OpNameDecl222// CHECK: `Result Types`223// CHECK: |-DeclRefExpr {{.*}} Type<Type>224// CHECK: |-DeclRefExpr {{.*}} Type<TypeRange>225// CHECK: `-DeclRefExpr {{.*}} Type<Type>226Pattern {227 erase op<> -> (_: Type, _: TypeRange, _: Type);228}229 230// -----231 232// Test that we don't need to provide values if all elements233// are optional.234 235#include "include/ops.td"236 237// CHECK: Module238// CHECK: -OperationExpr {{.*}} Type<Op<test.multi_variadic>>239// CHECK-NOT: `Operands`240// CHECK-NOT: `Result Types`241// CHECK: -OperationExpr {{.*}} Type<Op<test.all_variadic>>242// CHECK-NOT: `Operands`243// CHECK-NOT: `Result Types`244// CHECK: -OperationExpr {{.*}} Type<Op<test.multi_variadic>>245// CHECK: `Operands`246// CHECK: -RangeExpr {{.*}} Type<ValueRange>247// CHECK: -RangeExpr {{.*}} Type<ValueRange>248// CHECK: `Result Types`249// CHECK: -RangeExpr {{.*}} Type<TypeRange>250// CHECK: -RangeExpr {{.*}} Type<TypeRange>251Pattern {252 rewrite op<test.multi_variadic>() -> () with {253 op<test.all_variadic> -> ();254 op<test.multi_variadic> -> ();255 };256}257 258// -----259 260//===----------------------------------------------------------------------===//261// TupleExpr262//===----------------------------------------------------------------------===//263 264// CHECK: Module265// CHECK: `-VariableDecl {{.*}} Name<emptyTuple>266// CHECK: `-TupleExpr {{.*}} Type<Tuple<>>267// CHECK: `-VariableDecl {{.*}} Name<mixedTuple>268// CHECK: `-TupleExpr {{.*}} Type<Tuple<arg1: Attr, Value>>269// CHECK: |-DeclRefExpr {{.*}} Type<Attr>270// CHECK: `-DeclRefExpr {{.*}} Type<Value>271Pattern {272 let value: Value;273 274 let emptyTuple = ();275 let mixedTuple = (arg1 = _: Attr, value);276 277 erase _: Op;278}279 280// -----281 282//===----------------------------------------------------------------------===//283// RangeExpr284//===----------------------------------------------------------------------===//285 286// CHECK: Module287// CHECK: `Operands`288// CHECK: -RangeExpr {{.*}} Type<ValueRange>289// CHECK: -RangeExpr {{.*}} Type<ValueRange>290// CHECK: -MemberAccessExpr {{.*}} Member<0> Type<Value>291// CHECK: -MemberAccessExpr {{.*}} Member<1> Type<ValueRange>292// CHECK: `Result Types`293// CHECK: -RangeExpr {{.*}} Type<TypeRange>294// CHECK: -RangeExpr {{.*}} Type<TypeRange>295// CHECK: -MemberAccessExpr {{.*}} Member<0> Type<Type>296// CHECK: -MemberAccessExpr {{.*}} Member<1> Type<TypeRange>297Pattern {298 rewrite op<>(arg: Value, args: ValueRange) -> (type: Type, types: TypeRange) with {299 op<test.op>((), (arg, args)) -> ((), (type, types));300 };301}302 303// -----304 305//===----------------------------------------------------------------------===//306// TypeExpr307//===----------------------------------------------------------------------===//308 309// CHECK: Module310// CHECK: `-TypeExpr {{.*}} Value<"i64">311Pattern {312 let type = type<"i64">;313 314 erase _: Op;315}316