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

   1 // RUN: mlir-tblgen -gen-op-interface-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
   2 // RUN: mlir-tblgen -gen-op-interface-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
   3 // RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=OP_DECL
   4 // RUN: mlir-tblgen -gen-op-interface-docs -I %S/../../include %s | FileCheck %s --check-prefix=DOCS
   5
   6 include "mlir/IR/OpBase.td"
   7
   8 def ExtraClassOfInterface : OpInterface<"ExtraClassOfInterface"> {
   9   let extraClassOf = "return $_op->someOtherMethod();";
  10 }
  11
  12 // DECL: class ExtraClassOfInterface
  13 // DECL:   static bool classof(::mlir::Operation * base) {
  14 // DECL-NEXT:     auto* interface = getInterfaceFor(base);
  15 // DECL-NEXT:     if (!interface)
  16 // DECL-NEXT:       return false;
  17 // DECL-NEXT:     ExtraClassOfInterface odsInterfaceInstance(base, interface);
  18 // DECL-NEXT:     return odsInterfaceInstance->someOtherMethod();
  19 // DECL-NEXT:   }
  20
  21 def ExtraShardDeclsInterface : OpInterface<"ExtraShardDeclsInterface"> {
  22   let extraSharedClassDeclaration = [{
  23     bool sharedMethodDeclaration() {
  24       return $_op.someOtherMethod();
  25     }
  26   }];
  27 }
  28
  29 // DECL: class ExtraShardDeclsInterface
  30 // DECL:      bool sharedMethodDeclaration() {
  31 // DECL-NEXT:   return (*this).someOtherMethod();
  32 // DECL-NEXT: }
  33
  34 // DECL: struct ExtraShardDeclsInterfaceTrait
  35 // DECL:      bool sharedMethodDeclaration() {
  36 // DECL-NEXT:   return (*static_cast<ConcreteOp *>(this)).someOtherMethod();
  37 // DECL-NEXT: }
  38
  39 def TestInheritanceMultiBaseInterface : OpInterface<"TestInheritanceMultiBaseInterface"> {
  40   let methods = [
  41     InterfaceMethod<
  42       /*desc=*/[{some function comment}],
  43       /*retTy=*/"int",
  44       /*methodName=*/"baz",
  45       /*args=*/(ins "int":$input)
  46     >
  47   ];
  48 }
  49
  50 def TestInheritanceBaseInterface : OpInterface<"TestInheritanceBaseInterface", [TestInheritanceMultiBaseInterface]> {
  51   let methods = [
  52     InterfaceMethod<
  53       /*desc=*/[{some function comment}],
  54       /*retTy=*/"int",
  55       /*methodName=*/"foo",
  56       /*args=*/(ins "int":$input)
  57     >
  58   ];
  59 }
  60 def TestInheritanceMiddleBaseInterface
  61  : OpInterface<"TestInheritanceMiddleBaseInterface", [TestInheritanceBaseInterface]> {
  62   let methods = [
  63     InterfaceMethod<
  64       /*desc=*/[{some function comment}],
  65       /*retTy=*/"int",
  66       /*methodName=*/"bar",
  67       /*args=*/(ins "int":$input)
  68     >
  69   ];
  70 }
  71 def TestInheritanceZDerivedInterface
  72   : OpInterface<"TestInheritanceZDerivedInterface", [TestInheritanceMiddleBaseInterface]>;
  73
  74 // DECL: class TestInheritanceZDerivedInterface
  75 // DECL: struct Concept {
  76 // DECL:     const TestInheritanceMultiBaseInterface::Concept *implTestInheritanceMultiBaseInterface = nullptr;
  77 // DECL-NOT: const TestInheritanceMultiBaseInterface::Concept
  78 // DECL:     const TestInheritanceBaseInterface::Concept *implTestInheritanceBaseInterface = nullptr;
  79 // DECL:     const TestInheritanceMiddleBaseInterface::Concept *implTestInheritanceMiddleBaseInterface = nullptr;
  80
  81 // DECL:     void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
  82 // DECL:       implTestInheritanceBaseInterface = interfaceMap.lookup<TestInheritanceBaseInterface>();
  83 // DECL:       assert(implTestInheritanceBaseInterface && "`TestInheritanceZDerivedInterface` expected its base interface `TestInheritanceBaseInterface` to be registered");
  84 // DECL:       implTestInheritanceMiddleBaseInterface = interfaceMap.lookup<TestInheritanceMiddleBaseInterface>();
  85 // DECL:       assert(implTestInheritanceMiddleBaseInterface
  86 // DECL:     }
  87
  88 // DECL:    //===----------------------------------------------------------------===//
  89 // DECL:    // Inherited from TestInheritanceBaseInterface
  90 // DECL:    //===----------------------------------------------------------------===//
  91 // DECL:    operator TestInheritanceBaseInterface () const {
  92 // DECL:      return TestInheritanceBaseInterface(*this, getImpl()->implTestInheritanceBaseInterface);
  93 // DECL:    }
  94 // DECL:    /// some function comment
  95 // DECL:    int foo(int input);
  96
  97 // DECL:    //===----------------------------------------------------------------===//
  98 // DECL:    // Inherited from TestInheritanceMiddleBaseInterface
  99 // DECL:    //===----------------------------------------------------------------===//
 100 // DECL:    operator TestInheritanceMiddleBaseInterface () const {
 101 // DECL:      return TestInheritanceMiddleBaseInterface(*this, getImpl()->implTestInheritanceMiddleBaseInterface);
 102 // DECL:    }
 103 // DECL:    /// some function comment
 104 // DECL:    int bar(int input);
 105
 106 // DEF: int TestInheritanceZDerivedInterface::foo(int input) {
 107 // DEF-NEXT:    getImpl()->implTestInheritanceBaseInterface->foo(getImpl()->implTestInheritanceBaseInterface, getOperation(), input);
 108
 109 // DEF: int TestInheritanceZDerivedInterface::bar(int input) {
 110 // DEF-NEXT:   return getImpl()->implTestInheritanceMiddleBaseInterface->bar(getImpl()->implTestInheritanceMiddleBaseInterface, getOperation(), input);
 111
 112 def TestOpInterface : OpInterface<"TestOpInterface"> {
 113   let description = [{some op interface description}];
 114
 115   let methods = [
 116     InterfaceMethod<
 117       /*desc=*/[{some function comment}],
 118       /*retTy=*/"int",
 119       /*methodName=*/"foo",
 120       /*args=*/(ins "int":$input)
 121     >,
 122     InterfaceMethod<
 123       /*desc=*/[{some function comment}],
 124       /*retTy=*/"int",
 125       /*methodName=*/"body_foo",
 126       /*args=*/(ins "int":$input),
 127       /*body=*/[{ return 0; }]
 128     >,
 129     InterfaceMethod<
 130       /*desc=*/[{some function comment}],
 131       /*retTy=*/"int",
 132       /*methodName=*/"default_foo",
 133       /*args=*/(ins "int":$input),
 134       /*body=*/[{}],
 135       /*defaultBody=*/[{ return 0; }]
 136     >,
 137   ];
 138 }
 139
 140 def TestOpInterfaceVerify : OpInterface<"TestOpInterfaceVerify"> {
 141   let verify = [{
 142     return foo();
 143   }];
 144 }
 145
 146 def TestOpInterfaceVerifyRegion : OpInterface<"TestOpInterfaceVerifyRegion"> {
 147   let verify = [{
 148     return foo();
 149   }];
 150   let verifyWithRegions = 1;
 151 }
 152
 153 // Define Ops with TestOpInterface and
 154 // DeclareOpInterfaceMethods<TestOpInterface> traits to check that there
 155 // are not duplicated C++ classes generated.
 156 def TestDialect : Dialect {
 157   let name = "test";
 158 }
 159
 160 def OpInterfaceOp : Op<TestDialect, "op_interface_op", [TestOpInterface]>;
 161
 162 def OpInterfaceInterfacesOp : Op<TestDialect, "op_inherit_interface_op", [TestInheritanceZDerivedInterface]>;
 163
 164 def DeclareMethodsOp : Op<TestDialect, "declare_methods_op",
 165                           [DeclareOpInterfaceMethods<TestOpInterface>]>;
 166
 167 def DeclareMethodsWithDefaultOp : Op<TestDialect, "declare_methods_op",
 168       [DeclareOpInterfaceMethods<TestOpInterface, ["default_foo"]>]>;
 169
 170 // DECL-LABEL: TestOpInterfaceInterfaceTraits
 171 // DECL: class TestOpInterface : public ::mlir::OpInterface<TestOpInterface, detail::TestOpInterfaceInterfaceTraits>
 172
 173 // DECL: /// some function comment
 174 // DECL: int foo(int input);
 175
 176 // DECL-LABEL: struct TestOpInterfaceVerifyTrait
 177 // DECL: verifyTrait
 178
 179 // DECL-LABEL: struct TestOpInterfaceVerifyRegionTrait
 180 // DECL: verifyRegionTrait
 181
 182 // Method implementations come last, after all class definitions.
 183 // DECL: template<typename ConcreteOp>
 184 // DECL: int detail::TestOpInterfaceInterfaceTraits::Model<ConcreteOp>::foo
 185
 186 // OP_DECL-LABEL: class DeclareMethodsOp : public
 187 // OP_DECL: int foo(int input);
 188 // OP_DECL-NOT: int default_foo(int input);
 189
 190 // OP_DECL-LABEL: class DeclareMethodsWithDefaultOp : public
 191 // OP_DECL: int foo(int input);
 192 // OP_DECL: int default_foo(int input);
 193
 194 // OP_DECL: class OpInterfaceInterfacesOp :
 195 // OP_DECL-SAME: TestInheritanceBaseInterface::Trait, TestInheritanceMiddleBaseInterface::Trait, TestInheritanceZDerivedInterface::Trait
 196
 197 // DOCS-LABEL: {{^}}## TestOpInterface (`TestOpInterface`)
 198 // DOCS: some op interface description
 199
 200 // DOCS: {{^}}### Methods:
 201
 202 // DOCS: {{^}}#### `foo`
 203 // DOCS: some function comment
 204
 205 // DOCS: {{^}}#### `body_foo`
 206 // DOCS: some function comment
 207
 208 // DOCS: {{^}}#### `default_foo`
 209 // DOCS: some function comment