[mlir][SideEffects] Enable specifying side effects directly on the arguments/results of an operation.

[rriddle]

Summary

New classes are added to ODS to enable specifying additional information on the arguments and results of an operation. These classes, Arg and Res allow for adding a description and a set of 'decorators' along with the constraint. This enables specifying the side effects of an operation directly on the arguments and results themselves.

Example:

def LoadOp : Std_Op<"load"> {
  let arguments = (ins Arg<"The MemRef to load from.", AnyMemRef,
                           [MemRead]>:$memref,
                       Variadic<Index>:$indices);
}

Depends On D74439

[jpienaar]

Should Arg<"The MemRef to load from." be Arg<"the MemRef to load from" ? E.g., sentence fragment, not capitalized, could be added in generated docs as table entries?

mlir/include/mlir/IR/OpBase.td

1716

s/{}/;/ ?

mlir/include/mlir/TableGen/SideEffects.h

27

Nit: C++

mlir/lib/TableGen/Operator.cpp

309

Mmm, why are we referring to "constraint" a few times, could this be stored instead or queried in a different way? (same as being done for operands and attributes)

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1209

Does formatv read easier here?

1227

Comment?

[rriddle]

Resolve comments

[jpienaar]

General structure looks good to me and we can iterate from here, thanks

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

1056–1058

One last question about the ordering, what about switching the constraint and the text?

Then we have

AnyMemRef
Arg<AnyMemRef>
Arg<AnyMemRef, "the reference to load from">
Arg<AnyMemRef, "the reference to load from", [MemRead]>

and it just seems to extend more naturally (and one could have desc be empty to match what we have today implicitly).

Or is there a reason you prefer this ordering?

[rriddle]

Rebase

[rriddle]

Resolve comments

[NathanielMcVicar]

This appears to break the VisualStudio build for MSVC++ 14.16

E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(58): error C2664: 'bool mlir::SideEffects::Effect::Base<mlir::MemoryEffects::Allocate,mlir::MemoryEffects::Effect>::classof(const mlir::MemoryEffects::Effect *)': cannot convert argument 1 from 'const From *' to 'const mlir::MemoryEffects::Effect *'
        with
        [
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(58): note: Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(57): note: while compiling class template member function 'bool llvm::isa_impl<To,From,void>::doit(const From &)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(105): note: see reference to function template instantiation 'bool llvm::isa_impl<To,From,void>::doit(const From &)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(105): note: see reference to class template instantiation 'llvm::isa_impl<To,From,void>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(103): note: while compiling class template member function 'bool llvm::isa_impl_cl<To,FromTy>::doit(const From *)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(131): note: see reference to function template instantiation 'bool llvm::isa_impl_cl<To,FromTy>::doit(const From *)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(131): note: see reference to class template instantiation 'llvm::isa_impl_cl<To,FromTy>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(130): note: while compiling class template member function 'bool llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>::doit(const FromTy &)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(121): note: see reference to function template instantiation 'bool llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>::doit(const FromTy &)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(122): note: see reference to class template instantiation 'llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(120): note: while compiling class template member function 'bool llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>::doit(From &)'
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *,
            From=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(141): note: see reference to function template instantiation 'bool llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>::doit(From &)' being compiled
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *,
            From=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(142): note: see reference to class template instantiation 'llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>' being compiled
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\mlir\lib\IR\Operation.cpp(967): note: see reference to function template instantiation 'bool llvm::isa<mlir::MemoryEffects::Allocate,const mlir::SideEffects::Effect*>(const Y &)' being compiled
        with
        [
            Y=const mlir::SideEffects::Effect *
        ]
ninja: build stopped: subcommand failed.

[rriddle]

In D74440#1910724, @NathanielMcVicar wrote:

This appears to break the VisualStudio build for MSVC++ 14.16

E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(58): error C2664: 'bool mlir::SideEffects::Effect::Base<mlir::MemoryEffects::Allocate,mlir::MemoryEffects::Effect>::classof(const mlir::MemoryEffects::Effect *)': cannot convert argument 1 from 'const From *' to 'const mlir::MemoryEffects::Effect *'
        with
        [
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(58): note: Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(57): note: while compiling class template member function 'bool llvm::isa_impl<To,From,void>::doit(const From &)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(105): note: see reference to function template instantiation 'bool llvm::isa_impl<To,From,void>::doit(const From &)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(105): note: see reference to class template instantiation 'llvm::isa_impl<To,From,void>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(103): note: while compiling class template member function 'bool llvm::isa_impl_cl<To,FromTy>::doit(const From *)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(131): note: see reference to function template instantiation 'bool llvm::isa_impl_cl<To,FromTy>::doit(const From *)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(131): note: see reference to class template instantiation 'llvm::isa_impl_cl<To,FromTy>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(130): note: while compiling class template member function 'bool llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>::doit(const FromTy &)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(121): note: see reference to function template instantiation 'bool llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>::doit(const FromTy &)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(122): note: see reference to class template instantiation 'llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(120): note: while compiling class template member function 'bool llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>::doit(From &)'
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *,
            From=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(141): note: see reference to function template instantiation 'bool llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>::doit(From &)' being compiled
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *,
            From=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(142): note: see reference to class template instantiation 'llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>' being compiled
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\mlir\lib\IR\Operation.cpp(967): note: see reference to function template instantiation 'bool llvm::isa<mlir::MemoryEffects::Allocate,const mlir::SideEffects::Effect*>(const Y &)' being compiled
        with
        [
            Y=const mlir::SideEffects::Effect *
        ]
ninja: build stopped: subcommand failed.

Thanks for the report, looks like MSVC has some buggy symbol resolution for templates. I'll send fix-forward shortly.

[rriddle]

In D74440#1910771, @rriddle wrote:

In D74440#1910724, @NathanielMcVicar wrote:

This appears to break the VisualStudio build for MSVC++ 14.16

E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(58): error C2664: 'bool mlir::SideEffects::Effect::Base<mlir::MemoryEffects::Allocate,mlir::MemoryEffects::Effect>::classof(const mlir::MemoryEffects::Effect *)': cannot convert argument 1 from 'const From *' to 'const mlir::MemoryEffects::Effect *'
        with
        [
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(58): note: Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(57): note: while compiling class template member function 'bool llvm::isa_impl<To,From,void>::doit(const From &)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(105): note: see reference to function template instantiation 'bool llvm::isa_impl<To,From,void>::doit(const From &)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(105): note: see reference to class template instantiation 'llvm::isa_impl<To,From,void>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(103): note: while compiling class template member function 'bool llvm::isa_impl_cl<To,FromTy>::doit(const From *)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(131): note: see reference to function template instantiation 'bool llvm::isa_impl_cl<To,FromTy>::doit(const From *)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *,
            From=mlir::SideEffects::Effect
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(131): note: see reference to class template instantiation 'llvm::isa_impl_cl<To,FromTy>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(130): note: while compiling class template member function 'bool llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>::doit(const FromTy &)'
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(121): note: see reference to function template instantiation 'bool llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>::doit(const FromTy &)' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *,
            FromTy=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(122): note: see reference to class template instantiation 'llvm::isa_impl_wrap<To,SimpleFrom,SimpleFrom>' being compiled
        with
        [
            To=mlir::MemoryEffects::Allocate,
            SimpleFrom=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(120): note: while compiling class template member function 'bool llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>::doit(From &)'
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *,
            From=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(141): note: see reference to function template instantiation 'bool llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>::doit(From &)' being compiled
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *,
            From=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\llvm\include\llvm/Support/Casting.h(142): note: see reference to class template instantiation 'llvm::isa_impl_wrap<X,const Y,const mlir::SideEffects::Effect *>' being compiled
        with
        [
            X=mlir::MemoryEffects::Allocate,
            Y=const mlir::SideEffects::Effect *
        ]
E:\build_slave\mlir-x64-windows-ninja\llvm-project\mlir\lib\IR\Operation.cpp(967): note: see reference to function template instantiation 'bool llvm::isa<mlir::MemoryEffects::Allocate,const mlir::SideEffects::Effect*>(const Y &)' being compiled
        with
        [
            Y=const mlir::SideEffects::Effect *
        ]
ninja: build stopped: subcommand failed.

Thanks for the report, looks like MSVC has some buggy symbol resolution for templates. I'll send fix-forward shortly.

I submitted: https://github.com/llvm/llvm-project/commit/f240d303c2edf69d6a53691c62da110877ac6bf5

Let me know if that fixes it for you.

[NathanielMcVicar]

In D74440#1910791, @rriddle wrote:

Let me know if that fixes it for you.

It works. Thanks so much! My understanding is that some of these template related issues are fixed in VS19, but there is a different bug that's preventing us from using it until the next release.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 //===----------------------------------------------------------------------===//
 
 #ifndef STANDARD_OPS
 #define STANDARD_OPS
 
 include "mlir/Analysis/CallInterfaces.td"
 include "mlir/Analysis/ControlFlowInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
+include "mlir/IR/SideEffects.td"
 
 def Std_Dialect : Dialect {
   let name = "std";
   let cppNamespace = "";
 }
 
 // Base class for Standard dialect ops.
 class Std_Op<string mnemonic, list<OpTrait> traits = []> :
let description = [{
     output of load is a new value with the same type as the elements of the
     memref. The arity of indices is the rank of the memref (i.e., if the memref
     loaded from is of rank 3, then 3 indices are required for the load following
     the memref identifier). For example:
 
       %3 = load %0[%1, %1] : memref<4x4xi32>
   }];
 
-  let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices);
+  let arguments = (ins Arg<AnyMemRef, "the reference to load from",
+                           [MemRead]>:$memref,
+                       Variadic<Index>:$indices);
   let results = (outs AnyType:$result);
 
   let builders = [OpBuilder<
     "Builder *, OperationState &result, Value memref,"
     "ValueRange indices = {}", [{
       auto memrefType = memref.getType().cast<MemRefType>();
       result.addOperands(memref);
       result.addOperands(indices);
let description = [{
     stored to is of rank 3, then 3 indices are required for the store following
     the memref identifier). The store operation does not produce a result.
 
     In the following example, the ssa value '%v' is stored in memref '%A' at
     indices [%i, %j]:
       store %v, %A[%i, %j] : memref<4x128xf32, (d0, d1) -> (d0, d1), 0>
   }];
 
-  let arguments = (ins AnyType:$value, AnyMemRef:$memref,
+  let arguments = (ins AnyType:$value,
+                       Arg<AnyMemRef, "the reference to store to",
+                           [MemWrite]>:$memref,
                        Variadic<Index>:$indices);
 
   let builders = [OpBuilder<
     "Builder *, OperationState &result, Value valueToStore, Value memref", [{
       result.addOperands(valueToStore);
       result.addOperands(memref);
   }]>];
 
   let extraClassDeclaration = [{
let description = [{
     The "tensor_load" operation creates a tensor from a memref, making an
     independent copy of the element data. The result value is a tensor whose
     shape and element type match the memref operand.
 
     Produce a value of tensor<4x?xf32> type.
        %12 = tensor_load %10 : memref<4x?xf32, #layout, memspace0>
   }];
 
-  let arguments = (ins AnyMemRef:$memref);
+  let arguments = (ins Arg<AnyMemRef, "the reference to load from",
+                           [MemRead]>:$memref);
   let results = (outs AnyTensor:$result);
   // TensorLoadOp is fully verified by traits.
   let verifier = ?;
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, Value memref", [{
       auto memrefType = memref.getType().cast<MemRefType>();
       auto resultType = RankedTensorType::get(memrefType.getShape(),
let description = [{
     specified by the memref type.
 
     Example:
        %9 = dim %8, 1 : tensor<4x?xf32>
        %10 = alloc(%9) : memref<4x?xf32, #layout, memspace0>
        tensor_store %8, %10 : memref<4x?xf32, #layout, memspace0>
   }];
 
-  let arguments = (ins AnyTensor:$tensor, AnyMemRef:$memref);
+  let arguments = (ins AnyTensor:$tensor,
+                       Arg<AnyMemRef, "the reference to store to",
+                           [MemWrite]>:$memref);
   // TensorStoreOp is fully verified by traits.
   let verifier = ?;
 
   let assemblyFormat = "$tensor `,` $memref attr-dict `:` type($memref)";
 }
 
 //===----------------------------------------------------------------------===//
 // TruncateIOp

mlir/include/mlir/IR/OpBase.td

 // passed in for `body`, then *only* the builder declaration will be
 // generated; this provides a way to define complicated builders entirely
 // in C++.
 class OpBuilder<string p, code b = ""> {
   string params = p;
   code body = b;
 }
 
+// A base decorator class that may optionally be added to OpVariables.
+class OpVariableDecorator;
+
+// Class for providing additional information on the variables, i.e. arguments
+// and results, of an operation.
+class OpVariable<Constraint varConstraint, string desc = "",
+                 list<OpVariableDecorator> varDecorators = []> {
+  // The constraint, either attribute or type, of the argument.
+  Constraint constraint = varConstraint;
+
+  // A description for the argument.
+  string description = desc;
+
+  // The list of decorators for this variable, e.g. side effects.
+  list<OpVariableDecorator> decorators = varDecorators;
+}
+class Arg<Constraint constraint, string desc = "",
+          list<OpVariableDecorator> decorators = []>
+  : OpVariable<constraint, desc, decorators>;
+class Res<Constraint constraint, string desc = "",
+          list<OpVariableDecorator> decorators = []>
+  : OpVariable<constraint, desc, decorators>;
+
 // Base class for all ops.
 class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
   // The dialect of the op.
   Dialect opDialect = dialect;
 
   // The mnemonic of the op.
   string opName = mnemonic;
 

mlir/include/mlir/IR/SideEffects.td

class EffectOpInterfaceBase<string name, string baseEffect>
 
   // The base effect name of this interface.
   string baseEffectName = baseEffect;
 }
 
 // This class is the general base side effect class. This is used by derived
 // effect interfaces to define their effects.
 class SideEffect<EffectOpInterfaceBase interface, string effectName,
-                 string resourceName> {
+                 string resourceName> : OpVariableDecorator {
   /// The parent interface that the effect belongs to.
   string interfaceTrait = interface.trait;
 
   /// The name of the base effects class.
   string baseEffect = interface.baseEffectName;
 
   /// The derived effect that is being applied.
   string effect = effectName;

mlir/include/mlir/TableGen/Operator.h

public:
   std::string getOperationName() const;
 
   // Returns this op's C++ class name.
   StringRef getCppClassName() const;
 
   // Returns this op's C++ class name prefixed with namespaces.
   std::string getQualCppClassName() const;
 
+  /// A class used to represent the decorators of an operator variable, i.e.
+  /// argument or result.
+  struct VariableDecorator {
+  public:
+    explicit VariableDecorator(const llvm::Record *def) : def(def) {}
+    const llvm::Record &getDef() const { return *def; }
+
+  protected:
+    // The TableGen definition of this decorator.
+    const llvm::Record *def;
+  };
+
+  // A utility iterator over a list of variable decorators.
+  struct VariableDecoratorIterator
+      : public llvm::mapped_iterator<llvm::Init *const *,
+                                     VariableDecorator (*)(llvm::Init *)> {
+    using reference = VariableDecorator;
+
+    /// Initializes the iterator to the specified iterator.
+    VariableDecoratorIterator(llvm::Init *const *it)
+        : llvm::mapped_iterator<llvm::Init *const *,
+                                VariableDecorator (*)(llvm::Init *)>(it,
+                                                                     &unwrap) {}
+    static VariableDecorator unwrap(llvm::Init *init);
+  };
+  using var_decorator_iterator = VariableDecoratorIterator;
+  using var_decorator_range = llvm::iterator_range<VariableDecoratorIterator>;
+
   using value_iterator = NamedTypeConstraint *;
   using value_range = llvm::iterator_range<value_iterator>;
 
   // Returns true if this op has variadic operands or results.
   bool isVariadic() const;
 
   // Returns true if default builders should not be generated.
   bool skipDefaultBuilders() const;
public:
   const NamedTypeConstraint &getResult(int index) const {
     return results[index];
   }
 
   // Returns the `index`-th result's type constraint.
   TypeConstraint getResultTypeConstraint(int index) const;
   // Returns the `index`-th result's name.
   StringRef getResultName(int index) const;
+  // Returns the `index`-th result's decorators.
+  var_decorator_range getResultDecorators(int index) const;
 
   // Returns the number of variadic results in this operation.
   unsigned getNumVariadicResults() const;
 
   // Op attribute iterators.
   using attribute_iterator = const NamedAttribute *;
   attribute_iterator attribute_begin() const;
   attribute_iterator attribute_end() const;
public:
   // Op argument (attribute or operand) iterators.
   arg_iterator arg_begin() const;
   arg_iterator arg_end() const;
   arg_range getArgs() const;
 
   // Op argument (attribute or operand) accessors.
   Argument getArg(int index) const;
   StringRef getArgName(int index) const;
+  var_decorator_range getArgDecorators(int index) const;
 
   // Returns the trait wrapper for the given MLIR C++ `trait`.
   // TODO: We should add a C++ wrapper class for TableGen OpTrait instead of
   // requiring the raw MLIR trait here.
   const OpTrait *getTrait(llvm::StringRef trait) const;
 
   // Returns the number of regions.
   unsigned getNumRegions() const;

mlir/include/mlir/TableGen/SideEffects.h

+//===- SideEffects.h - Side Effects classes ---------------------*- C++ -*-===//
+//
+// Part of the MLIR Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Wrapper around side effect related classes defined in TableGen.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TABLEGEN_SIDEEFFECTS_H_
+#define MLIR_TABLEGEN_SIDEEFFECTS_H_
+
+#include "mlir/Support/LLVM.h"
+#include "mlir/TableGen/Operator.h"
+
+namespace mlir {
+namespace tblgen {
+
+// This class represents a specific instance of an effect that is being
+// exhibited.
+class SideEffect : public Operator::VariableDecorator {
+public:
+  // Return the name of the C++ effect.
+  StringRef getName() const;
+
+  // Return the name of the base C++ effect.
+  StringRef getBaseName() const;
+
+  // Return the name of the parent interface trait.
+  StringRef getInterfaceTrait() const;
+
+  // Return the name of the resource class.
+  StringRef getResource() const;
+
+  static bool classof(const Operator::VariableDecorator *var);
+};
+
+// This class represents an instance of a side effect interface applied to an
+// operation. This is a wrapper around an OpInterfaceTrait that also includes
+// the effects that are applied.
+class SideEffectTrait : public InterfaceOpTrait {
+public:
+  // Return the effects that are attached to the side effect interface.
+  Operator::var_decorator_range getEffects() const;
+
+  static bool classof(const OpTrait *t);
+};
+
+} // end namespace tblgen
+} // end namespace mlir
+
+#endif // MLIR_TABLEGEN_SIDEEFFECTS_H_

mlir/lib/TableGen/CMakeLists.txt

 add_llvm_library(LLVMMLIRTableGen
   Argument.cpp
   Attribute.cpp
   Constraint.cpp
   Dialect.cpp
   Format.cpp
   Operator.cpp
   OpClass.cpp
   OpInterfaces.cpp
   OpTrait.cpp
   Pattern.cpp
   Predicate.cpp
+  SideEffects.cpp
   Successor.cpp
   Type.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/TableGen
   )
 target_link_libraries(LLVMMLIRTableGen LLVMSupport LLVMTableGen)

mlir/lib/TableGen/Operator.cpp

tblgen::Operator::getResultTypeConstraint(int index) const {
   return TypeConstraint(cast<DefInit>(results->getArg(index)));
 }
 
 StringRef tblgen::Operator::getResultName(int index) const {
   DagInit *results = def.getValueAsDag("results");
   return results->getArgNameStr(index);
 }
 
+auto tblgen::Operator::getResultDecorators(int index) const
+    -> var_decorator_range {
+  Record *result =
+      cast<DefInit>(def.getValueAsDag("results")->getArg(index))->getDef();
+  if (!result->isSubClassOf("OpVariable"))
+    return var_decorator_range(nullptr, nullptr);
+  return *result->getValueAsListInit("decorators");
+}
+
 unsigned tblgen::Operator::getNumVariadicResults() const {
   return std::count_if(
       results.begin(), results.end(),
       [](const NamedTypeConstraint &c) { return c.constraint.isVariadic(); });
 }
 
 unsigned tblgen::Operator::getNumVariadicOperands() const {
   return std::count_if(
tblgen::Operator::arg_range tblgen::Operator::getArgs() const {
   return {arg_begin(), arg_end()};
 }
 
 StringRef tblgen::Operator::getArgName(int index) const {
   DagInit *argumentValues = def.getValueAsDag("arguments");
   return argumentValues->getArgName(index)->getValue();
 }
 
+auto tblgen::Operator::getArgDecorators(int index) const
+    -> var_decorator_range {
+  Record *arg =
+      cast<DefInit>(def.getValueAsDag("arguments")->getArg(index))->getDef();
+  if (!arg->isSubClassOf("OpVariable"))
+    return var_decorator_range(nullptr, nullptr);
+  return *arg->getValueAsListInit("decorators");
+}
+
 const tblgen::OpTrait *tblgen::Operator::getTrait(StringRef trait) const {
   for (const auto &t : traits) {
     if (auto opTrait = dyn_cast<tblgen::NativeOpTrait>(&t)) {
       if (opTrait->getTrait() == trait)
         return opTrait;
     } else if (auto opTrait = dyn_cast<tblgen::InternalOpTrait>(&t)) {
       if (opTrait->getTrait() == trait)
         return opTrait;
auto tblgen::Operator::getArg(int index) const -> Argument {
   return arguments[index];
 }
 
 void tblgen::Operator::populateOpStructure() {
   auto &recordKeeper = def.getRecords();
   auto typeConstraintClass = recordKeeper.getClass("TypeConstraint");
   auto attrClass = recordKeeper.getClass("Attr");
   auto derivedAttrClass = recordKeeper.getClass("DerivedAttr");
+  auto opVarClass = recordKeeper.getClass("OpVariable");
   numNativeAttributes = 0;
 
   DagInit *argumentValues = def.getValueAsDag("arguments");
   unsigned numArgs = argumentValues->getNumArgs();
 
   // Handle operands and native attributes.
   for (unsigned i = 0; i != numArgs; ++i) {
     auto arg = argumentValues->getArg(i);
     auto givenName = argumentValues->getArgNameStr(i);
     auto argDefInit = dyn_cast<DefInit>(arg);
     if (!argDefInit)
       PrintFatalError(def.getLoc(),
                       Twine("undefined type for argument #") + Twine(i));
     Record *argDef = argDefInit->getDef();
+    if (argDef->isSubClassOf(opVarClass))
+      argDef = argDef->getValueAsDef("constraint");
 
     if (argDef->isSubClassOf(typeConstraintClass)) {
       operands.push_back(
-          NamedTypeConstraint{givenName, TypeConstraint(argDefInit)});
+          NamedTypeConstraint{givenName, TypeConstraint(argDef)});
     } else if (argDef->isSubClassOf(attrClass)) {
       if (givenName.empty())
         PrintFatalError(argDef->getLoc(), "attributes must be named");
       if (argDef->isSubClassOf(derivedAttrClass))
         PrintFatalError(argDef->getLoc(),
                         "derived attributes not allowed in argument list");
       attributes.push_back({givenName, Attribute(argDef)});
       ++numNativeAttributes;
void tblgen::Operator::populateOpStructure() {
 
   // Populate `arguments`. This must happen after we've finalized `operands` and
   // `attributes` because we will put their elements' pointers in `arguments`.
   // SmallVector may perform re-allocation under the hood when adding new
   // elements.
   int operandIndex = 0, attrIndex = 0;
   for (unsigned i = 0; i != numArgs; ++i) {
     Record *argDef = dyn_cast<DefInit>(argumentValues->getArg(i))->getDef();
+    if (argDef->isSubClassOf(opVarClass))
+      argDef = argDef->getValueAsDef("constraint");
 
     if (argDef->isSubClassOf(typeConstraintClass)) {
       arguments.emplace_back(&operands[operandIndex++]);
     } else {
       assert(argDef->isSubClassOf(attrClass));
       arguments.emplace_back(&attributes[attrIndex++]);
     }
   }
 
   auto *resultsDag = def.getValueAsDag("results");
   auto *outsOp = dyn_cast<DefInit>(resultsDag->getOperator());
   if (!outsOp || outsOp->getDef()->getName() != "outs") {
     PrintFatalError(def.getLoc(), "'results' must have 'outs' directive");
   }
 
   // Handle results.
   for (unsigned i = 0, e = resultsDag->getNumArgs(); i < e; ++i) {
     auto name = resultsDag->getArgNameStr(i);
-    auto *resultDef = dyn_cast<DefInit>(resultsDag->getArg(i));
-    if (!resultDef) {
+    auto *resultInit = dyn_cast<DefInit>(resultsDag->getArg(i));
+    if (!resultInit) {
       PrintFatalError(def.getLoc(),
                       Twine("undefined type for result #") + Twine(i));
     }
+    auto *resultDef = resultInit->getDef();
+    if (resultDef->isSubClassOf(opVarClass))
+      resultDef = resultDef->getValueAsDef("constraint");
     results.push_back({name, TypeConstraint(resultDef)});
   }
 
   // Handle successors
   auto *successorsDag = def.getValueAsDag("successors");
   auto *successorsOp = dyn_cast<DefInit>(successorsDag->getOperator());
   if (!successorsOp || successorsOp->getDef()->getName() != "successor") {
     PrintFatalError(def.getLoc(),
void tblgen::Operator::print(llvm::raw_ostream &os) const {
   os << "op '" << getOperationName() << "'\n";
   for (Argument arg : arguments) {
     if (auto *attr = arg.dyn_cast<NamedAttribute *>())
       os << "[attribute] " << attr->name << '\n';
     else
       os << "[operand] " << arg.get<NamedTypeConstraint *>()->name << '\n';
   }
 }
+
+auto tblgen::Operator::VariableDecoratorIterator::unwrap(llvm::Init *init)
+    -> VariableDecorator {
+  return VariableDecorator(cast<llvm::DefInit>(init)->getDef());
+}

mlir/lib/TableGen/SideEffects.cpp

+//===- SideEffects.cpp - SideEffect classes -------------------------------===//
+//
+// Part of the MLIR Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/TableGen/SideEffects.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace mlir;
+using namespace mlir::tblgen;
+
+//===----------------------------------------------------------------------===//
+// SideEffect
+//===----------------------------------------------------------------------===//
+
+StringRef SideEffect::getName() const {
+  return def->getValueAsString("effect");
+}
+
+StringRef SideEffect::getBaseName() const {
+  return def->getValueAsString("baseEffect");
+}
+
+StringRef SideEffect::getInterfaceTrait() const {
+  return def->getValueAsString("interfaceTrait");
+}
+
+StringRef SideEffect::getResource() const {
+  auto value = def->getValueAsString("resource");
+  return value.empty() ? "::mlir::SideEffects::DefaultResource" : value;
+}
+
+bool SideEffect::classof(const Operator::VariableDecorator *var) {
+  return var->getDef().isSubClassOf("SideEffect");
+}
+
+//===----------------------------------------------------------------------===//
+// SideEffectsTrait
+//===----------------------------------------------------------------------===//
+
+Operator::var_decorator_range SideEffectTrait::getEffects() const {
+  auto *listInit = dyn_cast<llvm::ListInit>(def->getValueInit("effects"));
+  return {listInit->begin(), listInit->end()};
+}
+
+bool SideEffectTrait::classof(const OpTrait *t) {
+  return t->getDef().isSubClassOf("SideEffectsTraitBase");
+}

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

+// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
+
+include "mlir/IR/SideEffects.td"
+
+def TEST_Dialect : Dialect {
+  let name = "test";
+}
+class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
+    Op<TEST_Dialect, mnemonic, traits>;
+
+def SideEffectOpA : TEST_Op<"side_effect_op_a"> {
+  let arguments = (ins Arg<Variadic<AnyMemRef>, "", [MemRead]>);
+  let results = (outs Res<AnyMemRef, "", [MemAlloc<"CustomResource">]>);
+}
+
+def SideEffectOpB : TEST_Op<"side_effect_op_b",
+    [MemoryEffects<[MemWrite<"CustomResource">]>]>;
+
+// CHECK: void SideEffectOpA::getEffects
+// CHECK:   for (Value value : getODSOperands(0))
+// CHECK:     effects.emplace_back(MemoryEffects::Read::get(), value, ::mlir::SideEffects::DefaultResource::get());
+// CHECK:   for (Value value : getODSResults(0))
+// CHECK:     effects.emplace_back(MemoryEffects::Allocate::get(), value, CustomResource::get());
+
+// CHECK: void SideEffectOpB::getEffects
+// CHECK:   effects.emplace_back(MemoryEffects::Write::get(), CustomResource::get());

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 #include "mlir/Support/STLExtras.h"
 #include "mlir/Support/StringExtras.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/OpInterfaces.h"
 #include "mlir/TableGen/OpTrait.h"
 #include "mlir/TableGen/Operator.h"
+#include "mlir/TableGen/SideEffects.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 #define DEBUG_TYPE "mlir-tblgen-opdefgen"
private:
   void genSuccessorVerifier(OpMethodBody &body);
 
   // Generates the traits used by the object.
   void genTraits();
 
   // Generate the OpInterface methods.
   void genOpInterfaceMethods();
 
+  // Generate the side effect interface methods.
+  void genSideEffectInterfaceMethods();
+
 private:
   // The TableGen record for this op.
   // TODO(antiagainst,zinenko): OpEmitter should not have a Record directly,
   // it should rather go through the Operator for better abstraction.
   const Record &def;
 
   // The wrapper operator class for querying information from this op.
   Operator op;
OpEmitter::OpEmitter(const Operator &op)
   genBuilder();
   genParser();
   genPrinter();
   genVerifier();
   genCanonicalizerDecls();
   genFolderDecls();
   genOpInterfaceMethods();
   generateOpFormat(op, opClass);
+  genSideEffectInterfaceMethods();
 }
 
 void OpEmitter::emitDecl(const Operator &op, raw_ostream &os) {
   OpEmitter(op).emitDecl(os);
 }
 
 void OpEmitter::emitDef(const Operator &op, raw_ostream &os) {
   OpEmitter(op).emitDef(os);
for (auto method : interface.getMethods()) {
       opClass.newMethod(method.getReturnType(), method.getName(), os.str(),
                         method.isStatic() ? OpMethod::MP_Static
                                           : OpMethod::MP_None,
                         /*declOnly=*/true);
     }
   }
 }
 
+void OpEmitter::genSideEffectInterfaceMethods() {
+  enum EffectKind { Operand, Result, Static };
+  struct EffectLocation {
+    /// The effect applied.
+    SideEffect effect;
+
+    /// The index if the kind is either operand or result.
+    unsigned index : 30;
+
+    /// The kind of the location.
+    EffectKind kind : 2;
+  };
+
+  StringMap<SmallVector<EffectLocation, 1>> interfaceEffects;
+  auto resolveDecorators = [&](Operator::var_decorator_range decorators,
+                               unsigned index, EffectKind kind) {
+    for (auto decorator : decorators)
+      if (SideEffect *effect = dyn_cast<SideEffect>(&decorator))
+        interfaceEffects[effect->getInterfaceTrait()].push_back(
+            EffectLocation{*effect, index, kind});
+  };
+
+  // Collect effects that were specified via:
+  /// Traits.
+  for (const auto &trait : op.getTraits())
+    if (const auto *opTrait = dyn_cast<tblgen::SideEffectTrait>(&trait))
+      resolveDecorators(opTrait->getEffects(), /*index=*/0, EffectKind::Static);
+  /// Operands.
+  for (unsigned i = 0, operandIt = 0, e = op.getNumArgs(); i != e; ++i) {
+    if (op.getArg(i).is<NamedTypeConstraint *>()) {
+      resolveDecorators(op.getArgDecorators(i), operandIt, EffectKind::Operand);
+      ++operandIt;
+    }
+  }
+  /// Results.
+  for (unsigned i = 0, e = op.getNumResults(); i != e; ++i)
+    resolveDecorators(op.getResultDecorators(i), i, EffectKind::Result);
+
+  for (auto &it : interfaceEffects) {
+    StringRef baseEffect = it.second.front().effect.getBaseName();
+    auto effectsParam =
+        llvm::formatv(
+            "SmallVectorImpl<SideEffects::EffectInstance<{0}>> &effects",
+            baseEffect)
+            .str();
+
+    // Generate the 'getEffects' method.
+    auto &getEffects = opClass.newMethod("void", "getEffects", effectsParam);
+    auto &body = getEffects.body();
+
+    // Add effect instances for each of the locations marked on the operation.
+    for (auto &location : it.second) {
+      if (location.kind != EffectKind::Static) {
+        body << "  for (Value value : getODS"
+             << (location.kind == EffectKind::Operand ? "Operands" : "Results")
+             << "(" << location.index << "))\n  ";
+      }
+
+      body << "  effects.emplace_back(" << location.effect.getName()
+           << "::get()";
+
+      // If the effect isn't static, it has a specific value attached to it.
+      if (location.kind != EffectKind::Static)
+        body << ", value";
+      body << ", " << location.effect.getResource() << "::get());\n";
+    }
+  }
+}
+
 void OpEmitter::genParser() {
   if (!hasStringAttribute(def, "parser") ||
       hasStringAttribute(def, "assemblyFormat"))
     return;
 
   auto &method = opClass.newMethod(
       "ParseResult", "parse", "OpAsmParser &parser, OperationState &result",
       OpMethod::MP_Static);