[MLIR] Modify Partial op conversion mode to optionally track all non-legalizable operations.

[lucyrfox]

Summary

There are three op conversion modes: Partial, Full, and Analysis. This change modifies the Partial mode to optionally take a set of non-legalizable ops. If this parameter is specified, all ops that are not legalizable (i.e. would cause full conversion to fail) are tracked throughout the partial legalization.

[lucyrfox]

Took a first pass at this, but I'm open to different ways of approaching this change. At I've written it now, the basic idea of the Analysis conversion is "we're performing a partial conversion and emitting warnings along the way for any ops that would fail to legalize in a full conversion". Success is returned as long as the partial conversion succeeds. I did it this way because returning failure outright means that the partially converted IR doesn't get emitted, which is useful for debugging.

However, an implication of this is that if the legalization did fully succeed, we don't know that based on the Analysis conversion. As a result, I foresee a lot of users running an Analysis conversion immediately followed by a Full conversion, thus incurring an unnecessary pass over the IR. So ideally, this would return success/failure for the full conversion while still outputting the partially converted IR in the failure case.

What do you think?

[lucyrfox]

Minor formatting change.

[rriddle]

In D78788#2001142, @lucyrfox wrote:

Took a first pass at this, but I'm open to different ways of approaching this change. At I've written it now, the basic idea of the Analysis conversion is "we're performing a partial conversion and emitting warnings along the way for any ops that would fail to legalize in a full conversion". Success is returned as long as the partial conversion succeeds. I did it this way because returning failure outright means that the partially converted IR doesn't get emitted, which is useful for debugging.

Before answering, please note that we do not base these decisions based on debugging. What the result is depends on what the user intends to do with the result.

However, an implication of this is that if the legalization did fully succeed, we don't know that based on the Analysis conversion. As a result, I foresee a lot of users running an Analysis conversion immediately followed by a Full conversion, thus incurring an unnecessary pass over the IR. So ideally, this would return success/failure for the full conversion while still outputting the partially converted IR in the failure case.

Seems like the user can easily tell if the conversion was completely successful by checking if the set of unlegalized operations is empty?

What do you think?

We can change analysis conversion to whatever we want, but the main question is what are you doing with the information? What happens after the analysis conversion and what do you want to convey? We may end up with different types of analysis conversions based on the answer to that question. For example, the original envisioning for this was that a user would performs analysis conversions targeting different backends to detail which parts of the subgraph were really supported for a specific target. In that type of mode you don't want to do any conversions, because you want to splice the original graph based on the analysis. It seems that the use case you are targeting is different. For your use case, what is the pipeline that you are envisioning and how does an analysis conversion fit into it?

mlir/lib/Transforms/DialectConversion.cpp

1601

I'm not sure we always want warnings here, seems like more of a DEBUG log. If a user is relying on an analysis conversion to help slice code that is supported by different backends, they may not care that certain operations weren't converted.

[mehdi_amini]

mlir/lib/Transforms/DialectConversion.cpp

1598

Isn't the mode necessarily Partial/Analysis here?

1603

Isn't this something we'd want to track even in "Partial" mode?

It seems like the difference between Partial and Analysis overall is about whether the conversion is performed or not. Anything else should be uniform.
Partial vs Full is that the latter is aborting early and so does not need to accumulate the unlegalizableOps.

1605

Do we need to warn here?
Can we let signaling up to the client since we populate unlegalizableOps?

[lucyrfox]

[Note: I haven't made code changes in this iteration because I want to settle on an approach before refactoring this. For the same reason I'm leaving some comments unresolved for now.]

In D78788#2005904, @rriddle wrote:

In D78788#2001142, @lucyrfox wrote:

Took a first pass at this, but I'm open to different ways of approaching this change. At I've written it now, the basic idea of the Analysis conversion is "we're performing a partial conversion and emitting warnings along the way for any ops that would fail to legalize in a full conversion". Success is returned as long as the partial conversion succeeds. I did it this way because returning failure outright means that the partially converted IR doesn't get emitted, which is useful for debugging.

Before answering, please note that we do not base these decisions based on debugging. What the result is depends on what the user intends to do with the result.

However, an implication of this is that if the legalization did fully succeed, we don't know that based on the Analysis conversion. As a result, I foresee a lot of users running an Analysis conversion immediately followed by a Full conversion, thus incurring an unnecessary pass over the IR. So ideally, this would return success/failure for the full conversion while still outputting the partially converted IR in the failure case.

Seems like the user can easily tell if the conversion was completely successful by checking if the set of unlegalized operations is empty?

Good point, don't know why I didn't think of this :)

What do you think?

We can change analysis conversion to whatever we want, but the main question is what are you doing with the information? What happens after the analysis conversion and what do you want to convey? We may end up with different types of analysis conversions based on the answer to that question. For example, the original envisioning for this was that a user would performs analysis conversions targeting different backends to detail which parts of the subgraph were really supported for a specific target. In that type of mode you don't want to do any conversions, because you want to splice the original graph based on the analysis. It seems that the use case you are targeting is different. For your use case, what is the pipeline that you are envisioning and how does an analysis conversion fit into it?

Thanks for raising these points; this helps me better understand the current design of the analysis conversion mode.

My use case (for the TF XLA bridge) is the following: we want to perform a full conversion and for the result to be fully legalized (in that sense, the same as full legalization today). However, in the case that it fails, we want to (a) know all of the ops that failed to legalize and (b) have a partially legalized graph output. I suppose in that sense, this conversion mode I'm envisioning would act like full legalization in the success case but like partial legalization in the failure case.

After considering the comments here, I see a couple of possibilities (both of which would involve leaving the existing Analysis conversion mode as it is today):

(1) Modify the partial conversion mode to take an (optional?) unlegalizedOps set as input and populate it with all ops that fail to legalize.
-In our use case, this would mean always using the Partial conversion mode, and if what we really want is a Full conversion, checking whether that set of ops is empty. That's totally fine from the TF XLA perspective, but is that a level of indirection that ought to be in Core?
-Cons: API instability if the unlegalizedOps set is not optional.

(2) Add a new (2nd type of analysis) conversion mode that aligns with this use case.

I lean toward option (1), but I want to solicit some more thoughts before making the code change.

mlir/lib/Transforms/DialectConversion.cpp

1603

Isn't this something we'd want to track even in "Partial" mode?

I think this is a good idea and aligns with option (1) I describe in the larger comment on this reply.

It seems like the difference between Partial and Analysis overall is about whether the conversion is performed or not. Anything else should be uniform.

This is true with Analysis mode as it is today, but this patch (in its current state) makes it such that both Partial and Analysis mode perform the conversion. The key difference is whether or not the unlegalizable ops are collected in that set.

Partial vs Full is that the latter is aborting early and so does not need to accumulate the unlegalizableOps.

This is the difference between Analysis and Full. Presently, Partial doesn't accumulate the unlegalizableOps, either.

[rriddle]

I lean toward option (1), but I want to solicit some more thoughts before making the code change.

(1) seems like a fine option to add.

[lucyrfox]

Modify Partial conversion mode (instead of Analysis mode) to take an optional parameter to store non-legalizable ops.

[lucyrfox]

mlir/lib/Transforms/DialectConversion.cpp

1601

Removed these warnings.

1605

Agreed. Changed.

[mehdi_amini]

mlir/include/mlir/Transforms/DialectConversion.h

669

Just a nit, but I believe that if you use backticks ` to refer to arguments then doxygen link these.

[lucyrfox]

Small formatting fix.

mlir/include/mlir/Transforms/DialectConversion.h

 //===----------------------------------------------------------------------===//
 
 /// Below we define several entry points for operation conversion. It is
 /// important to note that the patterns provided to the conversion framework may
 /// have additional constraints. See the `PatternRewriter Hooks` section of the
 /// ConversionPatternRewriter, to see what additional constraints are imposed on
 /// the use of the PatternRewriter.
 
-/// Apply a partial conversion on the given operations, and all nested
+/// Apply a partial conversion on the given operations and all nested
 /// operations. This method converts as many operations to the target as
 /// possible, ignoring operations that failed to legalize. This method only
-/// returns failure if there are unreachable blocks in any of the regions nested
-/// within 'ops'. If 'converter' is provided, the signatures of blocks and
-/// regions are also converted.
+/// returns failure if there ops explicitly marked as illegal. If `converter` is
+/// provided, the signatures of blocks and regions are also converted.
+/// If an `unconvertedOps` set is provided, all operations that are found not
+/// to be legalizable to the given `target` are placed within that set. (Note
+/// that if there is an op explicitly marked as illegal, the conversion
+/// terminates and the `unconvertedOps` set will not necessarily be complete.)
 LLVM_NODISCARD LogicalResult
 applyPartialConversion(ArrayRef<Operation *> ops, ConversionTarget &target,
                        const OwningRewritePatternList &patterns,
-                       TypeConverter *converter = nullptr);
+                       TypeConverter *converter = nullptr,
+                       DenseSet<Operation *> *unconvertedOps = nullptr);
 LLVM_NODISCARD LogicalResult
 applyPartialConversion(Operation *op, ConversionTarget &target,
                        const OwningRewritePatternList &patterns,
-                       TypeConverter *converter = nullptr);
+                       TypeConverter *converter = nullptr,
+                       DenseSet<Operation *> *unconvertedOps = nullptr);
 
 /// Apply a complete conversion on the given operations, and all nested
 /// operations. This method returns failure if the conversion of any operation
 /// fails, or if there are unreachable blocks in any of the regions nested
 /// within 'ops'. If 'converter' is provided, the signatures of blocks and
 /// regions are also converted.
 LLVM_NODISCARD LogicalResult
 applyFullConversion(ArrayRef<Operation *> ops, ConversionTarget &target,

mlir/lib/Transforms/DialectConversion.cpp

 
 // This class converts operations to a given conversion target via a set of
 // rewrite patterns. The conversion behaves differently depending on the
 // conversion mode.
 struct OperationConverter {
   explicit OperationConverter(ConversionTarget &target,
                               const OwningRewritePatternList &patterns,
                               OpConversionMode mode,
-                              DenseSet<Operation *> *legalizableOps = nullptr)
-      : opLegalizer(target, patterns), mode(mode),
-        legalizableOps(legalizableOps) {}
+                              DenseSet<Operation *> *trackedOps = nullptr)
+      : opLegalizer(target, patterns), mode(mode), trackedOps(trackedOps) {}
 
   /// Converts the given operations to the conversion target.
   LogicalResult convertOperations(ArrayRef<Operation *> ops,
                                   TypeConverter *typeConverter);
 
 private:
   /// Converts an operation with the given rewriter.
   LogicalResult convert(ConversionPatternRewriter &rewriter, Operation *op);
 
   /// Converts the type signatures of the blocks nested within 'op'.
   LogicalResult convertBlockSignatures(ConversionPatternRewriter &rewriter,
                                        Operation *op);
 
   /// The legalizer to use when converting operations.
   OperationLegalizer opLegalizer;
 
   /// The conversion mode to use when legalizing operations.
   OpConversionMode mode;
 
-  /// A set of pre-existing operations that were found to be legalizable to the
-  /// target. This field is only used when mode == OpConversionMode::Analysis.
-  DenseSet<Operation *> *legalizableOps;
+  /// A set of pre-existing operations. When mode == OpConversionMode::Analysis,
+  /// this is populated with ops found to be legalizable to the target.
+  /// When mode == OpConversionMode::Partial, this is populated with ops found
+  /// *not* to be legalizable to the target.
+  DenseSet<Operation *> *trackedOps;
 };
 } // end anonymous namespace
 
 LogicalResult
 OperationConverter::convertBlockSignatures(ConversionPatternRewriter &rewriter,
                                            Operation *op) {
   // Check to see if type signatures need to be converted.
   if (!rewriter.getImpl().argConverter.typeConverter)
LogicalResult OperationConverter::convert(ConversionPatternRewriter &rewriter,
   // Legalize the given operation.
   if (failed(opLegalizer.legalize(op, rewriter))) {
     // Handle the case of a failed conversion for each of the different modes.
     /// Full conversions expect all operations to be converted.
     if (mode == OpConversionMode::Full)
       return op->emitError()
              << "failed to legalize operation '" << op->getName() << "'";
     /// Partial conversions allow conversions to fail iff the operation was not
-    /// explicitly marked as illegal.
-    if (mode == OpConversionMode::Partial && opLegalizer.isIllegal(op))
+    /// explicitly marked as illegal. If the user provided a nonlegalizableOps
+    /// set, non-legalizable ops are included.
+    if (mode == OpConversionMode::Partial) {
+      if (opLegalizer.isIllegal(op))
         return op->emitError()
                << "failed to legalize operation '" << op->getName()
                << "' that was explicitly marked illegal";
+      if (trackedOps)
+        trackedOps->insert(op);
+    }
   } else {
     /// Analysis conversions don't fail if any operations fail to legalize,
     /// they are only interested in the operations that were successfully
     /// legalized.
     if (mode == OpConversionMode::Analysis)
-      legalizableOps->insert(op);
+      trackedOps->insert(op);
 
     // If legalization succeeded, convert the types any of the blocks within
     // this operation.
     if (failed(convertBlockSignatures(rewriter, op)))
       return failure();
   }
   return success();
 }
return LegalizationInfo{LegalizationAction::Dynamic,
                             /*isRecursivelyLegal=*/false, unknownLegalityFn};
   return llvm::None;
 }
 
 //===----------------------------------------------------------------------===//
 // Op Conversion Entry Points
 //===----------------------------------------------------------------------===//
 
-/// Apply a partial conversion on the given operations, and all nested
+/// Apply a partial conversion on the given operations and all nested
 /// operations. This method converts as many operations to the target as
-/// possible, ignoring operations that failed to legalize.
+/// possible, ignoring operations that failed to legalize. This method only
+/// returns failure if there ops explicitly marked as illegal. If `converter` is
+/// provided, the signatures of blocks and regions are also converted.
+/// If an `unconvertedOps` set is provided, all operations that are found not
+/// to be legalizable to the given `target` are placed within that set. (Note
+/// that if there is an op explicitly marked as illegal, the conversion
+/// terminates and the `unconvertedOps` set will not necessarily be complete.)
 LogicalResult mlir::applyPartialConversion(
     ArrayRef<Operation *> ops, ConversionTarget &target,
-    const OwningRewritePatternList &patterns, TypeConverter *converter) {
-  OperationConverter opConverter(target, patterns, OpConversionMode::Partial);
+    const OwningRewritePatternList &patterns, TypeConverter *converter,
+    DenseSet<Operation *> *unconvertedOps) {
+  OperationConverter opConverter(target, patterns, OpConversionMode::Partial,
+                                 unconvertedOps);
   return opConverter.convertOperations(ops, converter);
 }
 LogicalResult
 mlir::applyPartialConversion(Operation *op, ConversionTarget &target,
                              const OwningRewritePatternList &patterns,
-                             TypeConverter *converter) {
+                             TypeConverter *converter,
+                             DenseSet<Operation *> *unconvertedOps) {
   return applyPartialConversion(llvm::makeArrayRef(op), target, patterns,
-                                converter);
+                                converter, unconvertedOps);
 }
 
 /// Apply a complete conversion on the given operations, and all nested
 /// operations. This method will return failure if the conversion of any
 /// operation fails.
 LogicalResult
 mlir::applyFullConversion(ArrayRef<Operation *> ops, ConversionTarget &target,
                           const OwningRewritePatternList &patterns,

mlir/test/Transforms/test-legalizer.mlir

 // RUN: mlir-opt -allow-unregistered-dialect -split-input-file -test-legalize-patterns -verify-diagnostics %s | FileCheck %s
 
 // CHECK-LABEL: verifyDirectPattern
 func @verifyDirectPattern() -> i32 {
   // CHECK-NEXT:  "test.legal_op_a"() {status = "Success"}
   %result = "test.illegal_op_a"() : () -> (i32)
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return %result : i32
 }
 
 // CHECK-LABEL: verifyLargerBenefit
 func @verifyLargerBenefit() -> i32 {
   // CHECK-NEXT:  "test.legal_op_a"() {status = "Success"}
   %result = "test.illegal_op_c"() : () -> (i32)
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return %result : i32
 }
 
 // CHECK-LABEL: func @remap_input_1_to_0()
 func @remap_input_1_to_0(i16)
 
 // CHECK-LABEL: func @remap_input_1_to_1(%arg0: f64)
 func @remap_input_1_to_1(%arg0: i64) {
   // CHECK-NEXT: "test.valid"{{.*}} : (f64)
   "test.invalid"(%arg0) : (i64) -> ()
 }
 
 // CHECK-LABEL: func @remap_call_1_to_1(%arg0: f64)
 func @remap_call_1_to_1(%arg0: i64) {
   // CHECK-NEXT: call @remap_input_1_to_1(%arg0) : (f64) -> ()
+  // expected-remark@+1 {{op 'std.call' is not legalizable}}
   call @remap_input_1_to_1(%arg0) : (i64) -> ()
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // CHECK-LABEL: func @remap_input_1_to_N({{.*}}f16, {{.*}}f16)
 func @remap_input_1_to_N(%arg0: f32) -> f32 {
  // CHECK-NEXT: "test.return"{{.*}} : (f16, f16) -> ()
  "test.return"(%arg0) : (f32) -> ()
 }
 
 // CHECK-LABEL: func @remap_input_1_to_N_remaining_use(%arg0: f16, %arg1: f16)
 func @remap_input_1_to_N_remaining_use(%arg0: f32) {
   // CHECK-NEXT: [[CAST:%.*]] = "test.cast"(%arg0, %arg1) : (f16, f16) -> f32
   // CHECK-NEXT: "work"([[CAST]]) : (f32) -> ()
+  // expected-remark@+1 {{op 'work' is not legalizable}}
   "work"(%arg0) : (f32) -> ()
 }
 
 // CHECK-LABEL: func @remap_input_to_self
 func @remap_input_to_self(%arg0: index) {
   // CHECK-NOT: test.cast
   // CHECK: "work"
+  // expected-remark@+1 {{op 'work' is not legalizable}}
   "work"(%arg0) : (index) -> ()
 }
 
 // CHECK-LABEL: func @remap_multi(%arg0: f64, %arg1: f64) -> (f64, f64)
 func @remap_multi(%arg0: i64, %unused: i16, %arg1: i64) -> (i64, i64) {
  // CHECK-NEXT: "test.valid"{{.*}} : (f64, f64)
  "test.invalid"(%arg0, %arg1) : (i64, i64) -> ()
 }
 
 // CHECK-LABEL: func @no_remap_nested
 func @no_remap_nested() {
   // CHECK-NEXT: "foo.region"
+  // expected-remark@+1 {{op 'foo.region' is not legalizable}}
   "foo.region"() ({
     // CHECK-NEXT: ^bb0(%{{.*}}: i64, %{{.*}}: i16, %{{.*}}: i64):
     ^bb0(%i0: i64, %unused: i16, %i1: i64):
       // CHECK-NEXT: "test.valid"{{.*}} : (i64, i64)
       "test.invalid"(%i0, %i1) : (i64, i64) -> ()
   }) : () -> ()
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // CHECK-LABEL: func @remap_moved_region_args
 func @remap_moved_region_args() {
   // CHECK-NEXT: return
   // CHECK-NEXT: ^bb1(%{{.*}}: f64, %{{.*}}: f64, %{{.*}}: f16, %{{.*}}: f16):
   // CHECK-NEXT: "test.cast"{{.*}} : (f16, f16) -> f32
   // CHECK-NEXT: "test.valid"{{.*}} : (f64, f64, f32)
   "test.region"() ({
     ^bb1(%i0: i64, %unused: i16, %i1: i64, %2: f32):
       "test.invalid"(%i0, %i1, %2) : (i64, i64, f32) -> ()
   }) : () -> ()
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // CHECK-LABEL: func @remap_cloned_region_args
 func @remap_cloned_region_args() {
   // CHECK-NEXT: return
   // CHECK-NEXT: ^bb1(%{{.*}}: f64, %{{.*}}: f64, %{{.*}}: f16, %{{.*}}: f16):
   // CHECK-NEXT: "test.cast"{{.*}} : (f16, f16) -> f32
   // CHECK-NEXT: "test.valid"{{.*}} : (f64, f64, f32)
   "test.region"() ({
     ^bb1(%i0: i64, %unused: i16, %i1: i64, %2: f32):
       "test.invalid"(%i0, %i1, %2) : (i64, i64, f32) -> ()
   }) {legalizer.should_clone} : () -> ()
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // CHECK-LABEL: func @remap_drop_region
 func @remap_drop_region() {
   // CHECK-NEXT: return
   // CHECK-NEXT: }
   "test.drop_region_op"() ({
     ^bb1(%i0: i64, %unused: i16, %i1: i64, %2: f32):
       "test.invalid"(%i0, %i1, %2) : (i64, i64, f32) -> ()
   }) : () -> ()
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // CHECK-LABEL: func @dropped_input_in_use
 func @dropped_input_in_use(%arg: i16, %arg2: i64) {
   // CHECK-NEXT: "test.cast"{{.*}} : () -> i16
   // CHECK-NEXT: "work"{{.*}} : (i16)
+  // expected-remark@+1 {{op 'work' is not legalizable}}
   "work"(%arg) : (i16) -> ()
 }
 
 // CHECK-LABEL: func @up_to_date_replacement
 func @up_to_date_replacement(%arg: i8) -> i8 {
   // CHECK-NEXT: return
   %repl_1 = "test.rewrite"(%arg) : (i8) -> i8
   %repl_2 = "test.rewrite"(%repl_1) : (i8) -> i8
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return %repl_2 : i8
 }
 
 // CHECK-LABEL: func @remove_foldable_op
 // CHECK-SAME:                          (%[[ARG_0:[a-z0-9]*]]: i32)
 func @remove_foldable_op(%arg0 : i32) -> (i32) {
   // CHECK-NEXT: return %[[ARG_0]]
   %0 = "test.op_with_region_fold"(%arg0) ({
     "foo.op_with_region_terminator"() : () -> ()
   }) : (i32) -> (i32)
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return %0 : i32
 }
 
 // CHECK-LABEL: @create_block
 func @create_block() {
+  // expected-remark@+1 {{op 'test.container' is not legalizable}}
   "test.container"() ({
     // Check that we created a block with arguments.
     // CHECK-NOT: test.create_block
     // CHECK: ^{{.*}}(%{{.*}}: i32, %{{.*}}: i32):
     // CHECK: test.finish
     "test.create_block"() : () -> ()
     "test.finish"() : () -> ()
   }) : () -> ()
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // CHECK-LABEL: @bounded_recursion
 func @bounded_recursion() {
   // CHECK: test.recursive_rewrite 0
   test.recursive_rewrite 3
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // -----
 
 func @fail_to_convert_illegal_op() -> i32 {
   // expected-error@+1 {{failed to legalize operation 'test.illegal_op_f'}}
   %result = "test.illegal_op_f"() : () -> (i32)
func @fail_to_convert_region() {
   }) : () -> ()
   return
 }
 
 // -----
 
 // CHECK-LABEL: @create_illegal_block
 func @create_illegal_block() {
+  // expected-remark@+1 {{op 'test.container' is not legalizable}}
   "test.container"() ({
     // Check that we can undo block creation, i.e. that the block was removed.
     // CHECK: test.create_illegal_block
     // CHECK-NOT: ^{{.*}}(%{{.*}}: i32, %{{.*}}: i32):
+    // expected-remark@+1 {{op 'test.create_illegal_block' is not legalizable}}
     "test.create_illegal_block"() : () -> ()
     "test.finish"() : () -> ()
   }) : () -> ()
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // -----
 
 // CHECK-LABEL: @undo_block_arg_replace
 func @undo_block_arg_replace() {
+  // expected-remark@+1 {{op 'test.undo_block_arg_replace' is not legalizable}}
   "test.undo_block_arg_replace"() ({
   ^bb0(%arg0: i32):
     // CHECK: ^bb0(%[[ARG:.*]]: i32):
     // CHECK-NEXT: "test.return"(%[[ARG]]) : (i32)
 
     "test.return"(%arg0) : (i32) -> ()
   }) : () -> ()
+  // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }

mlir/test/lib/Dialect/Test/TestPatterns.cpp

void runOnOperation() override {
     });
 
     // Mark the bound recursion operation as dynamically legal.
     target.addDynamicallyLegalOp<TestRecursiveRewriteOp>(
         [](TestRecursiveRewriteOp op) { return op.depth() == 0; });
 
     // Handle a partial conversion.
     if (mode == ConversionMode::Partial) {
-      (void)applyPartialConversion(getOperation(), target, patterns,
-                                   &converter);
+      DenseSet<Operation *> unlegalizedOps;
+      (void)applyPartialConversion(getOperation(), target, patterns, &converter,
+                                   &unlegalizedOps);
+      // Emit remarks for each legalizable operation.
+      for (auto *op : unlegalizedOps)
+        op->emitRemark() << "op '" << op->getName() << "' is not legalizable";
       return;
     }
 
     // Handle a full conversion.
     if (mode == ConversionMode::Full) {
       // Check support for marking unknown operations as dynamically legal.
       target.markUnknownOpDynamicallyLegal([](Operation *op) {
         return (bool)op->getAttrOfType<UnitAttr>("test.dynamically_legal");