[mlir] Add std.source and std.sink ops.

[silvas]

Summary

These ops are useful for test case reduction and test writing.

Example:

mlir
%0 = source : i1
sink %0 : i1

%a, %b = source : i1, i2
sink %a, %b : i1, i2

[silvas]

Make canonicalizer a bit easier to read.

[mehdi_amini]

I really don't feel this belongs to the standard dialect. This is very light in motivation right now. Can you expand?

[mehdi_amini]

Can you use the test dialect maybe?

[bondhugula]

Could test.produce, test.consume be better names for these? Could you add a couple more lines to the commit summary? I think you also need to say in the op description that these are no ops?

[ftynse]

+1 to not putting these in the standard dialect. We didn't want a generic cast operation precisely because it could create values with unclear semantics. I would rather have it in a dedicated dialect rather than in the Test dialect. If you intend to build a bugpoint analog, you'd end up with a dependency of tools/bugpoint on test/lib, which sounds awkward.

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

2167

You can omit this line

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

let description = [{
     %1 = constant 5 : i8                       // %1 is 0b00000101
     %2 = constant 3 : i8
     %3 = shift_left %1, %2 : (i8, i8) -> i8    // %3 is 0b00101000
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// SinkOp
+//===----------------------------------------------------------------------===//
+
+def SinkOp : Std_Op<"sink"> {
+  let summary = "sinks an arbitrary value";
+  let description = [{
+    Consumes an SSA value of any type.
+
+    This op has no runtime semantics and is mainly useful as a structural
+    placeholder to maintain IR validity outside a typical compilation flow,
+    such as during test case reduction.
+
+    ```mlir
+    sink %0 : i1
+    sink %1 : !my_dialect.my_type
+    sink %0, %1 : i1, !my_dialect.my_type
+    ```
+  }];
+  let arguments = (ins Variadic<AnyType>:$operands);
+  let results = (outs);
+
+  let assemblyFormat = "$operands attr-dict `:` type($operands)";
+
+  // This op is fully verified by its declarative specification.
+  let verifier = ?;
+}
+
+
+//===----------------------------------------------------------------------===//
 // SignedDivIOp
 //===----------------------------------------------------------------------===//
 
 def SignedDivIOp : IntArithmeticOp<"divi_signed"> {
   let summary = "signed integer division operation";
   let description = [{
     Syntax:
 
let extraClassDeclaration = [{
     /// the operation.
     static bool areCastCompatible(Type a, Type b);
   }];
 
   let hasFolder = 0;
 }
 
 //===----------------------------------------------------------------------===//
+// SourceOp
+//===----------------------------------------------------------------------===//
+
+def SourceOp : Std_Op<"source", [NoSideEffect]> {
+  let summary = "sources a value of a given type";
+  let description = [{
+    Creates an SSA value of the prescribed type.
+
+    This op has no runtime semantics and is mainly useful as a structural
+    placeholder to maintain IR validity outside a typical compilation flow,
+    such as during test case reduction.
+
+    ```mlir
+    %0 = source : i1
+    %1 = source : !my_dialect.my_type
+    %a, %b, %c = source : i1, i2, i3
+    ```
+  }];
+
+  let arguments = (ins);
+  let results = (outs Variadic<AnyType>:$results);
+
+  let assemblyFormat = "attr-dict `:` type($results)";
+
+  // This op is fully verified by its declarative specification.
+  let verifier = ?;
+
+  let hasCanonicalizer = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
 def SplatOp : Std_Op<"splat", [NoSideEffect,
      TypesMatchWith<"operand type matches element type of result",
                     "aggregate", "input",
                     "$_self.cast<ShapedType>().getElementType()">]> {
   let summary = "splat or broadcast operation";

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

 //===----------------------------------------------------------------------===//
 
 // sitofp is applicable from integer types to float types.
 bool SIToFPOp::areCastCompatible(Type a, Type b) {
   return a.isSignlessInteger() && b.isa<FloatType>();
 }
 
 //===----------------------------------------------------------------------===//
+// SourceOp
+//===----------------------------------------------------------------------===//
+
+namespace {
+class RemoveUnusedSourceOpOperands : public OpRewritePattern<SourceOp> {
+public:
+  using OpRewritePattern::OpRewritePattern;
+  LogicalResult matchAndRewrite(SourceOp op,
+                                PatternRewriter &rewriter) const override {
+    auto results = llvm::to_vector<6>(op.getResults());
+    llvm::erase_if(results, [](Value v) { return v.use_empty(); });
+    if (results.size() == op.getNumResults())
+      return success();
+    auto newResultTypes = llvm::to_vector<6>(
+        llvm::map_range(results, [](Value v) { return v.getType(); }));
+    auto newOp = rewriter.create<SourceOp>(op.getLoc(), newResultTypes);
+    for (auto t : llvm::zip(results, newOp.getResults()))
+      std::get<0>(t).replaceAllUsesWith(std::get<1>(t));
+    rewriter.eraseOp(op);
+    return success();
+  }
+};
+} // namespace
+
+void SourceOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                           MLIRContext *context) {
+  results.insert<RemoveUnusedSourceOpOperands>(context);
+}
+
+//===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(SplatOp op) {
   // TODO: we could replace this by a trait.
   if (op.getOperand().getType() !=
       op.getType().cast<ShapedType>().getElementType())
     return op.emitError("operand should be of elemental type of result type");

mlir/test/Dialect/Standard/source-sink.mlir

+// RUN: mlir-opt %s -canonicalize | FileCheck %s --dump-input=fail
+
+// CHECK-LABEL: func @canonicalize_does_not_remove_used_source_values
+func @canonicalize_does_not_remove_used_source_values() {
+  // CHECK: source : i1, i2, i3
+  %1, %2, %3 = source : i1, i2, i3
+  sink %1, %2, %3 : i1, i2, i3
+  return
+}
+
+// CHECK-LABEL: func @canonicalize_removes_unused_source_value
+func @canonicalize_removes_unused_source_value() {
+  // CHECK: source : i1, i3
+  %1, %2, %3 = source : i1, i2, i3
+  sink %1, %3 : i1, i3
+  return
+}
+
+// CHECK-LABEL: func @source_can_be_trivially_deleted
+func @source_can_be_trivially_deleted() {
+  // CHECK-NOT: source : i1
+  %0 = source : i1
+  return
+}
+
+// CHECK-LABEL: func @sink_cannot_be_trivially_deleted
+func @sink_cannot_be_trivially_deleted(%arg0: i1) {
+  sink %arg0 : i1
+  return
+}