[mlir][Linalg] Introduce linalg.pad_tensor op.

[hanchung]

Summary

linalg.pad_tensor is an operation that pads the source tensor
with given low and high padding config.

Example 1:

mlir
  %pad_value = ... : f32
  %1 = linalg.pad_tensor %0 low[1, 2] high[2, 3] {
  ^bb0(%arg0 : index, %arg1 : index):
    linalg.yield %pad_value : f32
  } : tensor<?x?xf32> to tensor<?x?xf32>

Example 2:

mlir
  %pad_value = ... : f32
  %1 = linalg.pad_tensor %arg0 low[2, %arg1, 3, 3] high[3, 3, %arg1, 2] {
  ^bb0(%arg2: index, %arg3: index, %arg4: index, %arg5: index):
    linalg.yield %pad_value : f32
  } : tensor<1x2x2x?xf32> to tensor<6x?x?x?xf32>

[mehdi_amini]

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

52

This backquote isn't closed.

60

You don't make it clear if the source buffer is *modified* by this op.
It seems like it is, because I don't see how to store the padded values otherwise, but that's not great that an operation which is described as "taking a view" is actually modifying the source buffer.

[mravishankar]

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

60

Thanks Mehdi (Hanhan and I discussed this op extensively and the implementation is based on that discussion). Would like to hash out semantics of this.

The op is not modifying the source buffer while taking a view. Instead it is providing a view of the underlying buffer with information about what values to use if you go "outside" of the underlying source buffer", i.e.

• When you read from the view, if you are not in the padding, you get the value from the source buffer. If you are in the padding you get the padded value specified using the region of the operation
• When you write from the view, if you are not in the padding, you write to the source buffer. If you are in the padding the write is ignored. (@Hanhan maybe we should make this semantics explicit)

For the write I agree the semantics is strange (but arguably correct). I dont expect the padded_view to be used to write data. Its only used to read, but the semantics is fairly easy to specify.
This is a way to not always require creating a new buffer to implement padding. Using this op you can fold the padding with its load/store which is a more efficient way to implement padding. You can also fold this with vector.transfer_read/transfer_write to used masked operations and vectorize the computation even with padding.

The advantage here is that the transformation to do tiling/vectorization, etc do not need to actually worry about the padding. They can be implemented as if they are working with the padded buffer. The padding is then implemented using rewrites on load/stores.
Goes without saying this is experimental to some extent, but thats what a lot of manual implementations of ops like conv/pooling, etc. implement

[mehdi_amini]

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

60

I have some concerns with what you're describing, because this "view" produces a memref that isn't usable without understanding and accessing this padded_view operation to be able to get the padded value.

[mehdi_amini]

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

60

Another aspect is that it does not describe when is the region evaluated: all these ops are evaluating their region when the op is executed, while here it seems that your intent is to fold the region to wherever the memref is used. That can yield weird "effects at a distance" when the region does more than just return a fixed SSA value.

[mravishankar]

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

60

I have some concerns with what you're describing, because this "view" produces a memref that isn't usable without understanding and accessing this padded_view operation to be able to get the padded value.

Explicitly trying to avoid that. This is producing a view (which is memref type) and not a new allocation. Within Linalg itself, you dont need to know where this "memref" came from. Can you give me a more concrete example of why the memref produced here is not usable. From my reading of what this sentence says, the same is true even for a subview. So maybe missing something.

Another aspect is that it does not describe when is the region evaluated: all these ops are evaluating their region when the op is executed, while here it seems that your intent is to fold the region to wherever the memref is used. That can yield weird "effects at a distance" when the region does more than just return a fixed SSA value.

The region is evaluated when you try to access the source memref using indices that are within the padded region. I am not sure I understand what you mean by region not returning a fixed SSA value. It has a single return value. We could have the region describe the conditionals logic described below, but thats seems cumbersome and not really required for the op semantics.

[mehdi_amini]

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

60

Explicitly trying to avoid that. This is producing a view (which is memref type) and not a new allocation. Within Linalg itself, you dont need to know where this "memref" came from. Can you give me a more concrete example of why the memref produced here is not usable. From my reading of what this sentence says, the same is true even for a subview. So maybe missing something.

As far as I understand it, a subview only transforms the mapping from the virtual index space into the underlying buffer, this isn't the case here because of the padding.
For example you have this example in the test:

%0 = linalg.padded_view %arg0[1, 2] [2, 3] {
  ^bb0(%arg1 : index, %arg2 : index):
    linalg.yield %pad_value : f32
  } : memref<3x4xf32> to memref<6x9xf32>

What can we do with the %0 memref? Can we use it like other memref?
So for example can you pass it to the runtime print?
We have mlir-cpu-runner test where you should be able to do:

%cast = memref_cast %0 : memref<6x9xf32> to memref<*xf32>
call @print_memref_f32(%unranked_input) : (memref<*xf32>) -> ()

Will this print a 6x9 output? What will it print for the padding?

The region is evaluated when you try to access the source memref using indices that are within the padded region.

As I mentioned before, this seems dangerously fragile to me. At minima that requires ensuring that the region has no side effects.

I am not sure I understand what you mean by region not returning a fixed SSA value. It has a single return value.

I mean that the SSA value alone is not enough, the SSA value somehow carries with it the closure that is represented by the region. This isn't consistent with memref in general I believe.
But we can clarify this point by looking at the example I provide above, this isn't a different point here.

[hanchung]

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

60

I don't know how print_memref_f32 work, but I can get a bit what you're saying. Different from other memref, we need a special logic to handle the output of linalg.padded_view. linalg.padded_view not only maps the access indices into the buffer, it also defines non-mapped elements in the buffer.

I feel theoretically it is correct because what print_memref_f32 does is to iterate over all the elements like:

scf.for %iv0 = ... {
  scf.for %iv1 = ... {
    %0 = load padded_view[%iv0, %iv1] : f32
    print %0 : f32
  }
}

And a valid lowering of padded_view is to fold it into if-else to extract the load_value or pad_value. So it will print a 6x9 output.

As Mahesh mentioned, this operation is expected to work within Linalg itself. After applying some transforms, the operation will just fold into either if-else op or alloc + fill + copy. The goal to create a Linalg operation which can represent "pad" semantics in Linalg, work with Linalg transforms, and the op will get killed at some point. I would expect to apply passes (like linalg-to-std) to work with mlir-cpu-runner.

I agree that we can have a more complete definition on the op like Mahesh stated:

When you read from the view, if you are not in the padding, you get the value from the source buffer. If you are in the padding you get the padded value specified using the region of the operation.
When you write from the view, if you are not in the padding, you write to the source buffer. If you are in the padding the write is ignored.

Having a region is easier to extend the pad op to handle different padding cases, like repeat_edge, mirror_edge, etc. But if this is not consistent with memref, I think we can have an explicit operation like padded_scalar_view without taking a region.

[hanchung]

Add more descriptions

[mehdi_amini]

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

60

I feel theoretically it is correct because what print_memref_f32 does is to iterate over all the elements like:
...
And a valid lowering of padded_view is to fold it into if-else to extract the load_value or pad_value. So it will print a 6x9 output.

I assume that it is %padded_view here and it is the SSA value returned by linalg.padded_view?

Then it would require *every* consumer of the memref to look for the producer and understand how it need to handle it: the SSA value you're producing is not a valid memref by itself, this is a problem to me.

print_memref_f32 is implemented here: https://github.com/llvm/llvm-project/blob/master/mlir/lib/ExecutionEngine/RunnerUtils.cpp#L39

[bondhugula]

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

40

pad -> padded_view

41

Nit: : after example

45

This is where you could really use the custom syntax to improve readability. Consider using keywords like low and high so that it's clear what corresponds to low/high and what corresponds to dimensions. Eg:
linalg.padded_view %0 low [1, 2] high [2, 3] {

45

Unfortunately, this design is flawed as @mehdi_amini hints in his first message -- simply because the resulting memref type isn't carrying the necessary information. This basically means that one is lost if the memref "escapes" (not just interprocedurally but also within a function in various ways), passed along to nested regions with arguments or propagated along in explicit capture style, or in numerous other ways. This is a common pitfall of not having the necessary information encoded in the type. @mravishankar - note that this is NOT a problem with the other view/subview like ops or any other memref creating cast ops that I've seen till date --- because the necessary information to lower say the load/stores is available in the *type*. If other memref defining ops with behavior like these have been introduced where you have to look at the defining operation to see what's happening with accesses (like @mehdi_amini points out), I believe that's equally grave!

51

The first list ...

[mravishankar]

Catching up on the discussion after break here. I agree the design is flawed. The strides are wrong of the result memref. As defined right now that would mean that lowering the memref will need to look at where the memref is coming from which is really wrong. You could return a memref with the strides embedded into the memref type so that it works fine, but I dont think that fully works either. I think Hanhan had a fix to this shortly. Thanks for the feedback!

[hanchung]

Rework and define the op on tensor.

[hanchung]

Update the doc a bit.

[hanchung]

After a long offline discussion, we have a plan to make pad op work with Linalg transforms. I will add two pad op, one is tensor version and another is memref version. I'll start with adding pad_tensor op to Linalg.

I agree that the original semantic introduces issues on memref. The information is not enough. The current plan is to pass an extra destination memref instead of returning one. I will work on it and send out for review in another patch. Thanks for the feedbacks, they are really helpful!

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

45

Added low and high. This is a good idea, thanks!

[nicolasvasilache]

Thanks for pushing on this Hanhan.
The impl. needs to be a little more involved to allow different numbers of low and high padding values.
You'll also need extra builders and accessors to make things easier to manipulate, they can be added on a per need basis.
You can look at Subview/Subtensor and the OffsetSizesAndStridesInterface for similarly looking code.
Refactorings to reuse code are most welcome, if reasonable.

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

36

I think you can't just use SameVariadicOperandSize, the following shouldn't work:
.pad_tensor %t low[0, 0] high[%ub0, %ub1].

Indeed you're missing a test for this.

You need to handle your operand_segment_size manually.

See https://github.com/llvm/llvm-project/blob/b1e1bbae0e30c89251940efb0780eee6a1b79ecd/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td#L226
and https://github.com/llvm/llvm-project/blob/118a71565462db41cab1dbb0349200627d6e8524/mlir/lib/Interfaces/ViewLikeInterface.cpp#L161 if you need an example.

42

I'd move the examples after the textual description.

mlir/test/Dialect/Linalg/roundtrip.mlir

22

Please add an asymmetrical test as discussed above.

[hanchung]

Address comments

• Use AttrSizedOperandSegments trait
• Add an asymmetrical test
• Add couple extra builders
• Add operands description
• Move examples after the textual description

[nicolasvasilache]

This looks good.
Can you please add one test per verifier failure to test/Dialect/Linalg/invalid.mlir ?
Once these are in, this is good to go.

Thanks @hanchung !

[hanchung]

Add one more test to invalid.mlir

[hanchung]

In D93704#2512931, @nicolasvasilache wrote:

This looks good.
Can you please add one test per verifier failure to test/Dialect/Linalg/invalid.mlir ?
Once these are in, this is good to go.

Thanks @hanchung !

Added one more test.

The only missing one is for multiple blocks. I think it is not easy to test in invalid.mlir because the parser doesn't parse two regions.

[hanchung]

Add no block test

[hanchung]

In D93704#2513404, @hanchung wrote:

In D93704#2512931, @nicolasvasilache wrote:

This looks good.
Can you please add one test per verifier failure to test/Dialect/Linalg/invalid.mlir ?
Once these are in, this is good to go.

Thanks @hanchung !

Added one more test.

The only missing one is for multiple blocks. I think it is not easy to test in invalid.mlir because the parser doesn't parse two regions.

I was wrong, added.

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

class Linalg_Op<string mnemonic, list<OpTrait> traits = []> :
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
+def Linalg_PadOp : Linalg_Op<"padded_view",
+    [DeclareOpInterfaceMethods<ViewLikeOpInterface>,
+     SingleBlockImplicitTerminator<"YieldOp">]> {
+  let summary = "memref padded view operation";
+  let description = [{
+    The pad operation provides a view of the underlying buffer with
+    padding. For example
+
+    ```mlir
+      %pad_value = ... : f32
+      %1 = linalg.padded_view %0[1, 2] [2, 3] {
+        ^bb0(%arg0 : index, %arg1 : index):
+          linalg.yield %pad_value : f32
+      } : memref<?x?xf32> to memref<?x?xf32>
+    ```
+
+    The first `[ ]` contains the padding along the start of each
+    dimension, i.e `low_padding`. The second `[ ]` contains the padding
+    along the end of each dimension, i.e. `high_padding`. The result
+    memref dimensions are `low_padding` + `dim` + `high_padding` along
+    that dimension. The number of elements of low_padding and
+    high_padding must match the rank of the input memref (which is
+    also the rank of the output memref).
+
+    The region of the `padded_view` operation returns the value to use
+    for the padding. The arguments of the region represent the index
+    of the source being accessed. There should be as many arguments as
+    the rank of the `source` memref. The value `yield`-ed by the
+    region is used as the value of the view at the given position.
+
+    Note that the operation is returning a "view" of the underlying
+    buffer and not a newly allocated buffer. So using the padded_view
+    as the result buffer of an operation results in the update of the
+    `source` memref.
+
+    When you read from the view, if you are not in the padding, you get
+    the value from the source buffer. If you are in the padding you get
+    the padded value specified using the region of the operation.
+
+    When you write to the view, if you are not in the padding, you
+    write to the source buffer. If you are in the padding the write is
+    ignored.
+
+    A valid lowering of `padded_view` is to fold it with its
+    consumers. For example,
+
+    ```mlir
+    %pad_value = ... : f32
+    %1 = linalg.padded_view %0[1, 2] [2, 3] {
+      ^bb0(%arg0 : index, %arg1 : index):
+        linalg.yield %pad_value : f32
+      } : memref<?x?xf32> to memref<?x?xf32>
+    scf.for %iv0 = ... {
+      scf.for %iv1 = ... {
+        %2 = load %1[%iv0, %iv1] : memref<?x?xf32>
+      }
+    }
+    ```
+
+    can be folded to
+
+    ```mlir
+    %pad_value = .... : f32
+    %c0 = constant 0 : index
+    %c1 = constant 1 : index
+    %d0 = dim %0, %c0
+    %d1 = dim %0, %c1
+    scf.for %iv0 = ... {
+      scf.for %iv1 = ... {
+        %a = subi %iv0, %c1 : index
+        %b = subi %iv1, %c2 : index
+        %cond1_y = cmpi "slt", %a, %d0 : (index, index) -> i1
+        %cond2_y = cmpi "sge", %a, %c0 : (index, index) -> i1
+        %cond_y = and %cond1_y, %cond2_y : i1
+        %cond1_x = cmpi "slt", %b, %d1 : (index, index) -> i1
+        %cond2_x = cmpi "sge", %b, %c0 : (index, index) -> i1
+        %cond_x = and %cond1_x, %cond2_x : i1
+        %cond = and %cond_x, %cond_y : i1
+        %2 = scf.if %cond -> (f32) {
+          %t = load %1[%a, %b] : f32
+          scf.yield %t : f32
+        } else {
+          scf.yield %pad_value : f32
+        }
+      }
+    }
+    ```
+
+    Another valid lowering is to create an allocation for the result
+    of the pad and copy the `source` memref into a subview of the
+    allocation.
+
+    ```
+    %c0 = constant 0 : index
+    %c1 = constant 1 : index
+    %c2 = constant 2 : index
+    %c3 = constant 3 : index
+    %d0 = dim %0, %c0
+    %d1 = dim %0, %c1
+    %t1 = addi %c1, %d0 : index
+    %t2 = addi %t1, %c2 : index
+    %t3 = addi %c2, %d1 : index
+    %t4 = addi %t3, %c3 : index
+    %1 = alloc(%t2, %t4) : memref<?x?xf32>
+    %2 = subview %0[%c1, %c2][%d0, %d1][1, 1] : memref<?x?xf32> into memref<?x?xf32, #map1>
+    linalg.copy(%0, %2)
+    ```
+
+    For the result, the copy would have to be done after all its uses.
+  }];
+
+  let arguments = (ins
+    AnyMemRef:$source,
+    I64ElementsAttr:$lowPadding,
+    I64ElementsAttr:$highPadding);
+
+  let regions = (region AnyRegion:$region);
+
+  let results = (outs AnyMemRef:$result);
+}
+
 def Linalg_RangeOp :
     Linalg_Op<"range", [NoSideEffect]>,
     Arguments<(ins Index:$min, Index:$max, Index:$step)>,
     Results<(outs Range)> {
   let summary = "Create a `range` type value, used to create `view`s";
   let description = [{
     The `linalg.range` op creates a `!linalg.range` from 3 values of type
     `index` that represent the min, max and step values of the `range`. This

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

if (viewType.getElementType() !=
              << (memrefArgIndex + 1)
              << " of the same type as elemental type of "
              << ((i < nInputViews) ? "input " : "output ")
              << "operand: " << viewType;
   }
   return success();
 }
 
+template <>
+LogicalResult BlockArgsVerifier<PadOp>::verify(PadOp op, Block &block) {
+  unsigned rank = op.getType().cast<ShapedType>().getRank();
+  if (block.getNumArguments() != rank)
+    return op.emitError("expected the block to have ") << rank << " arguments";
+
+  // Note: the number and type of yield values are checked in the YieldOp.
+  for (auto en : llvm::enumerate(block.getArgumentTypes())) {
+    if (!en.value().isIndex())
+      return op.emitOpError("expected block argument ")
+             << (en.index() + 1) << " to be an index";
+  }
+  return success();
+}
+
 template <typename GenericOpType>
 struct AnnotationsVerifier {
   static LogicalResult verify(GenericOpType op) { return success(); }
 };
 
 template <>
 LogicalResult AnnotationsVerifier<GenericOp>::verify(GenericOp op) {
   ArrayAttr sparseAttr = op.sparseAttr();
static LogicalResult verifyGenericOp(GenericOpType op) {
   return success();
 }
 
 static LogicalResult verify(GenericOp op) { return verifyGenericOp(op); }
 
 static LogicalResult verify(IndexedGenericOp op) { return verifyGenericOp(op); }
 
 //===----------------------------------------------------------------------===//
+// PadOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(PadOp op) {
+  ShapedType sourceType = op.source().getType().cast<ShapedType>();
+  // Check that the rank of the padding attributes is 1.
+  ShapedType lowPaddingType = op.lowPadding().getType();
+  ShapedType highPaddingType = op.highPadding().getType();
+  if (lowPaddingType.getRank() != 1)
+    return op.emitError("expected lowPadding to be of rank 1");
+  if (highPaddingType.getRank() != 1)
+    return op.emitError("expected highPadding to be of rank 1");
+  if (sourceType.getRank() != lowPaddingType.getShape()[0])
+    return op.emitError("expected size of lowPadding to match rank of source");
+  if (sourceType.getRank() != highPaddingType.getShape()[0]) {
+    return op.emitError("expected size of highPadding to match rank of source");
+  }
+
+  ShapedType resultType = op.result().getType().cast<ShapedType>();
+  if (sourceType.getRank() != resultType.getRank())
+    return op.emitError("expected result rank to match the rank of the source");
+
+  // Check that the shape matches. For static shape, shape of the output must be
+  // lowPadding + dim + highPadding.
+  auto lowPadding = op.lowPadding().getValues<int64_t>();
+  auto highPadding = op.highPadding().getValues<int64_t>();
+  auto checkAllPositive = [](int64_t v) { return v >= 0; };
+  if (!llvm::any_of(lowPadding, checkAllPositive))
+    return op.emitError("low padding values cannot be negetive");
+  if (!llvm::any_of(highPadding, checkAllPositive))
+    return op.emitError("high padding values cannot be negetive");
+
+  auto sourceShape = sourceType.getShape();
+  auto resultShape = resultType.getShape();
+  for (auto en : llvm::enumerate(llvm::zip(lowPadding, highPadding))) {
+    int dim = en.index();
+    if (sourceShape[dim] == ShapedType::kDynamicSize ||
+        resultShape[dim] == ShapedType::kDynamicSize)
+      continue;
+    int64_t low = std::get<0>(en.value());
+    int64_t high = std::get<1>(en.value());
+    int64_t expectedShape = sourceShape[dim] + low + high;
+    if (expectedShape != resultShape[dim]) {
+      return op.emitError("expected output shape to be (")
+             << low << " + " << sourceShape[dim] << " + " << high
+             << ") = " << expectedShape;
+    }
+  }
+
+  auto &region = op.region();
+  if (!llvm::hasSingleElement(region))
+    return op.emitOpError("expected region with 1 block");
+  if (failed(BlockArgsVerifier<PadOp>::verify(op, region.front())))
+    return failure();
+
+  return success();
+}
+
+Value PadOp::getViewSource() { return source(); }
+
+static ParseResult parseListOfOperands(OpAsmParser &parser,
+                                       OperationState &result,
+                                       StringRef attrName) {
+  if (failed(parser.parseLSquare()))
+    return failure();
+  if (succeeded(parser.parseOptionalRSquare()))
+    return success();
+
+  SmallVector<int64_t, 4> attrVals;
+  while (true) {
+    OpAsmParser::OperandType operand;
+    IntegerAttr attr;
+    if (failed(parser.parseAttribute<IntegerAttr>(attr)))
+      return parser.emitError(parser.getNameLoc()) << "expected integer";
+    attrVals.push_back(attr.getInt());
+    if (succeeded(parser.parseOptionalComma()))
+      continue;
+    if (failed(parser.parseRSquare()))
+      return failure();
+    break;
+  }
+  auto arrayAttr = parser.getBuilder().getI64TensorAttr(attrVals);
+  result.addAttribute(attrName, arrayAttr);
+  return success();
+}
+
+static ParseResult parsePadOp(OpAsmParser &parser, OperationState &result) {
+  OpAsmParser::OperandType baseInfo;
+  SmallVector<OpAsmParser::OperandType, 8> operands;
+  SmallVector<Type, 8> types;
+  if (parser.parseOperand(baseInfo))
+    return failure();
+
+  if (parseListOfOperands(parser, result, "lowPadding") ||
+      parseListOfOperands(parser, result, "highPadding"))
+    return failure();
+
+  SmallVector<OpAsmParser::OperandType, 8> regionOperands;
+  std::unique_ptr<Region> region = std::make_unique<Region>();
+  SmallVector<Type, 8> operandTypes, regionTypes;
+  if (parser.parseRegion(*region, regionOperands, regionTypes))
+    return failure();
+  result.addRegion(std::move(region));
+
+  Type srcType, dstType;
+  if (parser.parseColonType(srcType) || parser.parseKeywordType("to", dstType))
+    return failure();
+
+  if (parser.resolveOperand(baseInfo, srcType, result.operands))
+    return failure();
+
+  return parser.addTypeToList(dstType, result.types);
+}
+
+static void printListOfOperands(OpAsmPrinter &p, DenseIntElementsAttr attr) {
+  p << '[';
+  llvm::interleaveComma(attr, p, [&](APInt a) { p << a.getSExtValue(); });
+  p << ']';
+}
+
+static void print(OpAsmPrinter &p, PadOp op) {
+  p << op->getName().getStringRef() << ' ';
+  p << op.source();
+  printListOfOperands(p, op.lowPadding());
+  p << ' ';
+  printListOfOperands(p, op.highPadding());
+  p.printRegion(op.region());
+  p << " : " << op.source().getType() << " to " << op.getType();
+}
+
+//===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
 /// Collapse reassociation maps that are used in pair of reshape ops where one
 /// is a producer and other is the consumer. Only valid to use this method when
 /// both the producer and consumer are collapsing dimensions or both are
 /// expanding dimensions.
 ///

 static LogicalResult verify(linalg::YieldOp op) {
   auto *parentOp = op->getParentOp();
   if (parentOp->getNumRegions() != 1 || parentOp->getRegion(0).empty())
     return op.emitOpError("expected single non-empty parent region");
 
   if (auto linalgOp = dyn_cast<LinalgOp>(parentOp))
     return verifyYield(op, cast<LinalgOp>(parentOp));
 
+  if (auto padOp = dyn_cast<linalg::PadOp>(parentOp)) {
+    return success(op.getNumOperands() == 1 &&
+                   op.getOperand(0).getType() ==
+                       padOp.getType().cast<ShapedType>().getElementType());
+  }
+
   return op.emitOpError("expected parent op with LinalgOp interface");
 }
 
 /////// Operations corresponding to library calls defined with Tablegen ////////
 
 void FillOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {

mlir/test/Dialect/Linalg/invalid.mlir

 
 func @matching_inits(%m: memref<?x?xf32>, %t: tensor<?x?xf32>) {
   // expected-error @+1 {{expected init tensor #0 of the same type as result #0}}
   %res = linalg.matmul ins(%m, %m : memref<?x?xf32>, memref<?x?xf32>)
                       init(%t : tensor<?x?xf32>)
                         -> tensor<?xf32>
   return
 }
+
+// -----
+
+func @pad_mismatch_rank(%arg0: memref<?x?x?xf32>, %arg1: f32) -> memref<?x?x?xf32> {
+  // expected-error @+1 {{expected size of lowPadding to match rank of source}}
+  %0 = linalg.padded_view %arg0[1, 2] [2, 2, 3] {
+  ^bb0(%arg2: index, %arg3: index):  // no predecessors
+    linalg.yield %arg1 : f32
+  } : memref<?x?x?xf32> to memref<?x?x?xf32>
+  return %0 : memref<?x?x?xf32>
+}
+
+// -----
+
+func @pad_mismatch_rank(%arg0: memref<?x?x?xf32>, %arg1: f32) -> memref<?x?x?xf32> {
+  // expected-error @+1 {{expected size of highPadding to match rank of source}}
+  %0 = linalg.padded_view %arg0[2, 1, 2] [2, 3] {
+  ^bb0(%arg2: index, %arg3: index):  // no predecessors
+    linalg.yield %arg1 : f32
+  } : memref<?x?x?xf32> to memref<?x?x?xf32>
+  return %0 : memref<?x?x?xf32>
+}
+
+// -----
+
+func @pad_result_type(%arg0: memref<?x4xi32>, %arg1: i32) -> memref<?x8xi32> {
+  // expected-error @+1 {{expected output shape to be (2 + 4 + 3) = 9}}
+  %0 = linalg.padded_view %arg0[1, 2] [2, 3] {
+  ^bb0(%arg2: index, %arg3: index):  // no predecessors
+    linalg.yield %arg1 : i32
+  } : memref<?x4xi32> to memref<?x8xi32>
+  return %0 : memref<?x8xi32>
+}
+
+// -----
+
+func @pad_block_args(%arg0: memref<?x4xi32>, %arg1: i32) -> memref<?x9xi32> {
+  // expected-error @+1 {{op expected block argument 1 to be an index}}
+  %0 = linalg.padded_view %arg0[1, 2] [2, 3] {
+  ^bb0(%arg2: i32, %arg3: i32):  // no predecessors
+    linalg.yield %arg1 : i32
+  } : memref<?x4xi32> to memref<?x9xi32>
+  return %0 : memref<?x9xi32>
+}
+
+// -----
+
+func @pad_mismatch_rank(%arg0: memref<?x4xi32>, %arg1: i32) -> memref<?x?x9xi32> {
+  // expected-error @+1 {{expected result rank to match the rank of the source}}
+  %0 = linalg.padded_view %arg0[1, 2] [2, 3] {
+  ^bb0(%arg2: index, %arg3: index):  // no predecessors
+    linalg.yield %arg1 : i32
+  } : memref<?x4xi32> to memref<?x?x9xi32>
+  return %0 : memref<?x?x9xi32>
+}

mlir/test/Dialect/Linalg/roundtrip.mlir

 // RUN: mlir-opt -split-input-file %s | FileCheck %s
 // | mlir-opt | FileCheck %s
 
 // TODO: Re-enable LLVM lowering test after IndexedGenericOp is lowered.
 //
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // DISABLED: mlir-opt %s --convert-linalg-to-llvm -o=/dev/null 2>&1
 
+func @pad_dynamic(%arg0: memref<?x?xf32>, %pad_value: f32) -> memref<?x?xf32> {
+  %0 = linalg.padded_view %arg0[1, 2] [2, 3] {
+    ^bb0(%arg1 : index, %arg2 : index):
+      linalg.yield %pad_value : f32
+    } : memref<?x?xf32> to memref<?x?xf32>
+  return %0 : memref<?x?xf32>
+}
+// CHECK-LABEL: func @pad_dynamic
+//       CHECK:   linalg.padded_view %{{.*}}[1, 2] [2, 3]
+//       CHECK:    : memref<?x?xf32> to memref<?x?xf32>
+
+// -----
+
+func @pad_static(%arg0: memref<3x4xf32>, %pad_value: f32) -> memref<6x9xf32> {
+  %0 = linalg.padded_view %arg0[1, 2] [2, 3] {
+    ^bb0(%arg1 : index, %arg2 : index):
+      linalg.yield %pad_value : f32
+    } : memref<3x4xf32> to memref<6x9xf32>
+  return %0 : memref<6x9xf32>
+}
+// CHECK-LABEL: func @pad_static
+//       CHECK:   linalg.padded_view %{{.*}}[1, 2] [2, 3]
+//       CHECK:    : memref<3x4xf32> to memref<6x9xf32>
+
+// -----
+
 func @range(%arg0: index, %arg1: index, %arg2: index) {
   %0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range
   return
 }
 // CHECK-LABEL: func @range(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 //  CHECK-NEXT:  linalg.range %{{.*}} : %{{.*}} : %{{.*}} : !linalg.range
 
 // -----