[mlir][linalg] Tighter StructuredOp Verification.

[gysit]

Summary

Verify the number of results matches exactly the number of output tensors. Simplify the FillOp verification since part of it got redundant.

[gysit]

Remove additional TODO.

[gysit]

Rebase.

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

LogicalResult mlir::linalg::detail::verifyStructuredOpInterface(Operation *op) {
   // LinalgOp at the moment. For now this will have to be a special op until we
   // have output shape operands that are not tensors.
   int64_t numInputs = linalgOp.getNumInputs();
   int64_t numOutputs = linalgOp.getNumOutputs();
   if (numOutputs == 0)
     return op->emitOpError("expected at least one output operand");
   if (failed(OpTrait::impl::verifyNOperands(op, numInputs + numOutputs)))
     return failure();
-  // Should have at least one output tensor per result tensor.
-  // Can also have outbut buffers that do not correspond to results.
-  if (op->getNumResults() > linalgOp.getOutputTensorOperands().size())
-    return op->emitOpError("unexpected #results > #outputs");
+  // Verify the number of results matches the number of output tensors.
+  if (op->getNumResults() != linalgOp.getOutputTensorOperands().size())
+    return op->emitOpError("expected the number of results (")
+           << op->getNumResults()
+           << ") to be equal to the number of output tensors ("
+           << linalgOp.getOutputTensorOperands().size() << ")";
 
   // Before checking indexing maps, we need to make sure the attributes
   // referenced by it are valid.
   if (linalgOp.hasDynamicIndexingMaps())
     if (failed(linalgOp.verifyIndexingMapRequiredAttributes()))
       return failure();
 
   // All input/output operands must be indexed.
LogicalResult mlir::linalg::detail::verifyStructuredOpInterface(Operation *op) {
   // TODO: relax when mixed-mode needs to pass verification.
   if (!linalgOp.getOutputBufferOperands().empty() &&
       !linalgOp.getOutputTensorOperands().empty())
     return op->emitOpError(
         "expected output operands to all have tensor type or "
         "all have buffer type");
 
   for (OpOperand *opOperand : linalgOp.getOutputTensorOperands()) {
-    // TODO: Enforce one output tensor per result?
-    if (opOperand->getOperandNumber() - linalgOp.getNumInputs() >=
-        linalgOp->getNumResults())
-      continue;
     OpResult result = linalgOp.getTiedOpResult(opOperand);
     if (result.getType() != opOperand->get().getType())
       return op->emitOpError("expected type of operand #")
              << opOperand->getOperandNumber() << " ("
              << opOperand->get().getType() << ")"
              << " to match type of corresponding result (" << result.getType()
              << ")";
   }

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

 /// FillOp region is elided when printing.
 void printFillOpRegion(OpAsmPrinter &, Operation *, Region &, Type, Type) {}
 
 static LogicalResult verify(FillOp op) {
   OpOperand *output = op.getOutputOperand(0);
   Type fillType = op.value().getType();
   if (getElementTypeOrSelf(output->get()) != fillType)
     return op.emitOpError("expects fill type to match view elemental type");
-  if (!op.getNumResults() && !output->get().getType().isa<MemRefType>()) {
-    return op.emitOpError(
-        "expected fill op with no result value to use memref type");
-  }
   return success();
 }
 
 void FillOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
   if (output().getType().isa<MemRefType>())
     effects.emplace_back(MemoryEffects::Write::get(), output(),

mlir/test/Dialect/Linalg/invalid.mlir

func @pad_yield_type(%arg0: tensor<?x4xi32>, %arg1: i8) -> tensor<?x9xi32> {
   return %0 : tensor<?x9xi32>
 }
 
 // -----
 
 func @illegal_fill_tensor_no_return(%arg0 : index, %arg1 : index, %arg2 : f32)
 {
   %0 = linalg.init_tensor [%arg0, %arg1] : tensor<?x?xf32>
-  // expected-error @+1 {{expected fill op with no result value to use memref type}}
+  // expected-error @+1 {{expected the number of results (0) to be equal to the number of output tensors (1)}}
   linalg.fill(%arg2, %0) : f32, tensor<?x?xf32>
 }
 
 // -----
 
 func @illegal_fill_memref_with_return(%arg0 : memref<?x?xf32>, %arg1 : f32) -> memref<?x?xf32>
 {
-  // expected-error @+1 {{unexpected #results > #outputs}}
+  // expected-error @+1 {{expected the number of results (1) to be equal to the number of output tensors (0)}}
   %0 = linalg.fill(%arg1, %arg0) : f32, memref<?x?xf32> -> memref<?x?xf32>
   return %0 : memref<?x?xf32>
 }
 
 // -----
 
 func @illegal_fill_memref_with_tensor_return
   (%arg0 : memref<?x?xf32>, %arg1 : f32) -> tensor<?x?xf32>
 {
-  // expected-error @+1 {{unexpected #results > #outputs}}
+  // expected-error @+1 {{expected the number of results (1) to be equal to the number of output tensors (0)}}
   %0 = linalg.fill(%arg1, %arg0) : f32, memref<?x?xf32> -> tensor<?x?xf32>
   return %0 : tensor<?x?xf32>
 }
 
 // -----
 
 func @illegal_fill_tensor_with_memref_return
   (%arg0 : tensor<?x?xf32>, %arg1 : f32) -> memref<?x?xf32>