[mlir][Linalg] Extend generic ops to allow tensors

[nicolasvasilache]

Summary

This diff adds support to allow linalg.generic and
linalg.indexed_generic to take tensor input and output
arguments.

The subset of output tensor operand types must appear
verbatim in the result types after an arrow. The parser,
printer and verifier are extended to accomodate this
behavior.

The Linalg operations now support variadic ranked tensor
return values. This extension exhibited issues with the
current handling of NativeCall in RewriterGen.cpp. As a
consequence, RewriteerGen is tentatively special-cased to
support the new behavior (better suggestions are welcome).

Relevant cleanups and name uniformization are applied.

Relevant invalid and roundtrip test are added.

[merge_guards_bot]

Unit tests: pass. 61127 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[rriddle]

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

118

getInputs().getTypes()

Also, use Type|Value instead of auto. They are practically the same amount of characters.

119

nit: Merge assignment and condition
if (auto t = ...)

128

Same comments as above.

mlir/include/mlir/Dialect/Linalg/Transforms/LinalgTransforms.h

83

Why SmallVector<..., 0>?

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

67

Can you just use the same mechanism as 2 lines above? i.e. just stream it.

102

You need to check this for failure

mlir/tools/mlir-tblgen/RewriterGen.cpp

585

It isn't immediately clear to me why this is necessary. What return value is convertible to small vector, but not ArrayRef for example?

[ftynse]

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

92–93

Nit: Query -> Return, otherwise it souds like you query none

391

Reuse LinalgOperand.predicate here

541

Do you allow mixing tensor and memref arguments? If so, consider mentioning it explicitly.

603

Is this a placeholder? Consider using an op instead "some.condition(...)", a comment looks like it's related to the following code, but it is not.

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

308

Nit: use emitOpError if you want to refer the op name and drop the "op " part of the message

mlir/lib/Dialect/Linalg/Transforms/LinalgTransforms.cpp

187

should this rather be an assert(succeeded(...) && ...) ?

266

return isa_and_nonnull<...

mlir/lib/Dialect/VectorOps/VectorTransforms.cpp

500–501

Nit: would llvm::to_vector<1> work?

[nicolasvasilache]

Locally #include "Intrinsics.h" to try and avoid

clang-tidy: error: 'mlir/Dialect/Linalg/EDSC/Intrinsics.h' file not found [clang-diagnostic-error]

[merge_guards_bot]

Unit tests: pass. 61127 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[nicolasvasilache]

Addressing review comments

mlir/include/mlir/Dialect/Linalg/Transforms/LinalgTransforms.h

83

This needs a type compatible with SmallVector<Value, x> to be used as a NativeCall with for an op with Variadic returns.
Do you have a better suggestion?

mlir/lib/Dialect/VectorOps/VectorTransforms.cpp

500–501

Nope, this is just constructing a 1-element vector from a single value.

mlir/tools/mlir-tblgen/RewriterGen.cpp

585

Reworked and added a comment.

[merge_guards_bot]

Unit tests: pass. 61127 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[nicolasvasilache]

mlir/include/mlir/Dialect/Linalg/Transforms/LinalgTransforms.h

83

tentatively marking "Done", will update if a better suggestion is given.

[nicolasvasilache]

Addressing more review comments.

[nicolasvasilache]

Undo local include of Intrinsics.h, this is a clang-tidy issue.

[merge_guards_bot]

Unit tests: pass. 61127 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[merge_guards_bot]

Unit tests: pass. 61127 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[nicolasvasilache]

Update commit message.

[merge_guards_bot]

Unit tests: pass. 61159 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[rriddle]

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

187

All of this cleanup seems unrelated to this revision. It would be easier to review if you moved such changes out.

mlir/tools/mlir-tblgen/RewriterGen.cpp

585

Could you use ValueRange instead?

[nicolasvasilache]

Rebase on top of previously separated cleanups.

[nicolasvasilache]

mlir/tools/mlir-tblgen/RewriterGen.cpp

585

Not immediately:

/usr/local/google/home/ntv/work/github/llvm-project/mlir/include/mlir/IR/OperationSupport.h:623:3: note: candidate constructor
  ValueRange(iterator_range<OperandRange::iterator> values)
  ^
/usr/local/google/home/ntv/work/github/llvm-project/mlir/include/mlir/IR/OperationSupport.h:625:3: note: candidate constructor
  ValueRange(iterator_range<ResultRange::iterator> values)
  ^
/usr/local/google/home/ntv/work/github/llvm-project/mlir/include/mlir/IR/OperationSupport.h:627:3: note: candidate constructor
  ValueRange(ArrayRef<Value> values = llvm::None);
  ^
/usr/local/google/home/ntv/work/github/llvm-project/mlir/include/mlir/IR/OperationSupport.h:628:3: note: candidate constructor
  ValueRange(OperandRange values);
  ^
/usr/local/google/home/ntv/work/github/llvm-project/mlir/include/mlir/IR/OperationSupport.h:629:3: note: candidate constructor
  ValueRange(ResultRange values);
  ^
/usr/local/google/home/ntv/work/github/llvm-project/mlir/include/mlir/Support/STLExtras.h:223:3: note: candidate inherited constructor
  indexed_accessor_range_base(const iterator_range<iterator> &range)
  ^
/usr/local/google/home/ntv/work/github/llvm-project/mlir/include/mlir/IR/OperationSupport.h:613:21: note: constructor from base class 'indexed_accessor_range_base<mlir::ValueRange, llvm::PointerUnion<const mlir::Value *, mlir::OpOperand *, mlir::OpResult *>, mlir::Value, mlir::Value, mlir::Value>' inherited here
  using RangeBaseT::RangeBaseT;

[nicolasvasilache]

Fix warning on unused uncaptured attribute in RewriterGen.

[nicolasvasilache]

mlir/tools/mlir-tblgen/RewriterGen.cpp

585

Forgot the first line, here:

tools/mlir/test/lib/Transforms/../DeclarativeTransforms/TestLinalgTransformPatterns.h.inc:579:19: error: call to constructor of 'mlir::ValueRange' is ambiguous
    for (auto v : ValueRange{ {permuteGenericLinalgOp(rewriter, op, {1, 2, 0}, "PERMUTE")} }) { tblgen_repl_values.push_back(v); }
                  ^         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[merge_guards_bot]

Unit tests: pass. 61169 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[merge_guards_bot]

Unit tests: pass. 61169 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[nicolasvasilache]

clang-format.

[merge_guards_bot]

Unit tests: pass. 61169 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[mravishankar]

Without commenting on the specifics of the change itself, was wondering what advantage there is to allow generic ops to take tensor values as well. Until now lowering from Linalg to (say) GPU Dialect was fairly straight-forward cause Linalg operated on memref types. I am not sure what would happen if the generic op with tensors would be lowered to GPU dialect (presumably should be an error), and lowering it correctly would need some buffer allocation to kick in. So it seems like this is adding complexity. Could you please provide some context behind the need for this change?

[nicolasvasilache]

@mravishankar actually this will simplify things quite a lot.
Copy-pasting from the [e-mail] discussion: https://groups.google.com/a/tensorflow.org/g/mlir/c/pbWk9a-t3Xc

This has a number of implications in some of the transformations that are traditionally done at the level of the HLO dialect.
In particular, everything related to trivial fusion of pointwise operators can be done immediately using the region.
This avoids the need for the current, more cumbersome and phase-ordered, flow that does:
1. mark fusion with XLA fusion nodes,
2. allocate buffers for everything
3. convert to Linalg
4. apply fusion in Linalg
5. perform an analysis and remove temporary buffers that have been fused.

Note that step 4. may not necessarily do what one wants at step 1. since we are talking about different systems that are not really designed to talk to each other.

Instead, this can be replaced by:
1. apply fusion of ops using regions

Temporary buffers never get materialized or anything.
This becomes especially handy when implicit of explicit broadcast semantics are involved: some things are trivial to fuse at the level of Linalg on tensors and all the unnecessary intermediate memory is never allocated.

There are many other implications on the type of transforms that become available at this level (hint: look at the TASO compiler) but I only listed the most obvious one.

In my mind the codegen path where things are the most natural is:

User
-> Language / Framework 
-> HLO + Linalg on tensors 
-> LHLO + Linalg on buffers 
(note that buffer allocation in Linalg on tensors -> Linalg on buffers can be very progressive intermixing ops with both tensor and buffers arbitrarily)
-> Affine/StructuredControlFlow (still named Loops atm ..)
-> backends

Different transformations apply at each level.

This does of course not remove the need for the buffer allocation pass but it is just a trivial extension of what already exists.
The particular case you mention: linalg + tensors -> GPU is illegal, the IR must be legalized with buffer allocation first.

[rriddle]

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

118

Can we use Type instead of auto here? Same below.

mlir/tools/mlir-tblgen/RewriterGen.cpp

585

This is extremely unfortunate and should really get some attention if we have to do this. Can you file a bug so that this is cleaned up? We shouldn't be materializing vectors like this if we don't need to.

[nicolasvasilache]

Addressed, thanks!

[nicolasvasilache]

@rriddle hmm had forgotten to arc diff --update one more time but the last 2 points you made are in (see e.g. https://github.com/llvm/llvm-project/commit/2140a973f272969b5391532f3c0b7c90aafd803b#diff-c16fe9decadb57cda4e978ed72e24966R581)

[mravishankar]

@nicolasvasilache : Totally agree with all the points you make. I understand the advantage of performing fusion at the tensor level. I was under the impression that there would be a separate dialect for "Linalg operations on tensors", and the buffer allocation pass would "convert" from that dialect into the existing Linalg dialect. But, I guess inter-mixing of operations from different dialects to having different "incarnations" of the operation (one operating on tensors and other on buffers) is equivalent. I see that this makes sense for generic ops, but how would this work for other operations like linalg.matmul and linalg.matvec, etc. where I am not sure you can have a tensor argument. So it seems like this is making generic ops different than other linalg ops.
Another question is about buffer allocation. Is there some buffer allocation already implemented in Linalg?
In any case, since the contract between Linalg and other "backend" dialects is that the lowering is only supported if Linalg ops work on memrefs, I dont really have any major concerns and happy to see how things work out.

[• yangjunpro]

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

550

"that create"==>"which create", small typos

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

113

"Value v", might change to pass by reference for better performance? Although it might be a little bit marginal here.

127

There is a little bit duplicated code between getInputTensorTypes() and getOutputTensorTypes(), do we need to extract a small common function for reusability?

mlir/include/mlir/Dialect/Linalg/Transforms/LinalgTransforms.h

83

Can't we directly write the return type as SmallVector<Value> ? "0" looks peculiar here.

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

319

If we already have the index, why do we bother to use the zip()?
I think by directly use op.getResultTypes()[index], outputTensorTypes[index] is enough.

[nicolasvasilache]

@yangjunpro addressed in https://reviews.llvm.org/D72112 thanks!

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

113

Value is a POD, taking a reference would actually add a level of indirection and could be detrimental to perf.

mlir/include/mlir/Dialect/Linalg/Transforms/LinalgTransforms.h

83

SmallVector really wants 2 template args.

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

319

getResultTypes is an iterator range and does not work with random access.

[nicolasvasilache]

@mravishankar

I was under the impression that there would be a separate dialect for "Linalg operations on tensors", and the buffer allocation pass would "convert" from that dialect into the existing Linalg dialect. But, I guess inter-mixing of operations from different dialects to having different "incarnations" of the operation (one operating on tensors and other on buffers) is equivalent.

Yes this was the original intention but I realized that this didn't warrant yet another dialect and lowering can be made much more progressive by mixing types.

I see that this makes sense for generic ops, but how would this work for other operations like linalg.matmul and linalg.matvec, etc. where I am not sure you can have a tensor argument. So it seems like this is making generic ops different than other linalg ops.

Actually all these named ops should be auto-generated as special configurations of generic ops. See my comments on this thread: https://groups.google.com/a/tensorflow.org/g/mlir/c/CUL3_8fnJb4
The fact that there are manually declared matmul, conv etc ops today is more historical, they should be retired in the future.

Another question is about buffer allocation. Is there some buffer allocation already implemented in Linalg?

Not yet but it is very easy to do something simple that can evolve over time.

Thanks for your comments and questions!

[nicolasvasilache]

This was submitted as 2140a973f272969b5391532f3c0b7c90aafd803b

[nicolasvasilache]

For some reason this does not close automatically despite the landing and the commit message listing this diff.
Abandonning manually.

mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h

 //===- Builders.h - MLIR Declarative Linalg Builders ------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides intuitive composable interfaces for building structured MLIR
 // snippets in a declarative fashion.
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_DIALECT_LINALG_EDSC_BUILDERS_H_
 #define MLIR_DIALECT_LINALG_EDSC_BUILDERS_H_
 
-#include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
+#include "Intrinsics.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/EDSC/Builders.h"
 #include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 
 namespace mlir {
 class BlockArgument;
 
 namespace edsc {
 enum class IterType { Parallel, Reduction };
 
 inline StringRef toString(IterType t) {
   switch (t) {
   case IterType::Parallel:
     return getParallelIteratorTypeName();
   case IterType::Reduction:
     return getReductionIteratorTypeName();
   default:
     llvm_unreachable("Unsupport IterType");
   }
 }
 
 /// A StructuredIndexed represents a captured value that can be indexed and
-/// passed to the `makeLinalgGenericOp`. It allows writing intuitive index
+/// passed to the `makeGenericLinalgOp`. It allows writing intuitive index
 /// expressions such as:
 ///
 /// ```
 ///      StructuredIndexed A(vA), B(vB), C(vC);
-///      makeLinalgGenericOp({A({m, n}), B({k, n})}, {C({m, n})}, ... );
+///      makeGenericLinalgOp({A({m, n}), B({k, n})}, {C({m, n})}, ... );
 /// ```
 struct StructuredIndexed {
   StructuredIndexed(Value v) : value(v) {}
   StructuredIndexed operator()(ArrayRef<AffineExpr> indexings) {
     return StructuredIndexed(value, indexings);
   }
 
   operator Value() const /* implicit */ { return value; }
   ArrayRef<AffineExpr> getExprs() { return exprs; }
 
 private:
   StructuredIndexed(Value v, ArrayRef<AffineExpr> indexings)
       : value(v), exprs(indexings.begin(), indexings.end()) {
     assert(v->getType().isa<MemRefType>() && "MemRefType expected");
   }
   StructuredIndexed(ValueHandle v, ArrayRef<AffineExpr> indexings)
       : StructuredIndexed(v.getValue(), indexings) {}
 
   Value value;
   SmallVector<AffineExpr, 4> exprs;
 };
 
 inline void defaultRegionBuilder(ArrayRef<BlockArgument> args) {}
 
-Operation *makeLinalgGenericOp(
+Operation *makeGenericLinalgOp(
     ArrayRef<IterType> iteratorTypes, ArrayRef<StructuredIndexed> inputs,
     ArrayRef<StructuredIndexed> outputs,
     function_ref<void(ArrayRef<BlockArgument>)> regionBuilder =
         defaultRegionBuilder,
     ArrayRef<Value> otherValues = {}, ArrayRef<Attribute> otherAttributes = {});
 
 namespace ops {
 using edsc::StructuredIndexed;

mlir/include/mlir/Dialect/Linalg/IR/LinalgBase.td

 #define LINALG_BASE
 
 include "mlir/IR/OpBase.td"
 
 def Linalg_Dialect : Dialect {
   let name = "linalg";
   let description = [{
     The `linalg` dialect groups together a set of types, operations and
-    transformations that are useful to implement a structured abstraction where
-    ops can lower to scalar load/store and operations or to more general library
-    calls.
+    transformations that are useful to implement a structured abstraction on
+    buffers and tensors. These abstractions are useful for transformations and
+    can lower to scalar load/store and other operations or to more general
+    library calls.
 
     The `linalg` dialect manipulates the following types and operations:
 
     ### Core data types and special ops.
 
     The following abstractions are used by the `linalg` dialect:
 
     #### Views
Future ops are added on a per-need basis but should include:
         * `linalg.intersection`,
         * `linalg.convex_union`,
         * `linalg.difference` (would need to work on a list of views).
 
     ### Payload Ops
     A set of payload carrying operations that implement the [structured ops](
     https://docs.google.com/presentation/d/1P-j1GrH6Q5gLBjao0afQ-GfvcAeF-QU4GXXeSy0eJ9I/edit#slide=id.p
     )
-    abstraction on buffers. `linalg` has `2` generic operations `linalg.generic`
-    and `linalg.indexed_generic` for expressing custom operations. This is
-    subject to further evolution as transformations and analyses continue to be
-    developed.
+    abstraction on tensors and buffers. `linalg` has `2` generic operations
+    `linalg.generic` and `linalg.indexed_generic` for expressing custom
+    operations.
+    This is subject to further evolution as transformations and analyses
+    continue to be developed.
 
-    Additionally, `linalg` provides some common named operations:
+    Additionally, `linalg` provides some commonly named operations:
 
         * `linalg.copy`,
         * `linalg.fill`,
         * `linalg.dot`,
         * `linalg.matmul`,
         * `linalg.conv`.
 
     Future ops are added on a per-need basis but should include:

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

[{
       build(builder, result, rangeType, min, max, step);
     }]>];
 
   // Fully specified by traits.
   let verifier = ?;
 }
 
 def Linalg_SliceOp : Linalg_Op<"slice", [NoSideEffect]>,
-    Arguments<(ins AnyStridedMemRef:$view, Variadic<AnyTypeOf<[Range, Index]>>:$indexings)>,
+    Arguments<(ins AnyStridedMemRef:$view,
+                   Variadic<AnyTypeOf<[Range, Index]>>:$indexings)>,
     Results<(outs AnyStridedMemRef)> {
   let summary = "Produce a rank-reduced `subview` of a base `view`.";
   let description = [{
     The `linalg.slice` op allows defining a subregion of a smaller rank than the
     operand `view` within the underlying buffer.
 
     A `linalg.slice` op takes a view and a variadic number of indexings and
     produces a `view` of the same elemental type. An indexing is either:
def Linalg_SliceOp : Linalg_Op<"slice", [NoSideEffect]>,
   }];
 
   let builders = [OpBuilder<
     "Builder *b, OperationState &result, Value base, "
     "ValueRange indexings">];
 
   let extraClassDeclaration = [{
     enum { FirstIndexingOperand = 1 };
-    unsigned getRank() { return getViewType().getRank(); }
-    Type getElementType() { return getViewType().getElementType(); }
-    MemRefType getViewType() { return getType().cast<MemRefType>(); }
+    unsigned getRank() { return getShapedType().getRank(); }
+    Type getElementType() { return getShapedType().getElementType(); }
+    ShapedType getShapedType() { return getType().cast<ShapedType>(); }
     unsigned getBaseViewRank() { return getBaseViewType().getRank(); }
-    MemRefType getBaseViewType() { return view()->getType().cast<MemRefType>(); }
+    ShapedType getBaseViewType() { return view()->getType().cast<ShapedType>();}
 
     // Get the underlying indexing at a given rank.
     Value indexing(unsigned rank) { return *(indexings().begin() + rank); }
 
     // Get the subset of indexings that are of RangeType.
     SmallVector<Value, 8> getRanges() {
       SmallVector<Value, 8> res;
       for (auto operand : indexings())
         if (!operand->getType().isa<IndexType>())
           res.push_back(operand);
       return res;
     }
   }];
 }
 
 def Linalg_TransposeOp : Linalg_Op<"transpose", [NoSideEffect]>,
     Arguments<(ins AnyStridedMemRef:$view, AffineMapAttr:$permutation)>,
     Results<(outs AnyStridedMemRef)> {
-  let summary = "transpose operation produces a new strided memref (metadata-only)";
+  let summary = "`transpose` produces a new strided memref (metadata-only)";
   let description = [{
     The `linalg.transpose` op produces a strided memref whose sizes and strides
     are a permutation of the original `view`. This is a pure metadata
     transformation.
 
     Example:
 
     ```mlir
        %1 = linalg.transpose %0 (i, j) -> (j, i) : memref<?x?xf32, stride_spec>
     ```
   }];
 
   let builders = [OpBuilder<
     "Builder *b, OperationState &result, Value view, "
     "AffineMapAttr permutation, ArrayRef<NamedAttribute> attrs = {}">];
 
   let verifier = [{
     if (!permutation().isPermutation())
       return emitOpError("expected a permutation map");
-    if (permutation().getNumDims() != getViewType().getRank())
+    if (permutation().getNumDims() != getShapedType().getRank())
       return emitOpError("expected a permutation map of same rank as the view");
     return success();
   }];
 
   let extraClassDeclaration = [{
     static StringRef getPermutationAttrName() { return "permutation"; }
-    MemRefType getViewType() { return view()->getType().cast<MemRefType>(); }
+    ShapedType getShapedType() { return view()->getType().cast<ShapedType>(); }
   }];
 }
 
 def Linalg_YieldOp : Linalg_Op<"yield", [NativeOpTrait<"IsTerminator">]>,
     Arguments<(ins Variadic<AnyType>:$values)> {
   let summary = "Linalg yield operation";
   let description = [{
     `linalg.yield` is a special terminator operation for blocks inside regions

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

class NInputs<int args_in> :
   NativeOpTrait<"linalg::NInputs<" # !cast<string>(args_in) # ">::Impl"> {}
 
 // The Linalg `NOutputs` trait provides the API for ops that are known
 // to have a specified number of outputs, all passed as operands.
 // See Linalg/LinalgTraits.h for implementation details an usage.
 class NOutputs<int args_out> :
   NativeOpTrait<"linalg::NOutputs<" # !cast<string>(args_out) # ">::Impl"> {}
 
-def ViewTraits : NativeOpTrait<"linalg::ViewTraits">;
+def StructuredOpTraits : NativeOpTrait<"linalg::StructuredOpTraits">;
 
 // The linalg 'LinalgStructuredInterface' provides access to the 'LinalgOp'
 // interface.
 def LinalgStructuredInterface : OpInterface<"LinalgOp"> {
   let methods = [
     InterfaceMethod<
       "Query the number of inputs from the current operation.",
       "unsigned", "getNumInputs"
InterfaceMethod<
       "unsigned", "getNumLoops">,
     InterfaceMethod<"Query the input view at the given index.",
       "Value ", "getInput", (ins "unsigned":$i)
     >,
     InterfaceMethod<"Query the output view at the given index.",
       "Value ", "getOutput", (ins "unsigned":$i)
     >,
     InterfaceMethod<[{
-        Query the index of the given input value, or `None` if the value is not
-        an input.
+        Return the index of the given input value `v`, or `None` if the value is
+        not an input.
       }],
-      "llvm::Optional<unsigned>", "getIndexOfInput", (ins "Value ":$view)
+      "llvm::Optional<unsigned>", "getIndexOfInput", (ins "Value ":$v)
     >,
     InterfaceMethod<[{
         Query the index of the given view value, or `None` if the value is not
-        an view.
+        a view.
       }],
       "llvm::Optional<unsigned>", "getIndexOfOutput", (ins "Value ":$view)
     >,
     InterfaceMethod<[{
-        Query the type of the input view at the given index.
-      }], "MemRefType", "getInputViewType", (ins "unsigned":$i)>,
+        Query the type of the input shape at the given index.
+      }], "ShapedType", "getInputShapedType", (ins "unsigned":$i)>,
     InterfaceMethod<[{
         Query the type of the output view at the given index.
-      }], "MemRefType", "getOutputViewType", (ins "unsigned":$i)>,
+      }], "ShapedType", "getOutputShapedType", (ins "unsigned":$i)>,
+    InterfaceMethod<[{
+        Query whether the op has only MemRef input and outputs.
+      }], "bool", "hasBufferSemantics">,
+    InterfaceMethod<[{
+        Query the subset of input operands that are of ranked tensor type.
+      }], "SmallVector<RankedTensorType, 4>", "getInputTensorTypes">,
+    InterfaceMethod<[{
+        Query the subset of output operands that are of ranked tensor type.
+      }], "SmallVector<RankedTensorType, 4>", "getOutputTensorTypes">,
 
     StaticInterfaceMethod<[{
         Create an operation of the current type with the given location,
         operands, and attributes.
       }],
       "Operation *", "create",
       (ins "OpBuilder &":$builder, "Location":$loc,
            "ValueRange":$operands,

 }
 
 // Base Tablegen class for Linalg ops.
 // Linalg ops that correspond to library calls operate on linalg::View as their
 // first operands. These may be optionally followed by non-view operands
 // depending on the specific Linalg op.
 class LinalgStructuredBase_Op<string mnemonic, list<OpTrait> props>
   : Op<Linalg_Dialect, mnemonic,
-       !listconcat(props, [ViewTraits, LinalgStructuredInterface])> {
+       !listconcat(props, [StructuredOpTraits, LinalgStructuredInterface])> {
   let parser = [{ return parseLinalgStructuredOp(parser, result); }];
   let printer = [{ printLinalgStructuredOp(p, *this); }];
 }
 
 class LinalgStructured_Op<string mnemonic, list<OpTrait> props>
   : LinalgStructuredBase_Op<mnemonic, props> {
   code libraryCallName = [{
     std::string getLibraryCallName() {
let extraClassDeclaration = libraryCallName # [{
     unsigned getNumInputFeatureDimensions() { return 1; }
     unsigned getNumOutputFeatureDimensions() { return 1; }
 
     ArrayAttr indexing_maps();
 
     ArrayAttr iterator_types() {
       // Outer parallel loops are always the number of output dimensions; i.e.
       // [ b, xs, q] in the TF notation above.
-      unsigned nPar = getOutputViewType(0).getRank();
+      unsigned nPar = getOutputShapedType(0).getRank();
       unsigned nRed = getNumInputFeatureDimensions();
       // Window loops are a special kind of reduction that is never tiled or
       // parallelized across; i.e. [zs] in the TF notation above whose number
       // match `xs` (i.e. 1 window loop per "image" dimension).
       // This may evolve in the future.
       unsigned nWin =
         nPar - getNumBatchDimensions() - getNumInputFeatureDimensions();
       MLIRContext *ctx = getContext();
int64_t getDilation(unsigned i) {
       if (!dilations().hasValue()) return 1;
       return dilations()->getValue()[i]
         .cast<IntegerAttr>().getValue().getSExtValue();
     }
   }];
   let verifier = [{ return ::verify(*this); }];
 }
 
+def LinalgOperand: Type<
+  Or<[AnyRankedTensor.predicate, AnyStridedMemRef.predicate]>>;
+
+class LinalgOperandOfRank<int rank>: Type<
+  And<[
+    LinalgOperand.predicate,
+    CPred<"$_self.cast<ShapedType>().getRank() == " # rank>]
+  >>;
+
 class GenericOpBase<string mnemonic> : LinalgStructuredBase_Op<mnemonic, []> {
-  let arguments = (ins Variadic<AnyStridedMemRef>:$views,
+  let arguments = (ins Variadic<LinalgOperand>:$views,
                    I64Attr:$args_in,
                    I64Attr:$args_out,
                    AffineMapArrayAttr:$indexing_maps,
                    ArrayAttr:$iterator_types,
                    OptionalAttr<StrAttr>:$doc,
                    OptionalAttr<FlatSymbolRefAttr>:$fun,
                    OptionalAttr<StrAttr>:$library_call);
+  let results = (outs Variadic<AnyRankedTensor>:$output_tensors);
   let regions = (region AnyRegion:$region);
   let extraClassDeclaration = [{
     SmallVector<StringRef, 8> linalgTraitAttrNames() {
       return SmallVector<StringRef, 8>{
         getArgsInAttrName(), getArgsOutAttrName(), getDocAttrName(),
         getFunAttrName(), getIndexingMapsAttrName(), getLibraryCallAttrName(),
         getIteratorTypesAttrName()
       };
loop.for %m = %c0 to %M step %c1 {
           %c = linalg.load %C[%m, %n] : memref<?x?xf32, stride_specification>
           %d = call @func_of_elements(%a, %b, %c)
                  : (f32, f32, f32) -> (f32)
           linalg.store %d, %C[%m, %n] : memref<?x?x?xf32, stride_specification>
         }
       }
     }
     ```
+
+    To allow progressive lowering from the value world (a.k.a tensor values) to
+    the buffer world (a.k.a memref values), a `linalg.generic` op accepts
+    mixing input and output ranked tensor values with input and output memrefs.
+
+    ```mlir
+      %1 = linalg.generic #trait_attribute %A, %B, %C {other-attributes} :
+        tensor<?x?xf32>,
+        memref<?x?xf32, stride_specification>,
+        tensor<?x?xf32>
+        -> (tensor<?x?xf32>)
+    ```
+
+    In this case, the number of return values must match the number of output
+    tensor arguments. The semantics is that the `linalg.generic` op
+    produces (i.e. allocates and fills) its return values.
+    Tensor values must be legalized by a buffer allocation pass before most
+    transformations can be applied. In particular, transformations that create
+    control flow around linalg.generic operations are not expected to mix with
+    tensors because SSA values do not escape naturally. Still, transformations
+    and rewrites that take advantage of tensor SSA values are expected to be
+    useful and will be added in the near future.
   }];
   let verifier = [{ return ::verify(*this); }];
 }
 
 def IndexedGenericOp : GenericOpBase<"indexed_generic"> {
   let description = [{
     Indexed Generic Linalg op form where the key properties of the computation
     are specified as attributes. In pretty form, a linalg.indexed_generic op is
Where #trait_attributes is an alias of a dictionary attribute containing:
       - iterator_types: an ArrayAttr they type of the enclosing loops; Each
         element of the list represents and iterator of one of the following
         types:
           parallel, reduction, window
 
     Example:
     Defining a #matmul_trait attribute in MLIR can be done as follows:
       ```mlir
-        func @fma(%i: index, %j: index, %k: index, %a: f32, %b: f32, %c: f32)
+        func @fma(%offset_m: index, %offset_n: index, %offset_k: index,
+                  %a: f32, %b: f32, %c: f32)
           -> f32
         {
+          "some_optional_condition"(%offset_m, %offset_n, %offset_k)
           %d = mulf %a, %b: f32
           %e = addf %c, %d: f32
           return %e: f32
         }
         #matmul_accesses = [
           (m, n, k) -> (m, k),
           (m, n, k) -> (k, n),
           (m, n, k) -> (m, n)
And can be reused in multiple places as:
         linalg.indexed_generic #matmul_trait %A, %B, %C [other-attributes] :
           memref<?x?xf32, stride_specification>,
           memref<?x?xf32, stride_specification>,
           memref<?x?xf32, stride_specification>
       ```
 
     This may lower to either:
       ```mlir
-        call @linalg_matmul(%A, %B, %C) :
+        call @linalg_matmul(%offset_m, %offset_n, %offset_k, %A, %B, %C) :
           (memref<?x?xf32, stride_specification>,
            memref<?x?xf32, stride_specification>,
            memref<?x?xf32, stride_specification>)
           -> ()
       ```
 
     or IR resembling:
     ```mlir
     loop.for %m = %c0 to %M step %c1 {
       loop.for %n = %c0 to %N step %c1 {
         loop.for %k = %c0 to %K step %c1 {
           %a = linalg.load %A[%m, %k] : memref<?x?xf32, stride_specification>
           %b = linalg.load %B[%k, %n] : memref<?x?xf32, stride_specification>
           %c = linalg.load %C[%m, %n] : memref<?x?xf32, stride_specification>
           %d = call @func_of_elements_and_indices(%m, %n, %k, %a, %b, %c)
                  : (index, index, index, f32, f32, f32) -> (f32)
           linalg.store %d, %C[%m, %n] : memref<?x?x?xf32, stride_specification>
         }
       }
     }
     ```
+
+    To allow progressive lowering from the value world (a.k.a tensor values) to
+    the buffer world (a.k.a memref values), a `linalg.indexed_generic` op
+    accepts mixing input and output ranked tensor values with input and output
+    memrefs.
+
+    ```mlir
+      %1 = linalg.indexed_generic #trait_attribute %A, %B, %C {other-attributes}
+      : tensor<?x?xf32>,
+        memref<?x?xf32, stride_specification>,
+        tensor<?x?xf32>
+        -> (tensor<?x?xf32>)
+    ```
+
+    In this case, the number of return values must match the number of output
+    tensor arguments. The semantics is that the `linalg.indexed_generic` op
+    produces (i.e. allocates and fills) its return values.
+    Tensor values must be legalized by a buffer allocation pass before most
+    transformations can be applied. In particular, transformations that create
+    control flow around linalg.generic operations are not expected to mix with
+    tensors because SSA values do not escape naturally. Still, transformations
+    and rewrites that take advantage of tensor SSA values are expected to be
+    useful and will be added in the near future.
   }];
   let verifier = [{ return ::verify(*this); }];
 }
 
 #endif // LINALG_STRUCTURED_OPS

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

 //===- LinalgTraits.h - Linalg Traits ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_LINALG_LINALGTRAITS_H_
 #define MLIR_DIALECT_LINALG_LINALGTRAITS_H_
 
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 namespace OpTrait {
 namespace linalg {
 
 /// This class provides the API for ops that are known to have a specified
-/// number of inputs, all passed as operands. This is used as a trait like this:
+/// number of inputs, all passed as operands. Use as a trait as follows:
 ///
 ///   class DotOp : public Op<DotOp, OpTrait::NInputs<2>::Impl> {
 ///
 template <unsigned N> class NInputs {
 public:
   template <typename ConcreteType>
   class Impl : public OpTrait::TraitBase<ConcreteType, NInputs<N>::Impl> {
   public:
     static unsigned getNumInputs() { return N; }
   };
 };
 
 /// This class provides the API for ops that are known to have a specified
-/// number of inputs, all passed as operands. This is used as a trait like this:
+/// number of outputs, all passed as operands. Use as a trait as follows:
 ///
 ///   class DotOp : public Op<DotOp, OpTrait::NOutputs<2>::Impl> {
 ///
 template <unsigned N> class NOutputs {
 public:
   template <typename ConcreteType>
   class Impl : public OpTrait::TraitBase<ConcreteType, NOutputs<N>::Impl> {
   public:
     static unsigned getNumOutputs() { return N; }
   };
 };
 
-/// This class provides the API for ops that are known to operate on views. This
-/// trait must be used in conjunction with an op definition or a trait that
-/// provides the methods `getNumInputs` and `getNumOutputs`. This is used as a
-/// trait like this:
+/// This class provides the API for structured ops that are known to operate on
+/// buffers or tensors. This trait must be used in conjunction with an op
+/// definition or a trait that provides the methods `getNumInputs` and
+/// `getNumOutputs`. Use as a trait as follows:
 ///
-///   class DotOp : public Op<DotOp, OpTrait::ViewTrait> {
+///   class DotOp : public Op<DotOp, OpTrait::StructuredOpTraits> {
 ///
 template <typename ConcreteType>
-class ViewTraits : public OpTrait::TraitBase<ConcreteType, ViewTraits> {
+class StructuredOpTraits
+    : public OpTrait::TraitBase<ConcreteType, StructuredOpTraits> {
 private:
-  /// Return the number of input views. For internal use only.
+  /// Return the number of inputs. For internal use only.
   unsigned nInputs() {
     return cast<ConcreteType>(this->getOperation()).getNumInputs();
   }
-  /// Return the number of input views. For internal use only.
+  /// Return the number of outputs. For internal use only.
   unsigned nOutputs() {
     return cast<ConcreteType>(this->getOperation()).getNumOutputs();
   }
 
 public:
-  /// Return the `i`-th input view.
+  /// Return the `i`-th input value.
   Value getInput(unsigned i) {
     assert(i < nInputs());
     return this->getOperation()->getOperand(i);
   }
-  /// Return the index of `view` in the list of input views if found, llvm::None
+  /// Return the index of `value` in the list of inputs if found, llvm::None
   /// otherwise.
-  Optional<unsigned> getIndexOfInput(Value view) {
-    auto it = llvm::find(getInputs(), view);
+  Optional<unsigned> getIndexOfInput(Value value) {
+    auto it = llvm::find(getInputs(), value);
     if (it != getInputs().end())
       return it - getInputs().begin();
     return llvm::None;
   }
-  /// Return the `i`-th input view type.
-  MemRefType getInputViewType(unsigned i) {
-    return getInput(i)->getType().template cast<MemRefType>();
+  /// Return the `i`-th input buffer type.
+  ShapedType getInputShapedType(unsigned i) {
+    return getInput(i)->getType().template cast<ShapedType>();
   }
-  /// Return the range over input views.
+  /// Return the range over inputs.
   Operation::operand_range getInputs() {
     auto range = this->getOperation()->getOperands();
     return {range.begin(), range.begin() + nInputs()};
   }
-  /// Return the `i`-th output view.
+  /// Return the `i`-th output.
   Value getOutput(unsigned i) {
     return this->getOperation()->getOperand(nInputs() + i);
   }
-  /// Return the index of `view` in the list of output views if found,
+  /// Return the index of `value` in the list of output values if found,
   /// llvm::None otherwise.
-  Optional<unsigned> getIndexOfOutput(Value view) {
-    auto it = llvm::find(getOutputs(), view);
+  Optional<unsigned> getIndexOfOutput(Value value) {
+    auto it = llvm::find(getOutputs(), value);
     if (it != getOutputs().end())
       return it - getOutputs().begin();
     return llvm::None;
   }
-  /// Return the `i`-th output view type.
-  MemRefType getOutputViewType(unsigned i) {
-    return getOutput(i)->getType().template cast<MemRefType>();
+  /// Return the `i`-th output buffer type.
+  ShapedType getOutputShapedType(unsigned i) {
+    return getOutput(i)->getType().template cast<ShapedType>();
+  }
+  /// Query whether the op has only MemRef input and outputs.
+  bool hasBufferSemantics() {
+    return this->getOperation()->getNumResults() == 0 &&
+           llvm::all_of(getInputsAndOutputs(),
+                        [](Value v) { return v.getType().isa<MemRefType>(); });
+  }
+  /// Query the subset of input operands that are of ranked tensor type.
+  SmallVector<RankedTensorType, 4> getInputTensorTypes() {
+    SmallVector<RankedTensorType, 4> res;
+    for (auto type : getInputs().getTypes())
+      if (auto t = type.template dyn_cast<RankedTensorType>())
+        res.push_back(t);
+    return res;
+  }
+  /// Query the subset of output operands that are of ranked tensor type.
+  SmallVector<RankedTensorType, 4> getOutputTensorTypes() {
+    SmallVector<RankedTensorType, 4> res;
+    for (auto type : getOutputs().getTypes())
+      if (auto t = type.template dyn_cast<RankedTensorType>())
+        res.push_back(t);
+    return res;
   }
-  /// Return the range over output views.
+  /// Return the range over outputs.
   Operation::operand_range getOutputs() {
     auto range = this->getOperation()->getOperands();
     return {range.begin() + nInputs(),
             range.begin() + getNumInputsAndOutputs()};
   }
-  /// Return the number of input and output views.
+  /// Return the number of inputs and outputs.
   unsigned getNumInputsAndOutputs() { return nInputs() + nOutputs(); }
-  /// Return the `i`-th view type.
-  MemRefType getViewType(unsigned i) {
-    return (i < nInputs()) ? getInputViewType(i)
-                           : getOutputViewType(i - nInputs());
+  /// Return the `i`-th buffer type.
+  ShapedType getShapedType(unsigned i) {
+    return (i < nInputs()) ? getInputShapedType(i)
+                           : getOutputShapedType(i - nInputs());
   }
-  /// Return the range over input and output views.
+  /// Return the range over inputs and outputs.
   Operation::operand_range getInputsAndOutputs() {
     auto range = this->getOperation()->getOperands();
     return {range.begin(), range.begin() + getNumInputsAndOutputs()};
   }
   unsigned getNumParallelLoops() {
     return getNumIterators(
         getParallelIteratorTypeName(),
         cast<ConcreteType>(this->getOperation()).iterator_types());
   }
   unsigned getNumReductionLoops() {
     return getNumIterators(
         getReductionIteratorTypeName(),
         cast<ConcreteType>(this->getOperation()).iterator_types());
   }
   unsigned getNumWindowLoops() {
     return getNumIterators(
         getWindowIteratorTypeName(),
         cast<ConcreteType>(this->getOperation()).iterator_types());
   }
   unsigned getNumLoops() {
     return getNumIterators(
         cast<ConcreteType>(this->getOperation()).iterator_types());
   }
   static LogicalResult verifyTrait(Operation *op) {
-    auto nViews = cast<ConcreteType>(op).getNumInputsAndOutputs();
-    if (failed(OpTrait::impl::verifyAtLeastNOperands(op, nViews)))
+    auto nOperands = cast<ConcreteType>(op).getNumInputsAndOutputs();
+    if (failed(OpTrait::impl::verifyAtLeastNOperands(op, nOperands)))
       return failure();
     return success();
   }
 };
 
 } // namespace linalg
 } // namespace OpTrait
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LINALG_LINALGTRAITS_H_

mlir/include/mlir/Dialect/Linalg/Transforms/LinalgTransformPatterns.td

 #ifndef LINALG_TRANSFORMS
 #define LINALG_TRANSFORMS
 
 include "mlir/Dialect/Linalg/IR/LinalgOps.td"
 include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.td"
 include "mlir/Dialect/AffineOps/AffineOps.td"
 
 def HasNoLinalgTransformMarker : CPred<[{
-  !$0.getAttrOfType<StringAttr>(LinalgTransforms::kLinalgTransformMarker)
+  !op.getAttrOfType<StringAttr>(LinalgTransforms::kLinalgTransformMarker)
 }]>;
 
 class HasLinalgTransformMarker<string str> : CPred<[{
-  $0.getAttrOfType<StringAttr>(
+  op.getAttrOfType<StringAttr>(
     LinalgTransforms::kLinalgTransformMarker) &&
-  $0.getAttrOfType<StringAttr>(
+  op.getAttrOfType<StringAttr>(
     LinalgTransforms::kLinalgTransformMarker).getValue() == "}] # str # [{"}]>;
 
 class IsProducedByOpOfType<string str> :
-  CPred<"isProducedByOpOfType<" # str # ">($0, $1)">;
+  CPred<"isProducedByOpOfType<" # str # ">(op, $0)">;
 
 class AffineMapDomainHasDim<int n> : CPred<[{
-  $0.getAttrOfType<ArrayAttr>(getIndexingMapsAttrName()).getValue()[0].
+  op.getAttrOfType<ArrayAttr>(getIndexingMapsAttrName()).getValue()[0].
   cast<AffineMapAttr>().getValue().getNumDims() ==}] # n # [{}]>;
 
 class HasOperandsOfType<string type>: CPred<[{
-    llvm::any_of($0.getOperands(),
+    llvm::any_of(op.getOperands(),
         [](Value v) {
           return dyn_cast_or_null<}] # type # [{>(v->getDefiningOp());
         })
 }]>;
 
 //===----------------------------------------------------------------------===//
 // Linalg fusion patterns.
 //===----------------------------------------------------------------------===//
 //
 // In the future, tile sizes should be derived from op properties + machine
 // description but we do not need to wait on this to start having useful
 // patterns.
 class TileAndFuseLinalgOp<
     list<int> sizes, list<int> operandIndices, string value> : NativeCodeCall<
-  "if (failed(tileAndFuseLinalgOpAndSetMarker($_builder, $0, {" #
+  "if (failed(tileAndFuseLinalgOpAndSetMarker($_builder, op, {" #
   StrJoinInt<sizes>.result # "}, {" # StrJoinInt<operandIndices>.result # "}," #
       " \"" # value # "\")))" #
   "  return matchFailure();">;
 
 //===----------------------------------------------------------------------===//
 // Linalg tiling patterns.
 //===----------------------------------------------------------------------===//
 //
 // In the future, tile sizes should be derived from op properties + machine
 // description but we do not need to wait on this to start having useful
 // patterns.
 // `permutation` is an optional parameter to specify the ordering of the
 // tiled loops. If provided, it must be a list of integers with the same number
 // of elements as `sizes`.
 class TileLinalgOp<list<int> sizes, string value, list<int> permutation=[]> :
   NativeCodeCall<
-    "if (failed(tileLinalgOpAndSetMarker($_builder, $0, {" #
+    "if (failed(tileLinalgOpAndSetMarker($_builder, op, {" #
     StrJoinInt<sizes>.result # "}, \"" # value # "\", {" #
     StrJoinInt<permutation>.result # "})))" #
     "  return matchFailure();">;
 
 //===----------------------------------------------------------------------===//
 // Linalg to loop patterns.
 //===----------------------------------------------------------------------===//
 class LinalgOpToLoops<string OpType> : NativeCodeCall<
-  "if (failed(linalgOpToLoops<" # OpType # ">($_builder, $0))) " #
+  "if (failed(linalgOpToLoops<" # OpType # ">($_builder, op))) " #
   "  return matchFailure();">;
 
 class LinalgOpToAffineLoops<string OpType> : NativeCodeCall<
-  "if (failed(linalgOpToAffineLoops<" # OpType # ">($_builder, $0))) " #
+  "if (failed(linalgOpToAffineLoops<" # OpType # ">($_builder, op))) " #
   "  return matchFailure();">;
 
 //===----------------------------------------------------------------------===//
-// Linalg to vector contraction patterns.
+// Linalg to vector patterns precondition and DRR.
 //===----------------------------------------------------------------------===//
-class LinalgOpToVectorContraction<string OpType> : NativeCodeCall<
-  "if (failed(vectorizeGenericOp($_builder, $0))) " #
-  "  return matchFailure();">;
+def PreconditionVectorizeGenericLinalgOp : CPred<
+  "succeeded(vectorizeGenericLinalgOpPrecondition(op))">;
+def VectorizeGenericLinalgOp : NativeCodeCall<
+  "vectorizeGenericLinalgOp($_builder, op)">;
 
 //===----------------------------------------------------------------------===//
-// Linalg generic permutation patterns.
+// Linalg generic permutation patterns precondition and DRR.
 //===----------------------------------------------------------------------===//
+class PreconditionPermuteGenericLinalgOp<list<int> permutation> : CPred<
+  "succeeded(permuteGenericLinalgOpPrecondition(op, {" #
+  StrJoinInt<permutation>.result # "}))">;
 class PermuteGenericLinalgOp<list<int> permutation, string value> :
   NativeCodeCall<
-    "if (failed(permuteGenericLinalgOp($_builder, $0, {" #
-    StrJoinInt<permutation>.result # "}, \"" # value # "\"))) " #
-    "  return matchFailure();">;
+    "permuteGenericLinalgOp($_builder, op, {" # StrJoinInt<permutation>.result #
+    "}, \"" # value # "\")">;
 
 //===----------------------------------------------------------------------===//
-// Linalg promote subview operands.
+// Linalg promote subview operands precondition and DRR.
 //===----------------------------------------------------------------------===//
-class LinalgOpPromoteSubviews<string OpType> : NativeCodeCall<
-  "if (failed(linalgOpPromoteSubviews($_builder, $0))) " #
-  "  return matchFailure();">;
+def PreconditionPromoteSubviewsLinalgOp : CPred<
+  "succeeded(promoteSubviewsLinalgOpPrecondition(op))">;
+def PromoteSubviewsLinalgOp : NativeCodeCall<
+  "promoteSubviewsLinalgOp($_builder, op)">;
 #endif // LINALG_TRANSFORMS

mlir/include/mlir/Dialect/Linalg/Transforms/LinalgTransforms.h

 //===- LinalgTransforms.h - Linalg transformations as patterns --*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DIALECT_LINALG_TRANSFORMS_LINALGTRANSFORMS_H_
 #define DIALECT_LINALG_TRANSFORMS_LINALGTRANSFORMS_H_
 
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 
 #include "llvm/ADT/STLExtras.h"
 

 template <typename ConcreteOp>
 LogicalResult linalgOpToLoops(PatternRewriter &rewriter, Operation *op);
 
 /// Emits a loop nest of `affine.for` with the proper body for `op`.
 template <typename ConcreteOp>
 LogicalResult linalgOpToAffineLoops(PatternRewriter &rewriter, Operation *op);
 
 /// Rewrite a linalg.generic into a suitable vector.contraction op.
-LogicalResult vectorizeGenericOp(PatternRewriter &rewriter, Operation *op);
+LogicalResult vectorizeGenericLinalgOpPrecondition(Operation *op);
+SmallVector<Value, 0> vectorizeGenericLinalgOp(PatternRewriter &rewriter,
+                                               Operation *op);
 
 /// Emits a `generic` or `indexed_generic` operation with the `indexing_maps`
 /// and `iterator_types` permutated according to `permutation`.
-LogicalResult permuteGenericLinalgOp(PatternRewriter &rewriter, Operation *op,
+LogicalResult
+permuteGenericLinalgOpPrecondition(Operation *op,
+                                   ArrayRef<unsigned> permutation);
+SmallVector<Value, 0> permuteGenericLinalgOp(PatternRewriter &rewriter,
+                                             Operation *op,
                                              ArrayRef<unsigned> permutation,
                                              StringRef linalgMarker);
 
-/// Promote std.subviews feeding linalg operations
-LogicalResult linalgOpPromoteSubviews(PatternRewriter &rewriter, Operation *op);
+/// Promote std.subviews feeding linalg operations.
+LogicalResult promoteSubviewsLinalgOpPrecondition(Operation *op);
+SmallVector<Value, 0> promoteSubviewsLinalgOp(PatternRewriter &rewriter,
+                                              Operation *op);
 
 } // namespace linalg
 } // namespace mlir
 
 #endif // DIALECT_LINALG_TRANSFORMS_LINALGTRANSFORMS_H_

mlir/include/mlir/Dialect/VectorOps/VectorTransforms.h

 //===- VectorTransforms.h - Vector transformations as patterns --*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DIALECT_VECTOROPS_VECTORTRANSFORMS_H_
 #define DIALECT_VECTOROPS_VECTORTRANSFORMS_H_
 
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 class MLIRContext;
 class OwningRewritePatternList;
 
 /// Collect a set of patterns to convert from the Vector dialect to itself.
 /// Should be merged with populateVectorToAffineLoopsConversionPatterns.
 void populateVectorToVectorConversionPatterns(

 //                 \            |            /
 //      <-------------------- join ------------------------->
 //
 // Other local patterns then kick in iteratively (including DCE) and compose
 // until all the fakeFork and fakeJoin ops are removed.
 //
 // This will be extended in the future to support more advanced use cases than
 // simple pointwise ops.
-Value unrollSingleResultOpMatchingType(PatternRewriter &builder, Operation *op,
-                                       ArrayRef<int64_t> targetShape);
+SmallVector<Value, 1>
+unrollSingleResultOpMatchingType(PatternRewriter &builder, Operation *op,
 
 } // namespace vector
 } // namespace mlir
 
 #endif // DIALECT_VECTOROPS_VECTORTRANSFORMS_H_

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 //===- LinalgToLLVM.cpp - conversion from Linalg to LLVM dialect ----------===//
 //
 // 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/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
public:
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     edsc::ScopedContext context(rewriter, op->getLoc());
     SliceOpOperandAdaptor adaptor(operands);
     BaseViewConversionHelper baseDesc(adaptor.view());
 
     auto sliceOp = cast<SliceOp>(op);
     auto memRefType = sliceOp.getBaseViewType();
     auto int64Ty = lowering.convertType(rewriter.getIntegerType(64))
                        .cast<LLVM::LLVMType>();
 
-    BaseViewConversionHelper desc(lowering.convertType(sliceOp.getViewType()));
+    BaseViewConversionHelper desc(
+        lowering.convertType(sliceOp.getShapedType()));
 
     // TODO(ntv): extract sizes and emit asserts.
     SmallVector<Value, 4> strides(memRefType.getRank());
     for (int i = 0, e = memRefType.getRank(); i < e; ++i)
       strides[i] = baseDesc.stride(i);
 
     auto pos = [&rewriter](ArrayRef<int64_t> values) {
       return rewriter.getI64ArrayAttr(values);
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     // Insert the base and aligned pointers.
     desc.setAllocatedPtr(baseDesc.allocatedPtr());
     desc.setAlignedPtr(baseDesc.alignedPtr());
 
     // Insert base offset.
     desc.setOffset(baseOffset);
 
     // Corner case, no sizes or strides: early return the descriptor.
-    if (sliceOp.getViewType().getRank() == 0)
+    if (sliceOp.getShapedType().getRank() == 0)
       return rewriter.replaceOp(op, {desc}), matchSuccess();
 
     Value zero =
         constant(int64Ty, rewriter.getIntegerAttr(rewriter.getIndexType(), 0));
     // Compute and insert view sizes (max - min along the range) and strides.
     // Skip the non-range operands as they will be projected away from the view.
     int numNewDims = 0;
     for (auto en : llvm::enumerate(sliceOp.indexings())) {
       Value indexing = en.value();
       if (indexing->getType().isa<RangeType>()) {
         int rank = en.index();
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     TransposeOpOperandAdaptor adaptor(operands);
     BaseViewConversionHelper baseDesc(adaptor.view());
 
     auto transposeOp = cast<TransposeOp>(op);
     // No permutation, early exit.
     if (transposeOp.permutation().isIdentity())
       return rewriter.replaceOp(op, {baseDesc}), matchSuccess();
 
     BaseViewConversionHelper desc(
-        lowering.convertType(transposeOp.getViewType()));
+        lowering.convertType(transposeOp.getShapedType()));
 
     // Copy the base and aligned pointers from the old descriptor to the new
     // one.
     desc.setAllocatedPtr(baseDesc.allocatedPtr());
     desc.setAlignedPtr(baseDesc.alignedPtr());
 
     // Copy the offset pointer from the old descriptor to the new one.
     desc.setOffset(baseDesc.offset());

mlir/lib/Dialect/Linalg/EDSC/Builders.cpp

 //===- Builders.cpp - MLIR Declarative Linalg Builders --------------------===//
 //
 // 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/Dialect/Linalg/EDSC/Builders.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/EDSC/Builders.h"
 #include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Support/Functional.h"
 
for (auto expr : sidx.getExprs()) {
       expr.walk([&pos](AffineExpr e) {
         if (auto d = e.dyn_cast<AffineDimExpr>())
           pos = std::max(pos, d.getPosition());
       });
     }
   }
 }
 
-Operation *mlir::edsc::makeLinalgGenericOp(
+Operation *mlir::edsc::makeGenericLinalgOp(
     ArrayRef<IterType> iteratorTypes, ArrayRef<StructuredIndexed> inputs,
     ArrayRef<StructuredIndexed> outputs,
     function_ref<void(ArrayRef<BlockArgument>)> regionBuilder,
     ArrayRef<Value> otherValues, ArrayRef<Attribute> otherAttributes) {
   auto &builder = edsc::ScopedContext::getBuilder();
   auto *ctx = builder.getContext();
   unsigned nInputs = inputs.size();
   unsigned nOutputs = outputs.size();
Operation *mlir::edsc::makeGenericLinalgOp(
   values.append(outputs.begin(), outputs.end());
 
   auto iteratorStrTypes = functional::map(toString, iteratorTypes);
   // clang-format off
   auto *op =
       edsc::ScopedContext::getBuilder()
           .create<linalg::GenericOp>(
               edsc::ScopedContext::getLocation(),
+              ArrayRef<Type>{}, // TODO(ntv): support tensors
               values,
               IntegerAttr::get(IntegerType::get(64, ctx), nInputs),
               IntegerAttr::get(IntegerType::get(64, ctx), nOutputs),
               builder.getAffineMapArrayAttr(maps),
               builder.getStrArrayAttr(iteratorStrTypes),
               StringAttr() /*doc*/,
               FlatSymbolRefAttr() /*fun*/,
               StringAttr() /*library_call*/
Operation *mlir::edsc::ops::linalg_pointwise(UnaryPointwiseOpBuilder unaryOp,
                                              StructuredIndexed O) {
   SmallVector<edsc::IterType, 4> iterTypes(O.getExprs().size(),
                                            edsc::IterType::Parallel);
   auto fun = [&unaryOp](ArrayRef<BlockArgument> args) {
     assert(args.size() == 2 && "expected 2 block arguments");
     ValueHandle a(args[0]);
     linalg_yield(unaryOp(a));
   };
-  return makeLinalgGenericOp(iterTypes, {I}, {O}, fun);
+  return makeGenericLinalgOp(iterTypes, {I}, {O}, fun);
 }
 
 Operation *mlir::edsc::ops::linalg_pointwise_tanh(StructuredIndexed I,
                                                   StructuredIndexed O) {
   ;
   using edsc::intrinsics::tanh;
   UnaryPointwiseOpBuilder unOp([](ValueHandle a) -> Value { return tanh(a); });
   return linalg_pointwise(unOp, I, O);
 }
 
 /// Binary pointwise operation (with broadcast) entry point.
 Operation *mlir::edsc::ops::linalg_pointwise(BinaryPointwiseOpBuilder binaryOp,
                                              StructuredIndexed I1,
                                              StructuredIndexed I2,
                                              StructuredIndexed O) {
   SmallVector<edsc::IterType, 4> iterTypes(O.getExprs().size(),
                                            edsc::IterType::Parallel);
   auto fun = [&binaryOp](ArrayRef<BlockArgument> args) {
     assert(args.size() == 3 && "expected 3 block arguments");
     ValueHandle a(args[0]), b(args[1]);
     linalg_yield(binaryOp(a, b));
   };
-  return makeLinalgGenericOp(iterTypes, {I1, I2}, {O}, fun);
+  return makeGenericLinalgOp(iterTypes, {I1, I2}, {O}, fun);
 }
 
 Operation *mlir::edsc::ops::linalg_pointwise_add(StructuredIndexed I1,
                                                  StructuredIndexed I2,
                                                  StructuredIndexed O) {
   using edsc::op::operator+;
   BinaryPointwiseOpBuilder binOp(
       [](ValueHandle a, ValueHandle b) -> Value { return a + b; });

 }
 
 Operation *mlir::edsc::ops::linalg_matmul(ValueHandle vA, ValueHandle vB,
                                           ValueHandle vC) {
   // clang-format off
   AffineExpr m, n, k;
   bindDims(ScopedContext::getContext(), m, n, k);
   StructuredIndexed A(vA), B(vB), C(vC);
-  return makeLinalgGenericOp(
+  return makeGenericLinalgOp(
     {IterType::Parallel, IterType::Parallel, IterType::Reduction},
     {A({m, k}), B({k, n})},
     {C({m, n})},
     macRegionBuilder);
   // clang-format on
 }
 
 Operation *mlir::edsc::ops::linalg_conv_nhwc(ValueHandle vI, ValueHandle vW,
Operation *mlir::edsc::ops::linalg_conv_nhwc(ValueHandle vI, ValueHandle vW,
   auto s = strides;
   auto d = dilations;
 
   AffineExpr b, f, h, w, kh, kw, c;
   bindDims(ctx, b, f, h, w, kh, kw, c);
   unsigned numDims = c.cast<AffineDimExpr>().getPosition() + 1;
   StructuredIndexed I(vI), W(vW), O(vO);
   // clang-format off
-  return makeLinalgGenericOp(
+  return makeGenericLinalgOp(
     {par, par, par, par, red, red, red}, {
       I({b,
          // Roundtrip to flattened form to serve as canonicalization and ensure
          // consistent ordering of subexpressions.
          simplifyAffineExpr(s[0] * h + d[0] * kh, numDims, 0),
          simplifyAffineExpr(s[1] * w + d[1] * kw, numDims, 0),
          c}),
       W({kh, kw, c, f})}, {
Operation *mlir::edsc::ops::linalg_dilated_conv_nhwc(
   auto s = strides;
   auto d = dilations;
 
   // clang-format off
   AffineExpr b, dm, c, h, w, kh, kw;
   bindDims(ctx, b, dm, c, h, w, kh, kw);
   unsigned numDims = kw.cast<AffineDimExpr>().getPosition() + 1;
   StructuredIndexed I(vI), W(vW), O(vO);
-  return makeLinalgGenericOp(
+  return makeGenericLinalgOp(
     {par, par, par, par, par, red, red}, {
       I({b,
          // Roundtrip to flattened form to serve as canonicalization and ensure
          // consistent ordering of subexpressions.
          simplifyAffineExpr(s[0] * h + d[0] * kh, numDims, 0),
          simplifyAffineExpr(s[1] * w + d[1] * kw, numDims, 0),
          c}),
       W({kh, kw, c, dm})}, {
       O({b, h, w, simplifyAffineExpr(c * depth_multiplier + dm, numDims, 0)})},
     macRegionBuilder);
   // clang-format on
 }

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 //===- LinalgOps.cpp - Implementation of the linalg operations ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a the Linalg operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/EDSC/Helpers.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
if (linalgTraitAttrsSet.count(attr.first.strref()) > 0)
       attrs.push_back(attr);
 
   auto dictAttr = DictionaryAttr::get(attrs, op.getContext());
   p << op.getOperationName() << " " << dictAttr << " " << op.getOperands();
   if (!op.region().empty())
     p.printRegion(op.region());
   p.printOptionalAttrDict(op.getAttrs(), attrNames);
   p << ": " << op.getOperandTypes();
+
+  auto outputTensorTypes = op.getResultTypes();
+  if (!outputTensorTypes.empty())
+    p << " -> " << outputTensorTypes;
 }
 
 static void print(OpAsmPrinter &p, GenericOp op) { printGenericOp(p, op); }
 
 static void print(OpAsmPrinter &p, IndexedGenericOp op) {
   printGenericOp(p, op);
 }
 
 static ParseResult parseGenericOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 8> operandsInfo, regionOperandsInfo;
   DictionaryAttr dictAttr;
static ParseResult parseGenericOp(OpAsmParser &parser, OperationState &result) {
   // Optional attributes may be added.
   // Either Optional getFunAttrName() attribute or region must be specified.
   if (!dictAttr.get(getFunAttrName()) &&
       parser.parseOptionalRegion(region, regionOperandsInfo, regionTypes))
     return failure();
   if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonTypeList(operandTypes))
     return failure();
+  // Generic ops may specify that a subset of its outputs are tensors. Such
+  // outputs are specified in the result type.
+  SmallVector<Type, 8> tensorResultTypes;
+  if (parser.parseOptionalArrowTypeList(tensorResultTypes))
+    return failure();
+  if (!tensorResultTypes.empty())
+    result.addTypes(tensorResultTypes);
   return parser.resolveOperands(operandsInfo, operandTypes,
                                 parser.getCurrentLocation(), result.operands);
 }
 
 template <typename GenericOpType>
 LogicalResult verifyBlockArgs(GenericOpType op, Block &block);
 
 template <> LogicalResult verifyBlockArgs(GenericOp op, Block &block) {
   auto nViews = op.getNumInputsAndOutputs();
   auto nInputViews = op.getNumInputs();
   if (block.getNumArguments() != nViews)
-    return op.emitError(
+    return op.emitOpError(
         "op expected number of block arguments to match number of views");
 
   for (unsigned i = 0; i < nViews; ++i) {
-    auto viewType = op.getViewType(i);
+    auto viewType = op.getShapedType(i);
     if (viewType.getElementType() != block.getArgument(i)->getType())
-      return op.emitError("op expected block argument ")
+      return op.emitOpError("expected block argument ")
              << i << " of the same type as elemental type of "
              << ((i < nInputViews) ? "input " : "output ")
              << "view: " << viewType;
   }
   return success();
 }
 
 template <> LogicalResult verifyBlockArgs(IndexedGenericOp op, Block &block) {
   auto nInputViews = op.getNumInputs();
   auto nLoops = op.getNumLoops();
   auto nViews = op.getNumInputsAndOutputs();
   if (block.getNumArguments() != nViews + nLoops)
-    return op.emitError(
+    return op.emitOpError(
         "op expected number of block arguments to match number of views + "
         "number of loops");
 
   for (unsigned i = 0; i < nLoops; ++i) {
     if (!block.getArgument(i)->getType().isIndex())
-      return op.emitError("op expected block argument ")
+      return op.emitOpError("expected block argument ")
              << i << " to be of IndexType";
   }
 
   for (unsigned i = 0; i < nViews; ++i) {
     unsigned memrefArgIndex = i + nLoops;
-    auto viewType = op.getViewType(i);
+    auto viewType = op.getShapedType(i);
     if (viewType.getElementType() !=
         block.getArgument(memrefArgIndex)->getType())
-      return op.emitError("op expected block argument ")
+      return op.emitOpError("expected block argument ")
              << memrefArgIndex << " of the same type as elemental type of "
              << ((i < nInputViews) ? "input " : "output ")
              << "view: " << viewType;
   }
   return success();
 }
 
 template <typename GenericOpType>
 LogicalResult verifyFuncArgs(GenericOpType op, FunctionType funType);
 
 template <> LogicalResult verifyFuncArgs(GenericOp op, FunctionType funType) {
   auto nViews = op.getNumInputsAndOutputs();
   auto nInputViews = op.getNumInputs();
   if (funType.getNumInputs() != nViews)
-    return op.emitError("op expected fun arguments to match number of views");
+    return op.emitOpError("expected fun arguments to match number of views");
   if (funType.getNumResults() != op.getNumOutputs())
-    return op.emitError(
+    return op.emitOpError(
         "op expected fun results to match number of output views");
 
   for (auto en : llvm::enumerate(op.indexing_maps())) {
     auto idx = en.index();
-    auto view = (idx < nInputViews) ? op.getInputViewType(idx)
-                                    : op.getOutputViewType(idx - nInputViews);
+    auto view = (idx < nInputViews) ? op.getInputShapedType(idx)
+                                    : op.getOutputShapedType(idx - nInputViews);
     if (funType.getInput(idx) != view.getElementType())
-      return op.emitError("op expected fun argument ")
+      return op.emitOpError("expected fun argument ")
              << idx << " of the same type as elemental type "
              << view.getElementType() << " of view " << idx;
 
     if (idx >= nInputViews) {
       auto resultIdx = idx - nInputViews;
       if (funType.getResult(resultIdx) != view.getElementType())
-        return op.emitError("op expected fun result ")
+        return op.emitOpError("expected fun result ")
                << resultIdx << " of the same type as elemental type "
                << view.getElementType() << " of view " << idx;
     }
   }
   return success();
 }
 
 template <>
 LogicalResult verifyFuncArgs(IndexedGenericOp op, FunctionType funType) {
   auto nLoops = op.getNumLoops();
   auto nInputViews = op.getNumInputs();
   auto nOutputs = op.getNumOutputs();
   auto nViews = op.getNumInputsAndOutputs();
   if (funType.getNumInputs() != nViews + nLoops)
-    return op.emitError(
+    return op.emitOpError(
         "op expected fun arguments to match number of views + number of loops");
   if (funType.getNumResults() != nOutputs)
-    return op.emitError(
+    return op.emitOpError(
         "op expected fun results to match number of output views");
   for (unsigned i = 0; i < nLoops; ++i) {
     if (!funType.getInput(i).isIndex())
-      return op.emitError("op expected fun argument ")
+      return op.emitOpError("expected fun argument ")
              << i << " to be of IndexType";
   }
   for (auto en : llvm::enumerate(op.indexing_maps())) {
     auto idx = en.index();
     auto funIdx = nLoops + idx;
-    auto view = (idx < nInputViews) ? op.getInputViewType(idx)
-                                    : op.getOutputViewType(idx - nInputViews);
+    auto view = (idx < nInputViews) ? op.getInputShapedType(idx)
+                                    : op.getOutputShapedType(idx - nInputViews);
     if (funType.getInput(funIdx) != view.getElementType())
-      return op.emitError("op expected fun argument ")
+      return op.emitOpError("expected fun argument ")
              << funIdx << " of the same type as elemental type "
              << view.getElementType() << " of view " << idx;
 
     if (idx >= nInputViews) {
       auto resultIdx = idx - nInputViews;
       if (funType.getResult(resultIdx) != view.getElementType())
-        return op.emitError("op expected fun result ")
+        return op.emitOpError("expected fun result ")
                << resultIdx << " of the same type as elemental type "
                << view.getElementType() << " of view " << idx;
     }
   }
   return success();
 }
 
 template <typename GenericOpType>
 LogicalResult verifyGenericOp(GenericOpType op) {
   auto nInputViews = op.getNumInputs();
   auto nLoops = op.getNumLoops();
   auto nViews = op.getNumInputsAndOutputs();
   if (nViews != llvm::size(op.views()))
-    return op.emitError("op expected exactly ") << nViews << " view operands";
+    return op.emitOpError("expected exactly ") << nViews << " view operands";
 
   auto &region = op.region();
   auto funOp = op.getFunction();
   auto funType = funOp ? funOp.getType() : FunctionType();
   if (!region.empty()) {
     if (region.getBlocks().size() != 1)
-      return op.emitError("op expected region with 1 block");
+      return op.emitOpError("expected region with 1 block");
     if (failed(verifyBlockArgs(op, region.getBlocks().front())))
       return failure();
   } else {
     if (!funOp || !funOp.getType())
-      return op.emitError(
+      return op.emitOpError(
           "op expected fun attribute to refer to a defined symbol");
     if (failed(verifyFuncArgs(op, funType)))
       return failure();
   }
 
   SmallVector<AffineMap, 4> indexingMaps;
   indexingMaps.reserve(op.indexing_maps().size());
   for (auto en : llvm::enumerate(op.indexing_maps())) {
     auto idx = en.index();
     auto m = en.value().template cast<AffineMapAttr>().getValue();
     indexingMaps.push_back(m); // Save reference to map for further checks.
-    auto view = (idx < nInputViews) ? op.getInputViewType(idx)
-                                    : op.getOutputViewType(idx - nInputViews);
+    auto view = (idx < nInputViews) ? op.getInputShapedType(idx)
+                                    : op.getOutputShapedType(idx - nInputViews);
 
     if (m.getNumSymbols() != 0)
-      return op.emitError("op expected indexing_map #")
+      return op.emitOpError("expected indexing_map #")
              << idx << " to have no symbols";
 
     if (m.getNumDims() != nLoops)
-      return op.emitError("op expected indexing_map #")
+      return op.emitOpError("expected indexing_map #")
              << idx << " to have " << nLoops
              << " dim(s) to match the number of loops";
 
     if (m.getNumResults() == 1 && view.getRank() == 0) {
       auto cst = m.getResult(0).template dyn_cast<AffineConstantExpr>();
       if (!cst || cst.getValue() != 0)
-        return op.emitError("op expected indexing_map #")
+        return op.emitOpError("expected indexing_map #")
                << idx << " to be 0 to match 0-D view: " << view;
     }
 
     if (m.getNumResults() != view.getRank())
-      return op.emitError("op expected indexing_map #")
+      return op.emitOpError("expected indexing_map #")
              << idx << " results to match view rank: " << view;
   }
 
   auto concatMap = concatAffineMaps(indexingMaps);
   auto aggregateMap = inversePermutation(concatMap);
   if (!aggregateMap)
-    return op.emitError("op expected the concatenation of maps in indexing_map "
-                        "to be invertible");
+    return op.emitOpError(
+        "op expected the concatenation of maps in indexing_map "
 
+  auto outputTensorTypes = op.getOutputTensorTypes();
+  if (outputTensorTypes.size() != op.getNumResults())
+    return op.emitOpError("expected #output tensor operands (")
+           << outputTensorTypes.size() << ") to match #results ("
+           << op.getNumResults() << ")";
+
+  unsigned index = 0;
+  for (auto it : llvm::zip(op.getResultTypes(), outputTensorTypes)) {
+    auto resTy = std::get<0>(it);
+    auto outOpTy = std::get<1>(it);
+    if (resTy != outOpTy)
+      return op.emitOpError("result #")
+             << index << " must be " << outOpTy << ", but got " << resTy;
+    ++index;
+  }
+
   return success();
 }
 
 static LogicalResult verify(GenericOp op) { return verifyGenericOp(op); }
 static LogicalResult verify(IndexedGenericOp op) { return verifyGenericOp(op); }
 
 //===----------------------------------------------------------------------===//
 // RangeOp
 //===----------------------------------------------------------------------===//
 
 static void print(OpAsmPrinter &p, RangeOp op) {
   p << op.getOperationName() << " " << *op.min() << ":" << *op.max() << ":"
     << *op.step();
   p.printOptionalAttrDict(op.getAttrs());
   p << " : " << op.getResult()->getType();
 }
 
 static ParseResult parseRangeOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 3> rangeInfo(3);
   RangeType type;
   auto indexTy = parser.getBuilder().getIndexType();
   return failure(parser.parseOperand(rangeInfo[0]) || parser.parseColon() ||
return failure(parser.parseOperandList(opInfo) ||
                  parser.parseOptionalAttrDict(result.attributes) ||
                  (!opInfo.empty() && parser.parseColonTypeList(types)) ||
                  parser.resolveOperands(opInfo, types, loc, result.operands));
 }
 
 template <typename GenericOpType>
 LogicalResult verifyYield(YieldOp op, GenericOpType genericOp) {
   // The operand number and types must match the view element types.
   auto nOutputViews = genericOp.getNumOutputs();
   if (op.getNumOperands() != nOutputViews)
-    return op.emitOpError("op expected ")
+    return op.emitOpError("expected ")
            << nOutputViews << " operand to match enclosing linalg.generic op";
 
   for (unsigned i = 0; i != nOutputViews; ++i) {
-    auto elementType = genericOp.getOutputViewType(i).getElementType();
+    auto elementType = genericOp.getOutputShapedType(i).getElementType();
     if (op.getOperand(i)->getType() != elementType)
-      return op.emitError("type of return operand ")
+      return op.emitOpError("type of return operand ")
              << i << " (" << op.getOperand(i)->getType()
              << ") doesn't match view element type (" << elementType << ")";
   }
   return success();
 }
 
 static LogicalResult verify(YieldOp op) {
   auto *parentOp = op.getParentOp();
   if (parentOp->getNumRegions() != 1 || parentOp->getRegion(0).empty())
-    return op.emitOpError("op expected single non-empty parent region");
+    return op.emitOpError("expected single non-empty parent region");
 
   auto genericOp = dyn_cast<GenericOp>(parentOp);
   if (genericOp)
     return verifyYield(op, genericOp);
 
   auto indexedGenericOp = dyn_cast<IndexedGenericOp>(parentOp);
   if (indexedGenericOp)
     return verifyYield(op, indexedGenericOp);
 
   return op.emitOpError("expected '")
static ParseResult parseLinalgStructuredOp(OpAsmParser &parser,
   return failure(
       parser.parseOperandList(ops, OpAsmParser::Delimiter::Paren) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonTypeList(types) ||
       parser.resolveOperands(ops, types, parser.getNameLoc(), result.operands));
 }
 
 static LogicalResult verify(FillOp op) {
-  auto viewType = op.getOutputViewType(0);
+  auto viewType = op.getOutputShapedType(0);
   auto fillType = op.value()->getType();
   if (viewType.getElementType() != fillType)
     return op.emitOpError("expects fill type to match view elemental type");
   return success();
 }
 
 static LogicalResult verify(CopyOp op) {
-  auto outputViewType = op.getOutputViewType(0);
-  auto inputViewType = op.getInputViewType(0);
+  auto outputViewType = op.getOutputShapedType(0);
+  auto inputViewType = op.getInputShapedType(0);
   if (inputViewType.getElementType() != outputViewType.getElementType())
     return op.emitOpError("expects views of the same type");
   if (inputViewType.getRank() != outputViewType.getRank())
     return op.emitOpError("expects views of the same rank");
   auto rank = op.getNumParallelLoops();
   auto inputPermutationMap = op.inputPermutation();
   if (inputPermutationMap) {
     if (inputPermutationMap->getNumInputs() != rank)

 // Ideally this should all be Tablegen'd but there is no good story for
 // AffineMap for now.
 SmallVector<AffineMap, 4> mlir::linalg::loopToOperandRangesMaps(Operation *op) {
   MLIRContext *context = op->getContext();
   if (auto copyOp = dyn_cast<CopyOp>(op)) {
     // I(input_perm(ivs)) -> O(output_perm(ivs))
     auto maybeInputMap = copyOp.inputPermutation();
     auto maybeOutputMap = copyOp.outputPermutation();
-    unsigned inputRank = copyOp.getInputViewType(0).getRank();
-    unsigned outputRank = copyOp.getOutputViewType(0).getRank();
+    unsigned inputRank = copyOp.getInputShapedType(0).getRank();
+    unsigned outputRank = copyOp.getOutputShapedType(0).getRank();
     return SmallVector<AffineMap, 4>{
         extractOrIdentityMap(maybeInputMap, inputRank, context),
         extractOrIdentityMap(maybeOutputMap, outputRank, context)};
   }
   if (auto fillOp = dyn_cast<FillOp>(op)) {
     // filling_value -> O(ivs)
     unsigned rank = fillOp.getNumParallelLoops();
     return SmallVector<AffineMap, 4>{

mlir/lib/Dialect/Linalg/Transforms/LinalgTransforms.cpp

 //===- LinalgTransforms.cpp - Linalg transformations as patterns ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements logic for transforming Linalg operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Transforms/LinalgTransforms.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Utils/Intrinsics.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/VectorOps/VectorOps.h"
 #include "mlir/EDSC/Helpers.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Matchers.h"
for (auto dependence : G.getDependencesInto(
     if (!isProducerLastWriteOfView(G, consumer, consumedView, producer))
       continue;
     if (isaOpType(dependence.dependentOpView.op))
       return true;
   }
   return false;
 }
 
+//============================================================================//
+// Precondition and transformation for vectorization of Linalg generic ops.
+//============================================================================//
 static bool hasMultiplyAddBody(linalg::GenericOp op) {
   auto &r = op.region();
   if (r.empty())
     return false;
   if (r.getBlocks().size() != 1)
     return false;
   auto &ops = r.front().getOperations();
   if (ops.size() != 3)
     return false;
 
static bool isMatmul(linalg::GenericOp genericOp) {
   auto mapA = AffineMapAttr::get(AffineMap::get(3, 0, {m, k}));
   auto mapB = AffineMapAttr::get(AffineMap::get(3, 0, {k, n}));
   auto mapC = AffineMapAttr::get(AffineMap::get(3, 0, {m, n}));
   auto maps = ArrayAttr::get({mapA, mapB, mapC}, ctx);
   return genericOp.getNumInputs() == 2 && genericOp.getNumOutputs() == 1 &&
          genericOp.indexing_maps() == maps && hasMultiplyAddBody(genericOp);
 }
 
-LogicalResult mlir::linalg::vectorizeGenericOp(PatternRewriter &rewriter,
-                                               Operation *op) {
-  LLVM_DEBUG(dbgs() << "\n[" DEBUG_TYPE
-                       "]: Rewrite linalg op as vector.contract: "
-                    << *op << ":\n");
-
+LogicalResult
+mlir::linalg::vectorizeGenericLinalgOpPrecondition(Operation *op) {
   // TODO(ntv): This is in fact much more general than just vectorization for
   // matmul ops.
   auto genericOp = dyn_cast<linalg::GenericOp>(op);
   if (!genericOp || !isMatmul(genericOp))
     return failure();
 
   // TODO(ntv): non-identity layout.
   auto isStaticMemRefWithIdentityLayout = [](Value v) {
     auto m = v->getType().dyn_cast<MemRefType>();
     if (!m || !m.hasStaticShape() || !m.getAffineMaps().empty())
       return false;
     return true;
   };
   if (!llvm::all_of(genericOp.getInputsAndOutputs(),
                     isStaticMemRefWithIdentityLayout))
     return failure();
+  return success();
+}
 
+SmallVector<Value, 0>
+mlir::linalg::vectorizeGenericLinalgOp(PatternRewriter &rewriter,
+                                       Operation *op) {
+  LLVM_DEBUG(dbgs() << "\n[" DEBUG_TYPE
+                       "]: Rewrite linalg op as vector.contract: "
+                    << *op << ":\n");
+
+  assert(succeeded(vectorizeGenericLinalgOpPrecondition(op)) &&
+         "DRR failure case must be a precondition");
+
+  auto genericOp = cast<linalg::GenericOp>(op);
   edsc::ScopedContext scope(rewriter, op->getLoc());
   using edsc::intrinsics::std_load;
   using edsc::intrinsics::std_store;
   using vector_contract = edsc::intrinsics::ValueBuilder<vector::ContractionOp>;
   using vector_type_cast = edsc::intrinsics::ValueBuilder<vector::TypeCastOp>;
   auto vA = std_load(vector_type_cast(genericOp.getInput(0)));
   auto vB = std_load(vector_type_cast(genericOp.getInput(1)));
   auto vectorMemRefC = vector_type_cast(genericOp.getOutput(0));
   auto vC = std_load(vectorMemRefC);
   auto vRes = vector_contract(vA, vB, vC, genericOp.indexing_maps(),
                               genericOp.iterator_types());
   std_store(vRes, vectorMemRefC);
+  return {};
+}
+
+//============================================================================//
+// Precondition and transformation for permutation of Linalg generic ops.
+//============================================================================//
+LogicalResult mlir::linalg::permuteGenericLinalgOpPrecondition(
+    Operation *op, ArrayRef<unsigned> permutation) {
+  if (permutation.empty())
+    return failure();
+  // Transformation applies to generic ops only.
+  if (!isa<GenericOp>(op) && !isa<IndexedGenericOp>(op))
+    return failure();
+  LinalgOp linOp = cast<LinalgOp>(op);
+  // Transformation applies to buffers only.
+  if (!linOp.hasBufferSemantics())
+    return failure();
   return success();
 }
 
-LogicalResult
+SmallVector<Value, 0>
 mlir::linalg::permuteGenericLinalgOp(PatternRewriter &rewriter, Operation *op,
                                      ArrayRef<unsigned> permutation,
                                      StringRef linalgMarker) {
-  // If permutation is empty, there is nothing to be done.
-  if (permutation.empty())
-    return failure();
+  LLVM_DEBUG(dbgs() << "\n[" DEBUG_TYPE "]: Permute dims for linalg op: " << *op
+                    << ":\n");
+
+  assert(succeeded(permuteGenericLinalgOpPrecondition(op, permutation)) &&
+         "DRR failure case must be a precondition");
 
   auto linOp = cast<LinalgOp>(op);
   auto permutationMap = inversePermutation(
       AffineMap::getPermutationMap(permutation, rewriter.getContext()));
   SmallVector<AffineMap, 4> newIndexingMap;
   auto indexingMaps = linOp.indexing_maps().getValue();
   for (unsigned i = 0, e = linOp.getNumInputsAndOutputs(); i != e; ++i) {
     AffineMap m = indexingMaps[i].cast<AffineMapAttr>().getValue().compose(
         permutationMap);
     newIndexingMap.push_back(m);
   }
   auto itTypes = linOp.iterator_types().getValue();
   SmallVector<Attribute, 4> itTypesVector;
   for (unsigned i = 0, e = itTypes.size(); i != e; ++i)
     itTypesVector.push_back(itTypes[i]);
   applyPermutationToVector(itTypesVector, permutation);
   op->setAttr(getIndexingMapsAttrName(),
               rewriter.getAffineMapArrayAttr(newIndexingMap));
   op->setAttr(getIteratorTypesAttrName(), rewriter.getArrayAttr(itTypesVector));
   op->setAttr(LinalgTransforms::kLinalgTransformMarker,
               rewriter.getStringAttr(linalgMarker));
   linOp.clone(rewriter, linOp.getLoc(), op->getOperands());
+  return {};
+}
+
+//============================================================================//
+// Precondition and transformation for Linalg subview promotion.
+//============================================================================//
+LogicalResult mlir::linalg::promoteSubviewsLinalgOpPrecondition(Operation *op) {
+  LinalgOp linOp = dyn_cast<LinalgOp>(op);
+  // Transformation applies to buffers only.
+  if (!linOp || !linOp.hasBufferSemantics())
+    return failure();
+  if (llvm::none_of(linOp.getInputsAndOutputs(), [](Value v) {
+        return isa_and_nonnull<SubViewOp>(v.getDefiningOp());
+      }))
+    return failure();
   return success();
 }
 
-LogicalResult mlir::linalg::linalgOpPromoteSubviews(PatternRewriter &rewriter,
-                                                    Operation *op) {
-  LinalgOp linOp = dyn_cast<LinalgOp>(op);
+SmallVector<Value, 0>
+mlir::linalg::promoteSubviewsLinalgOp(PatternRewriter &rewriter,
+  LLVM_DEBUG(dbgs() << "\n[" DEBUG_TYPE "]: Promote subviews for linalg op: "
+                    << *op << ":\n");
+
+  assert(succeeded(promoteSubviewsLinalgOpPrecondition(op)) &&
+         "DRR failure case must be a precondition");
+
+  LinalgOp linOp = cast<LinalgOp>(op);
   SetVector<Value> subViews;
   for (auto it : linOp.getInputsAndOutputs())
     if (auto sv = dyn_cast_or_null<SubViewOp>(it->getDefiningOp()))
       subViews.insert(sv);
   if (!subViews.empty()) {
-    auto resOp = promoteSubViewOperands(rewriter, linOp, subViews);
-    return success(resOp);
+    promoteSubViewOperands(rewriter, linOp, subViews);
+    return {};
   }
-  return failure();
+  llvm_unreachable("DRR failure case must be a precondition");
 }

mlir/lib/Dialect/VectorOps/VectorTransforms.cpp

 //===- VectorToLoops.cpp - Conversion within the Vector dialect -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements target-independent rewrites as 1->N patterns.
 //
 //===----------------------------------------------------------------------===//
 
 #include <type_traits>
 
 #include "mlir/Dialect/VectorOps/Utils.h"
 #include "mlir/Dialect/VectorOps/VectorOps.h"
 #include "mlir/Dialect/VectorOps/VectorTransforms.h"
 #include "mlir/EDSC/Builders.h"
 #include "mlir/EDSC/Helpers.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
getVectorElementwiseOpUnrollState(Operation *op, ArrayRef<int64_t> targetShape,
   vectors.resize(numVectors);
   for (unsigned i = 0; i < op->getNumOperands(); ++i)
     vectors[i] = {resultType, indexMap, i, false};
   vectors[numVectors - 1] = {resultType, indexMap, -1, false};
   resultIndex = numVectors - 1;
 }
 
 // Entry point for unrolling declarative pattern rewrites.
-Value mlir::vector::unrollSingleResultOpMatchingType(
+SmallVector<Value, 1> mlir::vector::unrollSingleResultOpMatchingType(
     PatternRewriter &builder, Operation *op, ArrayRef<int64_t> targetShape) {
   assert(op->getNumResults() == 1 && "Expected single result operation");
 
   // Populate 'iterationBounds', 'vectors' and 'resultIndex' to unroll 'op'.
   SmallVector<int64_t, 6> iterationBounds;
   std::vector<VectorState> vectors;
   unsigned resultIndex;
 
   if (auto contractionOp = dyn_cast<vector::ContractionOp>(op)) {
     // Popultate state for vector ContractionOp.
     getVectorContractionOpUnrollState(contractionOp, targetShape,
                                       iterationBounds, vectors, resultIndex);
   } else {
     // Populate state for vector elementwise op.
     getVectorElementwiseOpUnrollState(op, targetShape, iterationBounds, vectors,
                                       resultIndex);
   }
 
   // Unroll 'op' with 'iterationBounds' to 'targetShape'.
-  return unrollSingleResultStructuredOp(op, iterationBounds, vectors,
-                                        resultIndex, targetShape, builder);
+  return SmallVector<Value, 1>{unrollSingleResultStructuredOp(
+      op, iterationBounds, vectors, resultIndex, targetShape, builder)};
 }
 
 // Generates slices of 'vectorType' according to 'sizes' and 'strides, and
 // calls 'fn' with linear index and indices for each slice.
 static void
 generateTransferOpSlices(VectorType vectorType, TupleType tupleType,
                          ArrayRef<int64_t> sizes, ArrayRef<int64_t> strides,
                          ArrayRef<Value> indices, PatternRewriter &rewriter,

mlir/test/Dialect/Linalg/invalid.mlir

linalg.generic {
     ^bb(%i: f32):
       %0 = constant 0: i1
       linalg.yield %0: i1
   }: memref<?xf32, (i)[off]->(off + i)>
 }
 
 // -----
 
+func @generic_result_tensor_type(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
+  // expected-error @+1 {{op result #0 must be ranked tensor of any type values, but got 'f32'}}
+  %0 = linalg.generic {
+    args_in = 0,
+    args_out = 1,
+    indexing_maps = [ (i) -> (i) ],
+    iterator_types = ["parallel"]
+  } %arg0 {
+    ^bb(%i: f32):
+      linalg.yield %i: f32
+  }: memref<?xf32, (i)[off]->(off + i)> -> f32
+}
+
+// -----
+
+func @generic_result_tensor_count(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
+  // expected-error @+1 {{op expected #output tensor operands (0) to match #results (1)}}
+  %0 = linalg.generic {
+    args_in = 0,
+    args_out = 1,
+    indexing_maps = [ (i) -> (i) ],
+    iterator_types = ["parallel"]
+  } %arg0 {
+    ^bb(%i: f32):
+      linalg.yield %i: f32
+  }: memref<?xf32, (i)[off]->(off + i)> -> tensor<?xf32>
+}
+
+// -----
+
+func @generic_result_tensor_type(%arg0: tensor<?xf32>) {
+  // expected-error @+1 {{op result #0 must be 'tensor<?xf32>', but got 'tensor<?x?xf32>'}}
+  %0 = linalg.generic {
+    args_in = 0,
+    args_out = 1,
+    indexing_maps = [ (i) -> (i) ],
+    iterator_types = ["parallel"]
+  } %arg0 {
+    ^bb(%i: f32):
+      linalg.yield %i: f32
+  }: tensor<?xf32> -> tensor<?x?xf32>
+}
+
+// -----
+
 func @generic_fun_result_0_element_type(%arg0: memref<?xf32>) {
   // expected-error @+1 {{'linalg.dot' op expected 3 or more operands}}
   linalg.dot(%arg0, %arg0): memref<?xf32>, memref<?xf32>
 }
 
 // -----
 
 // expected-error @+1 {{unknown Linalg type}}
 !invalid_type = type !linalg.unknown
 
 // -----
 
 // expected-error @+1 {{expected valid keyword}}
 !invalid_type = type !linalg<"?">

mlir/test/Dialect/Linalg/roundtrip.mlir

 func @generic(%arg0: memref<?x?xvector<3x4xi4>, offset: ?, strides: [?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
   linalg.generic #trait %arg0, %arg1 {foo = 1} : memref<?x?xvector<3x4xi4>, offset: ?, strides: [?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @foo
 // CHECK-LABEL: func @generic
 //       CHECK:   linalg.generic {args_in = 1 : i64, args_out = 1 : i64, fun = @foo, indexing_maps = [#{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "parallel"], library_call = "some_external_function_name_1"} %{{.*}}, %{{.*}} {foo = 1 : i64}: memref<?x?xvector<3x4xi4>, #[[strided2D]]>, memref<?x?x?xf32, #[[strided3D]]>
 
+func @generic_with_tensor_input(%arg0: tensor<?x?xvector<3x4xi4>>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
+  linalg.generic #trait %arg0, %arg1 {foo = 1} : tensor<?x?xvector<3x4xi4>>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
+  return
+}
+// CHECK-LABEL: func @generic_with_tensor_input
+//       CHECK:   linalg.generic {args_in = 1 : i64, args_out = 1 : i64, fun = @foo, indexing_maps = [#{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "parallel"], library_call = "some_external_function_name_1"} %{{.*}}, %{{.*}} {foo = 1 : i64}: tensor<?x?xvector<3x4xi4>>, memref<?x?x?xf32, #[[strided3D]]>
+
+func @generic_with_tensor_output(%arg0: memref<?x?xvector<3x4xi4>, offset: ?, strides: [?, 1]>, %arg1: tensor<?x?x?xf32>) -> (tensor<?x?x?xf32>) {
+  %0 = linalg.generic #trait %arg0, %arg1 {foo = 1} : memref<?x?xvector<3x4xi4>, offset: ?, strides: [?, 1]>, tensor<?x?x?xf32> -> tensor<?x?x?xf32>
+  return %0 : tensor<?x?x?xf32>
+}
+// CHECK-LABEL: func @generic_with_tensor_output
+//       CHECK:   linalg.generic {args_in = 1 : i64, args_out = 1 : i64, fun = @foo, indexing_maps = [#{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "parallel"], library_call = "some_external_function_name_1"} %{{.*}}, %{{.*}} {foo = 1 : i64}: memref<?x?xvector<3x4xi4>, #[[strided2D]]>, tensor<?x?x?xf32> -> tensor<?x?x?xf32>
+//       CHECK:   return {{.*}} : tensor<?x?x?xf32>
+
+func @generic_with_tensor_input_and_output(%arg0: tensor<?x?xvector<3x4xi4>>, %arg1: tensor<?x?x?xf32>) -> (tensor<?x?x?xf32>) {
+  %0 = linalg.generic #trait %arg0, %arg1 {foo = 1} : tensor<?x?xvector<3x4xi4>>, tensor<?x?x?xf32> -> tensor<?x?x?xf32>
+  return %0 : tensor<?x?x?xf32>
+}
+// CHECK-LABEL: func @generic_with_tensor_input_and_output
+//       CHECK:   linalg.generic {args_in = 1 : i64, args_out = 1 : i64, fun = @foo, indexing_maps = [#{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "parallel"], library_call = "some_external_function_name_1"} %{{.*}}, %{{.*}} {foo = 1 : i64}: tensor<?x?xvector<3x4xi4>>, tensor<?x?x?xf32> -> tensor<?x?x?xf32>
+//       CHECK:   return {{.*}} : tensor<?x?x?xf32>
+
 #trait2 = {
   args_in = 1,
   args_out = 1,
   indexing_maps = #accesses,
   iterator_types = ["parallel", "parallel", "parallel"],
   library_call = "some_external_function_name_2"
 }
 func @generic_region(%arg0: memref<?x?xvector<3x4xi4>, offset: ?, strides: [?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {

mlir/test/lib/DeclarativeTransforms/TestLinalgTransformPatterns.td

 #ifndef TEST_LINALG_TRANSFORMS_PATTERNS
 #define TEST_LINALG_TRANSFORMS_PATTERNS
 
 include "mlir/Dialect/Linalg/Transforms/LinalgTransformPatterns.td"
 
 //===----------------------------------------------------------------------===//
 // Test Linalg fusion patterns.
 //===----------------------------------------------------------------------===//
-def : Pat<(MatmulOp:$consumer $A, $B, $C),
-          (TileAndFuseLinalgOp<[100, 150], [0], "L1"> $consumer),
+def : Pat<(MatmulOp:$op $A, $_, $_),
+          (TileAndFuseLinalgOp<[100, 150], [0], "L1">),
           [
-            (Constraint<HasNoLinalgTransformMarker> $consumer),
-            (Constraint<IsProducedByOpOfType<"MatmulOp">> $consumer, $A),
+            (Constraint<HasNoLinalgTransformMarker>),
+            (Constraint<IsProducedByOpOfType<"MatmulOp">> $A),
           ],
           // In the buffer world there is no use-def chains or dags so benefits
           // cannot be computed automatically from the length of the matched
           // pattern. Instead we specify the benefit ourselves for now.
           // This is not expected to be a big challenge long-term because
           // pattern benefits are akin to feature engineering: features should
           // be learned.
           (addBenefit 1)>;
 
 //===----------------------------------------------------------------------===//
 // Linalg tiling patterns.
 //===----------------------------------------------------------------------===//
-def : Pat<(MatmulOp:$op $A, $B, $C),
-          (TileLinalgOp<[2000, 3000, 4000], "L3"> $op),
+def : Pat<(MatmulOp:$op $_, $_, $_),
+          (TileLinalgOp<[2000, 3000, 4000], "L3">),
           [(Constraint<Or<[HasNoLinalgTransformMarker,
-                           HasLinalgTransformMarker<"MEM">]>> $op)]>;
-def : Pat<(MatmulOp:$op $A, $B, $C),
-          (TileLinalgOp<[200, 300, 400], "L2"> $op),
-          [(Constraint<HasLinalgTransformMarker<"L3">> $op)]>;
-def : Pat<(MatmulOp:$op $A, $B, $C),
-          (TileLinalgOp<[20, 30, 40], "L1"> $op),
-          [(Constraint<HasLinalgTransformMarker<"L2">> $op)]>;
-def : Pat<(MatmulOp:$op $A, $B, $C),
-          (TileLinalgOp<[2, 3, 4], "REG"> $op),
-          [(Constraint<HasLinalgTransformMarker<"L1">> $op)]>;
-
-def : Pattern<(MatvecOp:$op $A, $b, $c),
-              [(TileLinalgOp<[5, 6], "L1"> $op)],
-              [(Constraint<HasNoLinalgTransformMarker> $op)]>;
+                           HasLinalgTransformMarker<"MEM">]>>)]>;
+def : Pat<(MatmulOp:$op $_, $_, $_),
+          (TileLinalgOp<[200, 300, 400], "L2">),
+          [(Constraint<HasLinalgTransformMarker<"L3">>)]>;
+def : Pat<(MatmulOp:$op $_, $_, $_),
+          (TileLinalgOp<[20, 30, 40], "L1">),
+          [(Constraint<HasLinalgTransformMarker<"L2">>)]>;
+def : Pat<(MatmulOp:$op $_, $_, $_),
+          (TileLinalgOp<[2, 3, 4], "REG">),
+          [(Constraint<HasLinalgTransformMarker<"L1">>)]>;
+
+def : Pattern<(MatvecOp:$op $_, $_, $_),
+              [(TileLinalgOp<[5, 6], "L1">)],
+              [(Constraint<HasNoLinalgTransformMarker>)]>;
 
-def : Pattern<(DotOp:$op $a, $b, $c),
-              [(TileLinalgOp<[8000], "L1"> $op)],
+def : Pattern<(DotOp:$op $_, $_, $_),
+              [(TileLinalgOp<[8000], "L1">)],
               [(Constraint<Or<[HasNoLinalgTransformMarker,
                                HasLinalgTransformMarker<"MEM">,
                                HasLinalgTransformMarker<"L3">,
-                               HasLinalgTransformMarker<"L2">]>> $op)]>;
-def : Pattern<(DotOp:$op $a, $b, $c),
-              [(TileLinalgOp<[8], "REG"> $op)],
-              [(Constraint<HasLinalgTransformMarker<"L1">> $op)]>;
+                               HasLinalgTransformMarker<"L2">]>>)]>;
+def : Pattern<(DotOp:$op $_, $_, $_),
+              [(TileLinalgOp<[8], "REG">)],
+              [(Constraint<HasLinalgTransformMarker<"L1">>)]>;
 
 //===----------------------------------------------------------------------===//
 // Linalg tiling and permutation patterns.
 //===----------------------------------------------------------------------===//
-def : Pat<(MatmulOp:$op $A, $B, $C),
-          (TileLinalgOp<[2000, 3000, 4000], "L2__with_perm__", [1,2,0]> $op),
-          [(Constraint<HasLinalgTransformMarker<"__with_perm__">> $op)]>;
-def : Pat<(MatmulOp:$op $A, $B, $C),
-          (TileLinalgOp<[200, 300, 400], "L1__with_perm__", [1,0,2]> $op),
-          [(Constraint<HasLinalgTransformMarker<"L2__with_perm__">> $op)]>;
-def : Pat<(MatmulOp:$op $A, $B, $C),
-          (TileLinalgOp<[20, 30, 40], "REG__with_perm__"> $op),
-          [(Constraint<HasLinalgTransformMarker<"L1__with_perm__">> $op)]>;
-
-
-def : Pattern<(MatvecOp:$op $A, $b, $c),
-              [(TileLinalgOp<[5, 6], "L1__with_perm__", [1,0]> $op)],
-              [(Constraint<HasLinalgTransformMarker<"__with_perm__">> $op)]>;
-
-def : Pattern<(DotOp:$op $a, $b, $c),
-              [(TileLinalgOp<[8000], "L1__with_perm__"> $op)],
-              [(Constraint<HasLinalgTransformMarker<"__with_perm__">> $op)]>;
-def : Pattern<(DotOp:$op $a, $b, $c),
-              [(TileLinalgOp<[8], "REG__with_perm__"> $op)],
-              [(Constraint<HasLinalgTransformMarker<"L1__with_perm__">> $op)]>;
+def : Pat<(MatmulOp:$op $_, $_, $_),
+          (TileLinalgOp<[2000, 3000, 4000], "L2__with_perm__", [1,2,0]>),
+          [(Constraint<HasLinalgTransformMarker<"__with_perm__">>)]>;
+def : Pat<(MatmulOp:$op $_, $_, $_),
+          (TileLinalgOp<[200, 300, 400], "L1__with_perm__", [1,0,2]>),
+          [(Constraint<HasLinalgTransformMarker<"L2__with_perm__">>)]>;
+def : Pat<(MatmulOp:$op $_, $_, $_),
+          (TileLinalgOp<[20, 30, 40], "REG__with_perm__">),
+          [(Constraint<HasLinalgTransformMarker<"L1__with_perm__">>)]>;
+
+
+def : Pattern<(MatvecOp:$op $_, $_, $_),
+              [(TileLinalgOp<[5, 6], "L1__with_perm__", [1,0]>)],
+              [(Constraint<HasLinalgTransformMarker<"__with_perm__">>)]>;
+
+def : Pattern<(DotOp:$op $_, $_, $_),
+              [(TileLinalgOp<[8000], "L1__with_perm__">)],
+              [(Constraint<HasLinalgTransformMarker<"__with_perm__">>)]>;
+def : Pattern<(DotOp:$op $_, $_, $_),
+              [(TileLinalgOp<[8], "REG__with_perm__">)],
+              [(Constraint<HasLinalgTransformMarker<"L1__with_perm__">>)]>;
 
 //===----------------------------------------------------------------------===//
 // Linalg to loops patterns.
 //===----------------------------------------------------------------------===//
-def : Pattern<(DotOp:$op $a, $b, $c),
-              [(LinalgOpToLoops<"DotOp"> $op)],
-              [(Constraint<HasLinalgTransformMarker<"REG">> $op)]>;
+def : Pattern<(DotOp:$op $_, $_, $_),
+              [(LinalgOpToLoops<"DotOp">)],
+              [(Constraint<HasLinalgTransformMarker<"REG">>)]>;
 
 //===----------------------------------------------------------------------===//
 // Linalg to vector contraction patterns.
 //===----------------------------------------------------------------------===//
-def : Pattern<(GenericOp:$op $_1, $_2, $_3, $_4, $_5, $_6, $_7, $_8),
-              [(LinalgOpToVectorContraction<"GenericOp"> $op)],
-              [(Constraint<HasLinalgTransformMarker<"_marked_matmul_">> $op)]>;
+def : Pattern<(GenericOp:$op $_, $_, $_, $_, $_, $_, $_, $_),
+             [(VectorizeGenericLinalgOp)],
+             [(Constraint<And<[
+               HasLinalgTransformMarker<"_marked_matmul_">,
+               PreconditionVectorizeGenericLinalgOp
+               ]>>)]>;
 
 //===----------------------------------------------------------------------===//
 // Linalg generic permutation patterns.
 //===----------------------------------------------------------------------===//
-def : Pat<(GenericOp:$op $_1, $_2, $_3, $_4, $_5, $_6, $_7, $_8),
-              (PermuteGenericLinalgOp<[1,2,0],"PERMUTED"> $op),
-              [(Constraint<And<[HasNoLinalgTransformMarker,
-                           AffineMapDomainHasDim<3>]>> $op)]>;
-
-def : Pat<(IndexedGenericOp:$op $_1, $_2, $_3, $_4, $_5, $_6, $_7, $_8),
-              (PermuteGenericLinalgOp<[1,2,0],"PERMUTED"> $op),
-              [(Constraint<And<[HasNoLinalgTransformMarker,
-                           AffineMapDomainHasDim<3>]>> $op)]>;
+def : Pat<(GenericOp:$op $_, $_, $_, $_, $_, $_, $_, $_),
+              (PermuteGenericLinalgOp<[1, 2, 0], "PERMUTE"> $op),
+              [(Constraint<And<[
+                HasNoLinalgTransformMarker,
+                AffineMapDomainHasDim<3>,
+                PreconditionPermuteGenericLinalgOp<[1, 2, 0]>
+              ]>>)]>;
+
+def : Pat<(IndexedGenericOp:$op $_, $_, $_, $_, $_, $_, $_, $_),
+              (PermuteGenericLinalgOp<[1, 2, 0], "PERMUTE"> $op),
+              [(Constraint<And<[
+                HasNoLinalgTransformMarker,
+                AffineMapDomainHasDim<3>,
+                PreconditionPermuteGenericLinalgOp<[1, 2, 0]>
+              ]>>)]>;
 
 //===----------------------------------------------------------------------===//
 // Linalg subview operands promotion.
 //===----------------------------------------------------------------------===//
-def : Pat<(MatmulOp:$op $A, $B, $C),
-          (LinalgOpPromoteSubviews<"MatmulOp"> $op),
-          [(Constraint<HasOperandsOfType<"SubViewOp">> $op),
-          (Constraint<HasLinalgTransformMarker<"_promote_views_">> $op)]>;
+def : Pat<(MatmulOp:$op $_, $_, $_),
+          (PromoteSubviewsLinalgOp),
+          [(Constraint<And<[
+              PreconditionPromoteSubviewsLinalgOp,
+              HasOperandsOfType<"SubViewOp">,
+              HasLinalgTransformMarker<"_promote_views_">]>>
+           )]>;
 #endif // TEST_LINALG_TRANSFORMS_PATTERNS

mlir/tools/mlir-tblgen/RewriterGen.cpp

 //===- RewriterGen.cpp - MLIR pattern rewriter generator ------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // RewriterGen uses pattern rewrite definitions to generate rewriter matchers.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Support/STLExtras.h"
 #include "mlir/TableGen/Attribute.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/Pattern.h"
 #include "mlir/TableGen/Predicate.h"
 #include "mlir/TableGen/Type.h"
 #include "llvm/ADT/StringExtras.h"
assert(replStartIndex >= numResultPatterns &&
            "invalid auxiliary vs. replacement pattern division!");
     // No result to replace. Just erase the op.
     os.indent(4) << "rewriter.eraseOp(op0);\n";
   } else {
     // Process replacement result patterns.
     os.indent(4) << "SmallVector<Value, 4> tblgen_repl_values;\n";
     for (int i = replStartIndex; i < numResultPatterns; ++i) {
       DagNode resultTree = pattern.getResultPattern(i);
       auto val = handleResultPattern(resultTree, offsets[i], 0);
       os.indent(4) << "\n";
       // Resolve each symbol for all range use so that we can loop over them.
+      // We need an explicit cast to `SmallVector` to capture the cases where
+      // `{0}` resolves to an `Operation::result_range` as well as cases that
+      // are not iterable (e.g. vector that gets wrapped in additional braces by
+      // RewriterGen).
       os << symbolInfoMap.getAllRangeUse(
-          val, "    for (auto v : {0}) {{ tblgen_repl_values.push_back(v); }",
+          val,
+          "    for (auto v : SmallVector<Value, 4>{ {0} }) {{ "
+          "tblgen_repl_values.push_back(v); }",
           "\n");
     }
     os.indent(4) << "\n";
     os.indent(4) << "rewriter.replaceOp(op0, tblgen_repl_values);\n";
   }
 
   LLVM_DEBUG(llvm::dbgs() << "--- done emitting rewrite logic ---\n");
 }
 
 std::string PatternEmitter::getUniqueSymbol(const Operator *op) {