[MLIR] Allow llvm.resume with non-landingpad input (#8590)

This changes verification of llvm.resume to just fail if there is no
llvm.landingpad instruction in the same function with the same type as
this instruction's input, more in line with LLVM's verification. From
LLVM documentation (https://llvm.org/docs/LangRef.html#i-resume):

The ‘resume’ instruction requires one argument, which must have the same
type as the result of any ‘landingpad’ instruction in the same function.

Signed-off-by: Victor Perez <victor.perez@codeplay.com>

Author: victor-eds

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

@@ -1585,8 +1585,21 @@ LogicalResult ReturnOp::verify() {
 //===----------------------------------------------------------------------===//
 
 LogicalResult ResumeOp::verify() {
-  if (!getValue().getDefiningOp<LandingpadOp>())
-    return emitOpError("expects landingpad value as operand");
+  auto parentFunc = getOperation()->getParentOfType<FunctionOpInterface>();
+  assert(parentFunc && "Expecting parent function");
+  const auto ty = getOperand().getType();
+  if (!parentFunc
+           ->walk([ty](LandingpadOp landingpad) {
+             return landingpad.getType() == ty
+                        ? WalkResult::interrupt() // Just an operation needed
+                        : WalkResult::advance();
+           })
+           .wasInterrupted()) {
+    // No operation was found: emit error
+    return emitOpError("expects landingpad operation in the same function and "
+                       "with the same type as this operation's operand");
+  }
+
   // No check for personality of function - landingpad op verifies it.
   return success();
 }

mlir/test/Dialect/LLVMIR/invalid.mlir

@@ -810,7 +810,18 @@ llvm.func @caller(%arg0: i32) -> i32 attributes { personality = @__gxx_personali
   llvm.return %0 : i32
 ^bb2: // pred: ^bb0
   %2 = llvm.landingpad cleanup : !llvm.struct<(ptr<i8>, i32)>
-  // expected-error@+1 {{'llvm.resume' op expects landingpad value as operand}}
+  // expected-error@+1 {{'llvm.resume' op expects landingpad operation in the same function and with the same type as this operation's operand}}
+  llvm.resume %0 : i32
+}
+
+// -----
+
+llvm.func @foo(i32) -> i32
+llvm.func @__gxx_personality_v0(...) -> i32
+
+llvm.func @caller(%arg0: i32) -> i32 attributes { personality = @__gxx_personality_v0 } {
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  // expected-error@+1 {{'llvm.resume' op expects landingpad operation in the same function and with the same type as this operation's operand}}
   llvm.resume %0 : i32
 }
 

mlir/test/Dialect/LLVMIR/roundtrip.mlir

@@ -425,6 +425,27 @@ llvm.func @invokeLandingpad() -> i32 attributes { personality = @__gxx_personali
   llvm.return %0 : i32
 }
 
+llvm.func @foo2() -> !llvm.struct<(ptr<i8>, i32)>
+
+// CHECK-LABEL: llvm.func @resumeNoLandingpadValue(
+// CHECK-SAME:                                     %[[ARG:.*]]: i32)
+llvm.func @resumeNoLandingpadValue(%arg0: i32) -> i32 attributes { personality = @__gxx_personality_v0 } {
+// CHECK: %[[VAL_0:.*]] = llvm.call @foo2() : () -> !llvm.struct<(ptr<i8>, i32)>
+// CHECK: %[[VAL_1:.*]] = llvm.invoke @foo(%[[ARG]]) to ^[[BB1:.*]] unwind ^[[BB2:.*]] : (i32) -> i32
+  %0 = llvm.call @foo2() : () -> !llvm.struct<(ptr<i8>, i32)>
+  %1 = llvm.invoke @foo(%arg0) to ^bb1 unwind ^bb2 : (i32) -> i32
+// CHECK: ^[[BB1]]:
+// CHECK: llvm.return %[[VAL_1]] : i32
+^bb1: // pred: ^bb0
+  llvm.return %1 : i32
+// CHECK: ^[[BB2]]:
+// CHECK: %[[VAL_2:.*]] = llvm.landingpad cleanup : !llvm.struct<(ptr<i8>, i32)>
+// CHECK: llvm.resume %[[VAL_0]] : !llvm.struct<(ptr<i8>, i32)>
+^bb2: // pred: ^bb0
+  %2 = llvm.landingpad cleanup : !llvm.struct<(ptr<i8>, i32)>
+  llvm.resume %0 : !llvm.struct<(ptr<i8>, i32)>
+}
+
 // CHECK-LABEL: @useFreezeOp
 func.func @useFreezeOp(%arg0: i32) {
   // CHECK:  = llvm.freeze %[[ARG0:.*]] : i32