[mlir][CAPI] Include anchor op in mlirParsePassPipeline

[rkayaith]

Summary

The pipeline string must now include the pass manager's anchor op. This
makes the parse API properly roundtrip the printed form of a pass
manager. Since this is already an API break, I also added an extra
callback argument which is used for reporting errors.

The old functionality of appending to an existing pass manager is
available through mlirOpPassManagerAddPipeline.

[rkayaith]

description

[rkayaith]

mlir/include/mlir-c/Pass.h

129–132

Maybe this should return an MlirOpPassManager instead now? Though that would require adding something like

// create a PassManager from `pm` and delete it
MlirPassManager mlirPassManagerCreateFromOwnedOpPassManager(MlirContext ctx, MlirOpPassManager pm)

for constructing a PassManager from the result

[mehdi_amini]

mlir/include/mlir-c/Pass.h

129–132

Maybe this should return an MlirOpPassManager instead

How would you handle the LogicalResult?

[rkayaith]

mlir/include/mlir-c/Pass.h

129–132

it could return a null object on error, and we would need to add mlirOpPassManagerIsNull, similar to mlirPassManagerIsNull.

or we could use an output argument instead, i.e.

// passManager is an output argument
MlirLogicalResult mlirParsePassPipeline(MlirOpPassManager *passManager, MlirStringRef pipeline,  MlirStringCallback callback, void *userData)

[ftynse]

Can we somehow test that the error messages are indeed redirected?

[rkayaith]

add test for error capture

mlir/include/mlir-c/Pass.h

 
 /// Print a textual MLIR pass pipeline by sending chunks of the string
 /// representation and forwarding `userData to `callback`. Note that the
 /// callback may be called several times with consecutive chunks of the string.
 MLIR_CAPI_EXPORTED void mlirPrintPassPipeline(MlirOpPassManager passManager,
                                               MlirStringCallback callback,
                                               void *userData);
 
-/// Parse a textual MLIR pass pipeline and add it to the provided OpPassManager.
-
+/// Parse a textual MLIR pass pipeline and assign it to the provided
+/// OpPassManager. If parsing fails an error message is reported using the
+/// provided callback.
 MLIR_CAPI_EXPORTED MlirLogicalResult
-mlirParsePassPipeline(MlirOpPassManager passManager, MlirStringRef pipeline);
+mlirParsePassPipeline(MlirOpPassManager passManager, MlirStringRef pipeline,
+                      MlirStringCallback callback, void *userData);
 
 //===----------------------------------------------------------------------===//
 // External Pass API.
 //
 // This API allows to define passes outside of MLIR, not necessarily in
 // C++, and register them with the MLIR pass management infrastructure.
 //
 //===----------------------------------------------------------------------===//
 

mlir/lib/CAPI/IR/Pass.cpp

 
 void mlirPrintPassPipeline(MlirOpPassManager passManager,
                            MlirStringCallback callback, void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(passManager)->printAsTextualPipeline(stream);
 }
 
 MlirLogicalResult mlirParsePassPipeline(MlirOpPassManager passManager,
-                                        MlirStringRef pipeline) {
-  // TODO: errors are sent to std::errs() at the moment, we should pass in a
-  // stream and redirect to a diagnostic.
-  return wrap(mlir::parsePassPipeline(unwrap(pipeline), *unwrap(passManager)));
+                                        MlirStringRef pipeline,
+                                        MlirStringCallback callback,
+                                        void *userData) {
+  detail::CallbackOstream stream(callback, userData);
+  FailureOr<OpPassManager> pm = parsePassPipeline(unwrap(pipeline), stream);
+  if (succeeded(pm))
+    *unwrap(passManager) = std::move(*pm);
+  return wrap(pm);
 }
 
 //===----------------------------------------------------------------------===//
 // External Pass API.
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 class ExternalPass;

mlir/test/CAPI/pass.c

 
 void testParsePassPipeline() {
   MlirContext ctx = mlirContextCreate();
   MlirPassManager pm = mlirPassManagerCreate(ctx);
   // Try parse a pipeline.
   MlirLogicalResult status = mlirParsePassPipeline(
       mlirPassManagerGetAsOpPassManager(pm),
       mlirStringRefCreateFromCString(
-          "builtin.module(func.func(print-op-stats{json=false}))"));
+          "builtin.module(func.func(print-op-stats{json=false}))"),
+      printToStderr, NULL);
   // Expect a failure, we haven't registered the print-op-stats pass yet.
   if (mlirLogicalResultIsSuccess(status)) {
     fprintf(
         stderr,
         "Unexpected success parsing pipeline without registering the pass\n");
     exit(EXIT_FAILURE);
   }
   // Try again after registrating the pass.
   mlirRegisterTransformsPrintOpStats();
   status = mlirParsePassPipeline(
       mlirPassManagerGetAsOpPassManager(pm),
       mlirStringRefCreateFromCString(
-          "builtin.module(func.func(print-op-stats{json=false}))"));
+          "builtin.module(func.func(print-op-stats{json=false}))"),
+      printToStderr, NULL);
   // Expect a failure, we haven't registered the print-op-stats pass yet.
   if (mlirLogicalResultIsFailure(status)) {
     fprintf(stderr,
             "Unexpected failure parsing pipeline after registering the pass\n");
     exit(EXIT_FAILURE);
   }
 
-  //      CHECK: Round-trip: builtin.module(
-  // CHECK-SAME:   builtin.module(func.func(print-op-stats{json=false}))
-  // CHECK-SAME: )
+  // CHECK: Round-trip: builtin.module(func.func(print-op-stats{json=false}))
   fprintf(stderr, "Round-trip: ");
   mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr,
                         NULL);
   fprintf(stderr, "\n");
 
   // Try appending a pass:
   status = mlirOpPassManagerAddPipeline(
       mlirPassManagerGetAsOpPassManager(pm),
       mlirStringRefCreateFromCString("func.func(print-op-stats{json=false})"),
       printToStderr, NULL);
   if (mlirLogicalResultIsFailure(status)) {
     fprintf(stderr, "Unexpected failure appending pipeline\n");
     exit(EXIT_FAILURE);
   }
   //      CHECK: Appended: builtin.module(
-  // CHECK-SAME:   builtin.module(func.func(print-op-stats{json=false})),
+  // CHECK-SAME:   func.func(print-op-stats{json=false}),
   // CHECK-SAME:   func.func(print-op-stats{json=false})
   // CHECK-SAME: )
   fprintf(stderr, "Appended: ");
   mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr,
                         NULL);
   fprintf(stderr, "\n");
 
   mlirPassManagerDestroy(pm);
   mlirContextDestroy(ctx);
 }
 
 void testParseErrorCapture() {
   // CHECK-LABEL: testParseErrorCapture:
   fprintf(stderr, "\nTEST: testParseErrorCapture:\n");
 
   MlirContext ctx = mlirContextCreate();
   MlirPassManager pm = mlirPassManagerCreate(ctx);
   MlirOpPassManager opm = mlirPassManagerGetAsOpPassManager(pm);
   MlirStringRef invalidPipeline = mlirStringRefCreateFromCString("invalid");
 
+  // CHECK: mlirParsePassPipeline:
+  // CHECK: expected pass pipeline to be wrapped with the anchor operation type
+  fprintf(stderr, "mlirParsePassPipeline:\n");
+  if (mlirLogicalResultIsSuccess(
+          mlirParsePassPipeline(opm, invalidPipeline, printToStderr, NULL)))
+    exit(EXIT_FAILURE);
+  fprintf(stderr, "\n");
+
   // CHECK: mlirOpPassManagerAddPipeline:
   // CHECK: 'invalid' does not refer to a registered pass or pass pipeline
   fprintf(stderr, "mlirOpPassManagerAddPipeline:\n");
   if (mlirLogicalResultIsSuccess(mlirOpPassManagerAddPipeline(
           opm, invalidPipeline, printToStderr, NULL)))
     exit(EXIT_FAILURE);
   fprintf(stderr, "\n");
 
   // Make sure all output is going through the callback.
   // CHECK: dontPrint: <>
   fprintf(stderr, "dontPrint: <");
   if (mlirLogicalResultIsSuccess(
+          mlirParsePassPipeline(opm, invalidPipeline, dontPrint, NULL)))
+    exit(EXIT_FAILURE);
+  if (mlirLogicalResultIsSuccess(
           mlirOpPassManagerAddPipeline(opm, invalidPipeline, dontPrint, NULL)))
     exit(EXIT_FAILURE);
   fprintf(stderr, ">\n");
 
   mlirPassManagerDestroy(pm);
   mlirContextDestroy(ctx);
 }