[mlir] Added llvm.resume and personality functions in LLVM IR Dialect

[shraiysh]

Summary

llvm.resume is similar to llvm.return except that has to be exactly one operand and that should be derived from a llvm.landingpad instruction.
Any function having llvm.landingpad instruction must have a personality attribute.

Example:
LLVM IR

define dso_local i32 @main() personality i32 (...)* @__gxx_personality_v0 {
  invoke void @foo(i32 42)
          to label %3 unwind label %1

1:                                                ; preds = %0
  %2 = landingpad i8*
          catch i8** @_ZTIi
          catch i8* bitcast (i8** @_ZTIi to i8*)
  resume i8* %2

3:                                                ; preds = %0
  ret i32 1
}

MLIR - LLVM IR Dialect

llvm.func @main() -> !llvm.i32 attributes {personality = @__gxx_personality_v0} {
    %0 = llvm.mlir.constant(1 : i32) : !llvm.i32
    %1 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**">
    %2 = llvm.bitcast %1 : !llvm<"i8**"> to !llvm<"i8*">
    %3 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**">
    %4 = llvm.mlir.constant(42 : i32) : !llvm.i32
    llvm.invoke @foo(%4) to ^bb2 unwind ^bb1 : (!llvm.i32) -> ()
  ^bb1:	// pred: ^bb0
    %5 = llvm.landingpad (catch %3 : !llvm<"i8**">) (catch %2 : !llvm<"i8*">) : !llvm<"i8*">
    llvm.resume %5 : !llvm<"i8*">
  ^bb2:	// pred: ^bb0
    llvm.return %0 : !llvm.i32
  }

[shraiysh]

Looks like landingpad needs to be implemented before doing this. Will come back to this after that is done.

[ftynse]

Thanks for working on this! Please feel free to add me as a reviewer when you are have landingpad implemented.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

457

The number of operands should be checked by declaring them in the "arguments" list with appropriate types. This will need another check to make sure the type matches that mentioned in some "landingpad", but that check can assume the "arguments"-based check passed.

Note that in MLIR, operation verifiers are not allowed to inspect sibling operations (since operations can be processed in parallel). So the type-match verifier should be implemented on the enclosing operation, likely in LLVMFuncOp.

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

762

This should be enforced by the verifier. Generally, we don't check the verifier-enforced properties in functions.

772

If there's strictly one operand, I'd suggest using parser.parseOperand instead. It would provide a more meaningful message in case the operand is absent.

[rriddle]

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

761

ResumeOp &

Operations are value-typed, so you shouldn't pass by reference or pointer in general.

[mehdi_amini]

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

457

Note that in MLIR, operation verifiers are not allowed to inspect sibling operations (since operations can be processed in parallel).

To clarify: this is only true for symbolic reference region-traversal: it is valid to traverse use-def chains in a verifier I believe.

[shraiysh]

Thank you all for your comments. I will get back to this issue after doing the landingpad instruction.

[shraiysh]

Please review this.

Also, I am unable to figure out how to model constant expressions for personality in MLIR.

For example,

define dso_local i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
  ...
}

will break right now, because I could not model bitcast globally.
Any insights into how do I get bitcast to work as a global instruction will help.
Thanks

[shraiysh]

Hi, can someone please provide a review for this patch.
Thanks.

[rriddle]

In D71888#1853128, @shraiysh wrote:

Please review this.

Also, I am unable to figure out how to model constant expressions for personality in MLIR.

For example,

define dso_local i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
  ...
}

will break right now, because I could not model bitcast globally.
Any insights into how do I get bitcast to work as a global instruction will help.
Thanks

This is a bit thorny. I'm not entirely sure on the contract of how the personality function is supposed to look. I went back through the commits in clang, but couldn't find anything that definitively documented it. I would say for now we could likely just always bitcast functions to an opaque i8* when exporting. That would mean that our roundtrip isn't exactly exact lossless, but that is a separate issue. Also, I have seen usages of i32 values as the personality function in some tests before. I'm not sure if any particular front-end uses anything other than a function pointer, but it is something to keep in mind. I'm fine with keeping the personality function as a FlatSymbolRef for now though.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

487

nit: Can you override the arguments of this op so that this is handled automatically?

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

931

nit: Can you use the declarative custom assembly form instead? That would remove the need to define the parser/printer in c++.

https://mlir.llvm.org/docs/OpDefinitions/#declarative-assembly-format

Should be something like:

let assemblyFormat = "operands attr-dict `:` type(operands)";

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

700

nit: v = b.create<LandingPadOp>(...);

775

nit: Can you create the function and then set the personality afterwards? That seems like it would be much cleaner.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

547

Can you just use the normal attribute export handling here?

612

What prompted this change? Seems unrelated.

mlir/test/Dialect/LLVMIR/invalid.mlir

611

Missing newline after this.

[rriddle]

In D71888#1863086, @shraiysh wrote:

Hi, can someone please provide a review for this patch.
Thanks.

Sorry for the delay.

[shraiysh]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

612

In landingpad instruction, valuMapping was not set. Hence, while trying to make it an operand in resume, the program was going into a segmentation fault. I wrote this assert to avoid the segmentation fault.

[rriddle]

Looking good, a few more nits.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

502

nit: Can you just use a single line string? = "...";

672

Can you fix the formatting here? Seems to be 2 spaces too many.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

768

Can you extract this out into a new function? That should simplify a bit of the control flow here.

782

dyn_cast_or_null is only for when the value can be null, do we expect the operand here to ever be null? If not, use dyn_cast instead.

785

Please update each of the comments to have punctuation at the end. This applies throughout this revision.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

637

nit: llvm::is_contained

[shraiysh]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

637

I think llvm::is_contained is a wrapper for std::find. I am not sure if there is a neat way of looking for keys in a map using std::find (and hence llvm::is_contained). Please let me know if there is.

[bondhugula]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

637

It might be a wrapper around it, but it's more readable to me with llvm::is_contained.

[shraiysh]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

637

I meant llvm::is_contained(valueMapping, v) does not work - because valueMapping is a DenseMap. I am not aware of a variant of is_contained that supports maps - looking for a key in it. Currently I am using std::map::find while the documentation suggests is_contained is wrapper for std::find.

[mehdi_amini]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

637

rather valueMapping.count(v) ?

[rriddle]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

637

Gah, I was hoping that llvm::is_contained would be smart enough to detect find at this point. Given that, you should use .count() instead.

[shraiysh]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

637

Done!

[shraiysh]

I do not have write access to the repository. If would be great if someone could commit for me. Thanks.

[shraiysh]

Updated with full context.

[ftynse]

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

496

Value is not guaranteed to have a defining op, use isa_and_nonnull instead to avoid a crash here.

Nit: add a space between if and (.

671

Don't we have a tablegenrated equivalent?

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

758

LLVM prefers early-return over long control flow blocks, e.g.

if (!f->hasPersinalityFn())
  return nullptr;

FlatSymbolRefAttr personality;
/* The code you have inside if, but with less indentation. */

770–771

LLVMDialect is cached by the Importer, so just dialect->getLLVMContext() should be sufficient

777

Why is this necessary? I wouldn't expect the converter to modify the input module silently.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

98

Do we always want to bitcast symbol references? E.g., what happens for good old function constants that have the right type?

mlir/test/Dialect/LLVMIR/invalid.mlir

577

You don't need to test the default parser.

600

This line doesn't seem necessary in this test

[shraiysh]

Addressed comments.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

777

If this is not done, the conversion crashes with the error Use still stuck around after Def is destroyed.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

98

When the type is same, the bitcast instruction is automatically omitted in this behaviour (must be handled somewhere else). I tried running it on a function pointer for which both the types were same and it did not produce a new bitcast instruction while converting to LLVM IR.

[shraiysh]

@ftynse @rriddle please review this

[rriddle]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

63

nit: -> /

63

(sigh, looks like the display is messed up)
nit: Use /// for top-level comments.

769

We shouldn't materialize an instruction here, you can just use ce->getOpCode() == llvm::Instruction::BitCast.

[shraiysh]

Addressed comments.

[rriddle]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

780

Can we change these to early return instead?

if (...)

return b...;

if (auto ce ...) {

}
return FlatSymbolRefAttr();

[shraiysh]

Addressed comments.

I do not have commit access. Can someone please commit this?
Thanks

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

   let parser = [{ return parseReturnOp(parser, result); }];
   let printer = [{ printReturnOp(p, *this); }];
 }
+def LLVM_ResumeOp : LLVM_TerminatorOp<"resume", []> {
+  let arguments = (ins LLVM_Type:$value);
+  string llvmBuilder = [{ builder.CreateResume($value); }];
+  let verifier = [{
+    if(!isa<LandingpadOp>(value().getDefiningOp()))
+      return emitOpError("expects landingpad value as operand");
+    // No check for personality of function - landingpad op verifies it.
+    return success();
+  }];
+
+  let assemblyFormat = "$value attr-dict `:` type($value)";
+}
 def LLVM_UnreachableOp : LLVM_TerminatorOp<"unreachable", []> {
   string llvmBuilder = [{ builder.CreateUnreachable(); }];
   let parser = [{ return success(); }];

 def LLVM_LLVMFuncOp
     : LLVM_ZeroResultOp<"func", [IsolatedFromAbove, FunctionLike, Symbol]>,
       Arguments<(ins DefaultValuedAttr<Linkage,
-                                       "Linkage::External">:$linkage)> {
+                                       "Linkage::External">:$linkage,
+                     OptionalAttr<FlatSymbolRefAttr>:$personality)> {
   let summary = "LLVM dialect function, has wrapped LLVM IR function type";
 
   let regions = (region AnyRegion:$body);

     bool isVarArg() {
       return getType().getUnderlyingType()->isFunctionVarArg();
     }
+    void setPersonalityFn(FlatSymbolRefAttr personality) {
+      setAttr("personality", personality);
+    }
 
     // Hook for OpTrait::FunctionLike, returns the number of function arguments.
     // Depends on the type attribute being correct as checked by verifyType.

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

 
 static LogicalResult verify(LandingpadOp op) {
   Value value;
+  if (LLVMFuncOp func = op.getParentOfType<LLVMFuncOp>()) {
+    if (!func.personality().hasValue())
+      return op.emitError(
+          "llvm.landingpad needs to be in a function with a personality");
+  }
 
   if (!op.cleanup() && op.getOperands().empty())
     return op.emitError("landingpad instruction expects at least one clause or "

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

   GlobalOp processGlobal(llvm::GlobalVariable *GV);
 
 private:
+  // Returns personality of `f` as a FlatSymbolRefAttr.
+  FlatSymbolRefAttr getPersonalityAsAttr(llvm::Function *f);
   /// Imports `bb` into `block`, which must be initially empty.
   LogicalResult processBasicBlock(llvm::BasicBlock *bb, Block *block);
   /// Imports `inst` and populates instMap[inst] with the imported Value.

     // FIXME: switch
     // FIXME: indirectbr
     // FIXME: invoke
-    // FIXME: resume
+    INST(Resume, Resume),
     // FIXME: unreachable
     // FIXME: cleanupret
     // FIXME: catchret

   case llvm::Instruction::Load:
   case llvm::Instruction::Store:
   case llvm::Instruction::Ret:
+  case llvm::Instruction::Resume:
   case llvm::Instruction::Trunc:
   case llvm::Instruction::ZExt:
   case llvm::Instruction::SExt:

     for (unsigned i = 0, ie = lpi->getNumClauses(); i < ie; i++)
       ops.push_back(processConstant(lpi->getClause(i)));
 
-    b.create<LandingpadOp>(loc, processType(lpi->getType()), lpi->isCleanup(),
-                           ops);
+    Type ty = processType(lpi->getType());
+    if (!ty)
+      return failure();
+
+    v = b.create<LandingpadOp>(loc, ty, lpi->isCleanup(), ops);
     return success();
   }
   case llvm::Instruction::Invoke: {

   }
 }
 
+FlatSymbolRefAttr Importer::getPersonalityAsAttr(llvm::Function *f) {
+  FlatSymbolRefAttr personality;
+  if (f->hasPersonalityFn()) {
+    llvm::Constant *pf = f->getPersonalityFn();
+
+    // If it directly has a name, we can use it.
+    if (pf->hasName())
+      personality = b.getSymbolRefAttr(pf->getName());
+    // If it doesn't have a name, currently, only function pointers that are
+    // bitcast to i8* are parsed.
+    if (auto ce = dyn_cast<llvm::ConstantExpr>(pf)) {
+      if (auto bc =
+              dyn_cast_or_null<llvm::BitCastInst>(ce->getAsInstruction())) {
+        if (bc->getDestTy() ==
+            llvm::Type::getInt8PtrTy(b.getContext()
+                                         ->getRegisteredDialect<LLVMDialect>()
+                                         ->getLLVMContext())) {
+          if (auto func = dyn_cast<llvm::Function>(bc->getOperand(0)))
+            personality = b.getSymbolRefAttr(func->getName());
+        }
+        // Delete the zombie instruction.
+        bc->deleteValue();
+      }
+    }
+  }
+  return personality;
+}
+
 LogicalResult Importer::processFunction(llvm::Function *f) {
   blocks.clear();
   instMap.clear();

   b.setInsertionPoint(module.getBody(), getFuncInsertPt());
   LLVMFuncOp fop = b.create<LLVMFuncOp>(UnknownLoc::get(context), f->getName(),
                                         functionType);
+
+  if (FlatSymbolRefAttr personality = getPersonalityAsAttr(f))
+    fop.setPersonalityFn(personality);
+  else if (f->hasPersonalityFn())
+    emitWarning(UnknownLoc::get(context),
+                "could not deduce personality, skipping it");
+
   if (f->isDeclaration())
     return success();
 

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

   if (auto floatAttr = attr.dyn_cast<FloatAttr>())
     return llvm::ConstantFP::get(llvmType, floatAttr.getValue());
   if (auto funcAttr = attr.dyn_cast<FlatSymbolRefAttr>())
-    return functionMapping.lookup(funcAttr.getValue());
+    return llvm::ConstantExpr::getBitCast(
+        functionMapping.lookup(funcAttr.getValue()), llvmType);
   if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
     auto *sequentialType = cast<llvm::SequentialType>(llvmType);
     auto elementType = sequentialType->getElementType();

       if (auto constOperand = dyn_cast<llvm::Constant>(operand))
         lpi->addClause(constOperand);
     }
+    valueMapping[lpOp.getResult()] = lpi;
     return success();
   }
 

     argIdx++;
   }
 
+  // Check the personality and set it.
+  if (func.personality().hasValue()) {
+    llvm::Type *ty = llvm::Type::getInt8PtrTy(llvmFunc->getContext());
+    if (llvm::Constant *pfunc =
+            getLLVMConstant(ty, func.personalityAttr(), func.getLoc()))
+      llvmFunc->setPersonalityFn(pfunc);
+  }
+
   // First, create all blocks so we can jump to them.
   llvm::LLVMContext &llvmContext = llvmFunc->getContext();
   for (auto &bb : func) {

 ModuleTranslation::lookupValues(ValueRange values) {
   SmallVector<llvm::Value *, 8> remapped;
   remapped.reserve(values.size());
-  for (Value v : values)
+  for (Value v : values) {
+    assert(valueMapping.count(v) && "referencing undefined value");
     remapped.push_back(valueMapping.lookup(v));
+  }
   return remapped;
 }
 

mlir/test/Dialect/LLVMIR/invalid.mlir

 llvm.func @foo(!llvm.i32) -> !llvm.i32
 llvm.func @__gxx_personality_v0(...) -> !llvm.i32
 
-llvm.func @bad_landingpad(%arg0: !llvm<"i8**">) {
+llvm.func @bad_landingpad(%arg0: !llvm<"i8**">) attributes { personality = @__gxx_personality_v0} {
   %0 = llvm.mlir.constant(3 : i32) : !llvm.i32
   %1 = llvm.mlir.constant(2 : i32) : !llvm.i32
   %2 = llvm.invoke @foo(%1) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32

 llvm.func @foo(!llvm.i32) -> !llvm.i32
 llvm.func @__gxx_personality_v0(...) -> !llvm.i32
 
-llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 {
+llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 attributes { personality = @__gxx_personality_v0} {
   %0 = llvm.mlir.constant(1 : i32) : !llvm.i32
   %1 = llvm.alloca %0 x !llvm<"i8*"> : (!llvm.i32) -> !llvm<"i8**">
   // expected-note@+1 {{global addresses expected as operand to bitcast used in clauses for landingpad}}

 llvm.func @foo(!llvm.i32) -> !llvm.i32
 llvm.func @__gxx_personality_v0(...) -> !llvm.i32
 
-llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 {
+llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 attributes { personality = @__gxx_personality_v0} {
   %0 = llvm.mlir.constant(1 : i32) : !llvm.i32
   %1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32
 ^bb1: // pred: ^bb0

   %2 = llvm.landingpad : !llvm<"{ i8*, i32 }">
   llvm.return %0 : !llvm.i32
 }
+
+// -----
+
+llvm.func @foo(!llvm.i32) -> !llvm.i32
+llvm.func @__gxx_personality_v0(...) -> !llvm.i32
+
+llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 attributes { personality = @__gxx_personality_v0 } {
+  %0 = llvm.mlir.constant(1 : i32) : !llvm.i32
+  %1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32
+^bb1: // pred: ^bb0
+  llvm.return %0 : !llvm.i32
+^bb2: // pred: ^bb0
+  %2 = llvm.landingpad cleanup : !llvm<"{ i8*, i32 }">
+  // expected-error@+1 {{expected SSA operand}}
+  llvm.resume : !llvm<"{ i8*, i32 }">
+}
+
+// -----
+
+llvm.func @foo(!llvm.i32) -> !llvm.i32
+llvm.func @__gxx_personality_v0(...) -> !llvm.i32
+
+llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 attributes { personality = @__gxx_personality_v0 } {
+  %0 = llvm.mlir.constant(1 : i32) : !llvm.i32
+  %1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32
+^bb1: // pred: ^bb0
+  llvm.return %0 : !llvm.i32
+^bb2: // pred: ^bb0
+  %2 = llvm.landingpad cleanup : !llvm<"{ i8*, i32 }">
+  // expected-error@+1 {{'llvm.resume' op expects landingpad value as operand}}
+  llvm.resume %0 : !llvm.i32
+}
+
+// -----
+
+llvm.func @foo(!llvm.i32) -> !llvm.i32
+llvm.func @__gxx_personality_v0(...) -> !llvm.i32
+
+llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 {
+  %0 = llvm.mlir.constant(1 : i32) : !llvm.i32
+  %1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32
+^bb1: // pred: ^bb0
+  llvm.return %0 : !llvm.i32
+^bb2: // pred: ^bb0
+  // expected-error@+1 {{llvm.landingpad needs to be in a function with a personality}}
+  %2 = llvm.landingpad cleanup : !llvm<"{ i8*, i32 }">
+  llvm.resume %2 : !llvm<"{ i8*, i32 }">
+}

mlir/test/Dialect/LLVMIR/roundtrip.mlir

 llvm.func @__gxx_personality_v0(...) -> !llvm.i32
 
 // CHECK-LABEL: @invokeLandingpad
-llvm.func @invokeLandingpad() -> !llvm.i32 {
+llvm.func @invokeLandingpad() -> !llvm.i32 attributes { personality = @__gxx_personality_v0 } {
 // CHECK-NEXT: %[[a0:[0-9]+]] = llvm.mlir.constant(0 : i32) : !llvm.i32
 // CHECK-NEXT: %{{[0-9]+}} = llvm.mlir.constant(3 : i32) : !llvm.i32
 // CHECK-NEXT: %[[a2:[0-9]+]] = llvm.mlir.constant("\01") : !llvm<"[1 x i8]">

   %9 = llvm.invoke @foo(%7) to ^bb2 unwind ^bb1 : (!llvm.i32) -> !llvm<"{ i32, double, i32 }">
 
 // CHECK-NEXT: ^bb1:
-// CHECK-NEXT:   %{{[0-9]+}} = llvm.landingpad cleanup (catch %[[a3]] : !llvm<"i8**">) (catch %[[a6]] : !llvm<"i8*">) (filter %[[a2]] : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }">
-// CHECK-NEXT:   llvm.br ^bb3
+// CHECK-NEXT:   %[[lp:[0-9]+]] = llvm.landingpad cleanup (catch %[[a3]] : !llvm<"i8**">) (catch %[[a6]] : !llvm<"i8*">) (filter %[[a2]] : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }">
+// CHECK-NEXT:   llvm.resume %[[lp]] : !llvm<"{ i8*, i32 }">
 ^bb1:
   %10 = llvm.landingpad cleanup (catch %3 : !llvm<"i8**">) (catch %6 : !llvm<"i8*">) (filter %2 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }">
-  llvm.br ^bb3
+  llvm.resume %10 : !llvm<"{ i8*, i32 }">
 
 // CHECK-NEXT: ^bb2:
 // CHECK-NEXT:   llvm.return %[[a7]] : !llvm.i32

mlir/test/Target/import.ll

   ; FIXME: Change filter to a constant array once they are handled. 
   ; Currently, even though it parses this, LLVM module is broken
           filter [1 x i8] [i8 1]
-  ; CHECK: llvm.br ^bb3
-  br label %5
+  resume { i8*, i32 } %3
 
 ; CHECK: ^bb2:
   ; CHECK: llvm.return %{{[0-9]+}} : !llvm.i32

mlir/test/Target/llvmir.mlir

 llvm.func @__gxx_personality_v0(...) -> !llvm.i32
 
 // CHECK-LABEL: @invokeLandingpad
-llvm.func @invokeLandingpad() -> !llvm.i32 {
+llvm.func @invokeLandingpad() -> !llvm.i32 attributes { personality = @__gxx_personality_v0 } {
 // CHECK: %[[a1:[0-9]+]] = alloca i8
   %0 = llvm.mlir.constant(0 : i32) : !llvm.i32
   %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]">