[MLIR] Added llvm.invoke and llvm.landingpad

[shraiysh]

Summary

I have tried to implement llvm.invoke and llvm.landingpad.

1. llvm.invoke is similar to llvm.call with two successors added, the first one is the normal label and the second one is unwind label.
2. llvm.launchpad takes a variable number of args with either catch or filter associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866)

Examples:

LLVM IR

define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
    invoke i32 @foo(i32 2) to label %success unwind label %fail

  success:
    ret i32 2

  fail:
    landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ]
    ret i32 3
}

MLIR LLVM Dialect

llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 {
  %0 = llvm.mlir.constant(3 : i32) : !llvm.i32
  %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]">
  %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**">
  %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*">
  %4 = llvm.mlir.null : !llvm<"i8**">
  %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**">
  %6 = llvm.mlir.constant(2 : i32) : !llvm.i32
  %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32
^bb1:	// pred: ^bb0
  llvm.return %6 : !llvm.i32
^bb2:	// pred: ^bb0
  %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }">
  llvm.return %0 : !llvm.i32
}

Signed-off-by: Shraiysh Vaishay <[e-mail]>

[rriddle]

You are missing some tests.

Simple comments for now, haven't had time to think much about the modeling.

For 2. I would remove the attributes and just do the same thing that LLVM does, i.e. if the type is an Array it is a filter. I don't see a reason why attributes are necessary on top of that.

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

377

Can we use the same names as LLVM for 'success' and 'failure'?

379

This should be checked now, we don't model PHIInst like LLVM does so this should be even simpler.

452

Lines should be wrapped at 80 characters just like code.

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

642

This needs to be updated

645

Why is this necessary? Why not just use result.attributes directly instead?

651

Change this to FunctionType, parseType will already check that the parsed type isa<FunctionType>

868

Stream these in:

p << ' ' << op.getOperands() << " : " << op.getType();

875

This seems unimplemented

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

294

Leftover debugging.

299

This looks unrelated.

780

Remove all trivial braces.

799

Please use proper builder.create<> instead, adding build methods to Invoke and LandingPad as necessary.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

317

Remove all commented out code.

[shraiysh]

Yes, I'm sorry for the confusion. Thanks for the comments.

I just wanted a green light to go ahead with this implementation. This obviously needs a lot of revision 🙂

[ftynse]

Haven't looked at the code, let met know if you want me to. Please see design comments inline.

I have tried to implement llvm.invoke and llvm.landingpad.

llvm.invoke is similar to llvm.call with two successors added, the first one is the normal label and the second one is unwind label.
llvm.call was breaking for function pointers inside code, so I did not handle the same for llvm.invoke

Breaking how? If you think there's a bug, please report it (and feel free to assign to me).

handling that can probably be a separate commit as it is independent on this. Both call and invoke might need revision after that.

I have a slight preference of not changing the IR often, i.e. if we know invoke will be modeled differently soon, why not model it differently from the start?

llvm.launchpad takes a variable number of args with either catch or filter associated with them. I went with a string attribute dictionary for a list of catch and filter.

This could work, but there may be another way. Since the clauses must refer to globals anyway, we can have a list of attributes where the i-th attribute is a SymbolRef to the global if it is a catch clause, and a nested potentially empty array of SymbolRefs to globals if it is a filter clause. This is a more intrusive change compared to LLVM IR, but it's justifiable IMO since we model globals differently anyway. We can optionally store the array types as other attributes but they can always be inferred from array attributes. I haven't thought deeply about the trade-offs involved.

This would give something like
"llvm.landingpad"() {[@_ZTli, [], @_ZTd, [@_ZTf]}] : () -> !llvm<"result_type">
in the generic form. which would correspond to
landingpad catch i8* @_ZTli, filter [0xi8**] undef, catch i8* @_ZTd, filter [1xi8*] @_ZTf
It will remove the need to do addressof and declare constants before the landingpad (simplifying the verifier that checks whether it's the first operation in the block, and another one that checks the operands are only constants), but will make it hard to see the types.

Not sure if implementing another type constraint alongside LLVM_Type would be a better idea.

I don't think type constraints are relevant here. You need to _store_ the fact that an operand belongs to one clause or another, constraints are only checked in the verifier and don't affect the storage.

llvm.launchpad expects an array as an argument when filtering. Constant array and Undefined values were not handled and the program was going into a segmentation fault.

Please report a bug about the segmentation fault.

I could test that it should work using i8 constants, which are interpreted as strings, but this is not rigorous testing.
Examples:
LLVM IR

define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {

  invoke i32 @foo(i32 2) to label %success unwind label %fail

success:
  ret i32 2

fail:
  landingpad {i8*, i32} catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ]
  ret i32 3

}
MLIR LLVM Dialect

llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 {

  %0 = llvm.mlir.constant(3 : i32) : !llvm.i32
  %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]">
  %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**">
  %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*">
  %4 = llvm.mlir.null : !llvm<"i8**">
  %5 = llvm.mlir.constant(2 : i32) : !llvm.i32
  %6 = llvm.invoke @foo(%5) ^bb1, ^bb2 : (!llvm.i32) -> !llvm.i32
^bb1:	// pred: ^bb0
  llvm.return %5 : !llvm.i32
^bb2:	// pred: ^bb0
  %7 = llvm.landingpad  {clauseTypes = ["catch", "catch", "filter"], cleanup = false} %4, %3, %1 : !llvm<"{ i8*, i32 }">
  llvm.return %0 : !llvm.i32
}

Is this syntax okay? Should go ahead with verifiers and tests for currently handled inputs?

I think you can even have the llvm-like syntax:
llvm.landingpad catch %4, catch %3, filter %1 : !llvm<"{ i8*, i32 }">

You can do something like

StringRef kw;
while (succeeded(parseOptionalKeyword(&kw)) {
  if (kw.is(kCatchKeyword)) // handle catch
  else if (kw.is(kFilterKeyword)) // handle filter
  else if (kw.is(kCleanupKeyword)) // handle cleanup
}
parseColonType(..)

[ftynse]

For 2. I would remove the attributes and just do the same thing that LLVM does, i.e. if the type is an Array it is a filter. I don't see a reason why attributes are necessary on top of that.

Does anything preclude catch type from being an array type, in theory? (In C++, it's a pointer to a std::type_info, but we should not be limited to that)

[rriddle]

In D72006#1799769, @ftynse wrote:

For 2. I would remove the attributes and just do the same thing that LLVM does, i.e. if the type is an Array it is a filter. I don't see a reason why attributes are necessary on top of that.

Does anything preclude catch type from being an array type, in theory? (In C++, it's a pointer to a std::type_info, but we should not be limited to that)

Langref doesn't outright state it as far as I can remember, but this has always been a constraint(from the point landing pad was added, ~9 years). You could try to use an Array for catch, but it would require some amount of changes to LLVM(i.e. removing baked-in assumptions) to get it to work.
https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866

[shraiysh]

Haven't looked at the code, let met know if you want me to. Please see design comments inline.

No, the code is not finished yet. I just wanted reviews on the design. Thanks.

Breaking how? If you think there's a bug, please report it (and feel free to assign to me).

It goes into a segmentation fault. I will file a bug.

I have a slight preference of not changing the IR often, i.e. if we know invoke will be modelled differently soon, why not model it differently from the start?

Agreed. Handling the function call is same for both call and invoke - so, once the function pointers are handled for call, it will be exactly the same for invoke. I think this syntax is going to work even after the change - it's just that while handling those pointers, the LLVM IR parser in MLIR might have to change a bit - that is what I meant by revision.

This could work, but there may be another way. Since the clauses must refer to globals anyway, we can have a list of attributes where the i-th attribute is a SymbolRef to the global if it is a catch clause, and a nested potentially empty array of SymbolRefs to globals if it is a filter clause. This is a more intrusive change compared to LLVM IR, but it's justifiable IMO since we model globals differently anyway. We can optionally store the array types as other attributes but they can always be inferred from array attributes. I haven't thought deeply about the trade-offs involved.

This would give something like
"llvm.landingpad"() {[@_ZTli, [], @_ZTd, [@_ZTf]}] : () -> !llvm<"result_type">
in the generic form. which would correspond to
landingpad catch i8* @_ZTli, filter [0xi8**] undef, catch i8* @_ZTd, filter [1xi8*] @_ZTf
It will remove the need to do addressof and declare constants before the landingpad (simplifying the verifier that checks whether it's the first operation in the block, and another one that checks the operands are only constants), but will make it hard to see the types.

This sounds like a better idea. I will start working on this instead of the current thing.

I don't think type constraints are relevant here. You need to _store_ the fact that an operand belongs to one clause or another, constraints are only checked in the verifier and don't affect the storage.

Okay. That makes sense.

llvm.launchpad expects an array as an argument when filtering. Constant array and Undefined values were not handled and the program was going into a segmentation fault.

Please report a bug about the segmentation fault.

Sure thing. I will report about those too.

I think you can even have the llvm-like syntax:
llvm.landingpad catch %4, catch %3, filter %1 : !llvm<"{ i8*, i32 }">

You can do something like

StringRef kw;
while (succeeded(parseOptionalKeyword(&kw)) {
  if (kw.is(kCatchKeyword)) // handle catch
  else if (kw.is(kFilterKeyword)) // handle filter
  else if (kw.is(kCleanupKeyword)) // handle cleanup
}
parseColonType(..)

Sure, I will do this.

Thanks for the comments @ftynse, @rriddle.

[shraiysh]

I have tried to address almost all the comments.

1. I did not make a builder for llvm.invoke and used the OperationState instead - because it would involve two specialised builders for just one instruction. Let me know if making both of them is worth the effort.
2. Because the clauses can have any constant and not only a global variable (bitcasts and all), I decided to save them in operands instead of an array of attributes. The verifier for llvm.invoke checks for the first llvm.landingpad instruction and makes sure that whatever operations occur before it are the ones used in the clauses. I am not sure how sound this is. I will be willing to update it in case this is flawed.

I have also updated the summary. If I missed anything, please let me know, and I will address it.

[rriddle]

Please add proper builders. Users should *not* have to use OperationState directly, it is extremely error prone and clunky.

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

333

Please move large blocks of c++ into the .cpp file.

349

Remove trivial braces. There are still quite a few remaining.

357

This loop seems fairly inefficient. Can you rework this?

363

This seems slightly incorrect. Other instructions are allowed if they feed into the landingpad.

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

431

Can you print this in a more MLIR friendly way? i.e. operand : type

448

Can we use a UnitAttr for this instead?

462

Why not just resolve the operand right here?

471

I don't see where the location is used.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

546

nit: You can elide the b.getIdentifier() and just pass the string name.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

223

This looks error prone, what is the invariant you want here?

232

nit: inline this into its use.

237

Start diagnostics with lower case

mlir/test/Dialect/LLVMIR/roundtrip.mlir

228

Please do not use SSA value names directly.

https://mlir.llvm.org/getting_started/TestingGuide/

This script can help with generating check lines, but should be stripped down to something appropriate.

https://github.com/llvm/llvm-project/blob/master/mlir/utils/generate-test-checks.py

271

Missing newline in some of these files.

[shraiysh]

I have tried to address all the comments pointed out by @rriddle . I have also made the builder for llvm.InvokeOp. Please let me know if anything else has to be done.

[shraiysh]

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

357

I have avoided this now, by processing GlobalVariable in processConstant (earlier it was in processValue) and putting it at the beginning of the basic block. So, now, the first instruction has to be a landingpad instruction.

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

471

It is used in reporting the error inside next if.

[rriddle]

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

294

Remove the newline.

300

Never use 'size' for operation/block/region lists, it is not O(1). You should be able to use getSuccessor(1)->empty() instead.

372

This should already be checked by parseType, so no need to duplicate error handling. You should be able to replace uses of 'funcType' with 'type' directly.

440

nit: auto -> Value

459

You need to check this parse method for failure.

462

The || true seems off, what invariant are you trying to capture here? Also, it is good practice to explicitly wrap optional parse methods with 'succeeded' or 'failed' to make the intent clear.

478

You shouldn't emit error for these methods, an error will already be emitted.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

523

Remove trivial braces. Also, please cache the end iterator to avoid recomputation.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

228

Is this error case captured by any of the tests? I can't seem to find where it's covered.

[shraiysh]

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

462

Actually I was trying to make parenthesis optional - but they had to be parsed if present. Hence they || true. Now, I realize that code in the current patch would lead to valid parsing of ( catch... (catch... (filter... also (which is wrong). So, in the new patch, I am making parenthesis compulsory.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

228

I have added tests for invalid IR in test/Dialect/LLVMIR/invalid.mlir. Also, I have added a verified for landingpad instruction

[shraiysh]

I realized that I had forgotten to add function personality in our dialect. I will be adding it in another patch, once this gets accepted.
Apart from that, I have tried to address all the all inline comments. Please let me know if anything has to be changed. Thanks.

[rriddle]

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

337

nit: just invoke the other build method after adding the 'callee' attribute.

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

301

atleast -> at least

303

This sentence seems incomplete.

304

->front()?

338

Use /// for top-level comments.

399

nit: Use range based for loop instead: funcType.getInputs()

411

nit: llvm::makeArrayRef(operands).drop_front()

423

nit: Can you hoist these above the 'if (isDirect)' branch so that you can change that to early exit instead?

485

'ua' looks unused.

491

Are the 'catch'/'filter' truly optional? i.e. should we emit an error if neither are present?

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

226

nit: constOperand

[shraiysh]

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

338

// was used for other functions in the file. Should I change it for all of them for uniformity?

423

addSuccessor internally is appending successor operands to result.operands and therefore, adding successor before adding operands leads to unexpected failures.

491

I have now added a check in the verifier.

[rriddle]

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

317

nit: This is unnecessary now.

438

This seems like something that should be attached as a note.

See https://mlir.llvm.org/docs/Diagnostics/ for more details

[shraiysh]

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

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

 def LLVM_SIToFPOp : LLVM_CastOp<"sitofp", "CreateSIToFP">;
 def LLVM_UIToFPOp : LLVM_CastOp<"uitofp", "CreateUIToFP">;
 def LLVM_FPToSIOp : LLVM_CastOp<"fptosi", "CreateFPToSI">;
 def LLVM_FPToUIOp : LLVM_CastOp<"fptoui", "CreateFPToUI">;
 def LLVM_FPExtOp : LLVM_CastOp<"fpext", "CreateFPExt">;
 def LLVM_FPTruncOp : LLVM_CastOp<"fptrunc", "CreateFPTrunc">;
 
 // Call-related operations.
+def LLVM_InvokeOp : LLVM_Op<"invoke", [Terminator]>,
+                    Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee,
+                               Variadic<LLVM_Type>)>,
+                    Results<(outs Variadic<LLVM_Type>)> {
+  let builders = [OpBuilder<
+    "Builder *b, OperationState &result, ArrayRef<Type> tys, "
+    "FlatSymbolRefAttr callee, ValueRange ops, Block* normal, "
+    "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
+    [{
+      result.addAttribute("callee", callee);
+      build(b, result, tys, ops, normal, normalOps, unwind, unwindOps);
+    }]>,
+    OpBuilder<
+    "Builder *b, OperationState &result, ArrayRef<Type> tys, "
+    "ValueRange ops, Block* normal, "
+    "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
+    [{
+      result.addTypes(tys);
+      result.addOperands(ops);
+      result.addSuccessor(normal, normalOps);
+      result.addSuccessor(unwind, unwindOps);
+    }]>];
+  let verifier = [{ return ::verify(*this);  }];
+  let parser = [{ return parseInvokeOp(parser, result); }];
+  let printer = [{ printInvokeOp(p, *this); }];
+}
+
+def LLVM_LandingpadOp : LLVM_OneResultOp<"landingpad">,
+                        Arguments<(ins UnitAttr:$cleanup, 
+                                       Variadic<LLVM_Type>)> {
+  let verifier = [{ return ::verify(*this); }];
+  let parser = [{ return parseLandingpadOp(parser, result); }];
+  let printer = [{ printLandingpadOp(p, *this); }];
+}
+
 def LLVM_CallOp : LLVM_Op<"call">,
                   Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                              Variadic<LLVM_Type>)>,
                   Results<(outs Variadic<LLVM_Type>)>,
                   LLVM_TwoBuilders<LLVM_OneResultOpBuilder,
                                    LLVM_ZeroResultOpBuilder> {
   let verifier = [{
     if (getNumResults() > 1)
       return emitOpError("must have 0 or 1 result");
     return success();
   }];
   let parser = [{ return parseCallOp(parser, result); }];
   let printer = [{ printCallOp(p, *this); }];
 }
 def LLVM_ExtractElementOp : LLVM_OneResultOp<"extractelement", [NoSideEffect]>,
                           Arguments<(ins LLVM_Type:$vector,
                                      LLVM_Type:$position)> {
   string llvmBuilder = [{
     $res = builder.CreateExtractElement($vector, $position);
   }];
   let builders = [OpBuilder<
     "Builder *b, OperationState &result, Value vector, Value position,"
     "ArrayRef<NamedAttribute> attrs = {}">];
   let parser = [{ return parseExtractElementOp(parser, result); }];
   let printer = [{ printExtractElementOp(p, *this); }];
 }
 def LLVM_ExtractValueOp : LLVM_OneResultOp<"extractvalue", [NoSideEffect]>,
                           Arguments<(ins LLVM_Type:$container,
                                      ArrayAttr:$position)> {
   string llvmBuilder = [{
     $res = builder.CreateExtractValue($container, extractPosition($position));
   }];
   let parser = [{ return parseExtractValueOp(parser, result); }];
   let printer = [{ printExtractValueOp(p, *this); }];
 }
let builders = [OpBuilder<
     "Value rhs", [{
       build(b, result, lhs.getType(), condition, lhs, rhs);
     }]>];
   let parser = [{ return parseSelectOp(parser, result); }];
   let printer = [{ printSelectOp(p, *this); }];
 }
 
 // Terminators.
 def LLVM_BrOp : LLVM_TerminatorOp<"br", []> {
   let parser = [{ return parseBrOp(parser, result); }];
   let printer = [{ printBrOp(p, *this); }];
 }
 def LLVM_CondBrOp : LLVM_TerminatorOp<"cond_br", []> {
   let verifier = [{
     if (getNumSuccessors() != 2)
       return emitOpError("expected exactly two successors");
     return success();

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

static ParseResult parseStoreOp(OpAsmParser &parser, OperationState &result) {
 
   if (parser.resolveOperand(value, elemTy, result.operands) ||
       parser.resolveOperand(addr, type, result.operands))
     return failure();
 
   return success();
 }
 
+///===----------------------------------------------------------------------===//
+/// Verifying/Printing/Parsing for LLVM::InvokeOp.
+///===----------------------------------------------------------------------===//
+
+static LogicalResult verify(InvokeOp op) {
+  if (op.getNumResults() > 1)
+    return op.emitOpError("must have 0 or 1 result");
+  if (op.getNumSuccessors() != 2)
+    return op.emitOpError("must have normal and unwind destinations");
+
+  if (op.getSuccessor(1)->empty())
+    return op.emitError(
+        "must have at least one operation in unwind destination");
+
+  // In unwind destination, first operation must be LandingpadOp
+  if (!isa<LandingpadOp>(op.getSuccessor(1)->front()))
+    return op.emitError("first operation in unwind destination should be a "
+                        "llvm.landingpad operation");
+
+  return success();
+}
+
+static void printInvokeOp(OpAsmPrinter &p, InvokeOp &op) {
+  auto callee = op.callee();
+  bool isDirect = callee.hasValue();
+
+  p << op.getOperationName() << ' ';
+
+  // Either function name or pointer
+  if (isDirect)
+    p.printSymbolName(callee.getValue());
+  else
+    p << op.getOperand(0);
+
+  p << '(' << op.getOperands().drop_front(isDirect ? 0 : 1) << ')';
+  p << " to ";
+  p.printSuccessorAndUseList(op.getOperation(), 0);
+  p << " unwind ";
+  p.printSuccessorAndUseList(op.getOperation(), 1);
+
+  p.printOptionalAttrDict(op.getAttrs(), {"callee"});
+
+  SmallVector<Type, 8> argTypes(
+      llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
+
+  p << " : "
+    << FunctionType::get(argTypes, op.getResultTypes(), op.getContext());
+}
+
+/// <operation> ::= `llvm.invoke` (function-id | ssa-use) `(` ssa-use-list `)`
+///                  `to` bb-id (`[` ssa-use-and-type-list `]`)?
+///                  `unwind` bb-id (`[` ssa-use-and-type-list `]`)?
+///                  attribute-dict? `:` function-type
+static ParseResult parseInvokeOp(OpAsmParser &parser, OperationState &result) {
+  SmallVector<OpAsmParser::OperandType, 8> operands;
+  FunctionType funcType;
+  SymbolRefAttr funcAttr;
+  llvm::SMLoc trailingTypeLoc;
+  Block *normalDest, *unwindDest;
+  SmallVector<Value, 4> normalOperands, unwindOperands;
+
+  // Parse an operand list that will, in practice, contain 0 or 1 operand.  In
+  // case of an indirect call, there will be 1 operand before `(`.  In case of a
+  // direct call, there will be no operands and the parser will stop at the
+  // function identifier without complaining.
+  if (parser.parseOperandList(operands))
+    return failure();
+  bool isDirect = operands.empty();
+
+  // Optionally parse a function identifier.
+  if (isDirect && parser.parseAttribute(funcAttr, "callee", result.attributes))
+    return failure();
+
+  if (parser.parseOperandList(operands, OpAsmParser::Delimiter::Paren) ||
+      parser.parseKeyword("to") ||
+      parser.parseSuccessorAndUseList(normalDest, normalOperands) ||
+      parser.parseKeyword("unwind") ||
+      parser.parseSuccessorAndUseList(unwindDest, unwindOperands) ||
+      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
+      parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(funcType))
+    return failure();
+
+  if (isDirect) {
+    // Make sure types match.
+    if (parser.resolveOperands(operands, funcType.getInputs(),
+                               parser.getNameLoc(), result.operands))
+      return failure();
+    result.addTypes(funcType.getResults());
+  } else {
+    // Construct the LLVM IR Dialect function type that the first operand
+    // should match.
+    if (funcType.getNumResults() > 1)
+      return parser.emitError(trailingTypeLoc,
+                              "expected function with 0 or 1 result");
+
+    Builder &builder = parser.getBuilder();
+    auto *llvmDialect =
+        builder.getContext()->getRegisteredDialect<LLVM::LLVMDialect>();
+    LLVM::LLVMType llvmResultType;
+    if (funcType.getNumResults() == 0) {
+      llvmResultType = LLVM::LLVMType::getVoidTy(llvmDialect);
+    } else {
+      llvmResultType = funcType.getResult(0).dyn_cast<LLVM::LLVMType>();
+      if (!llvmResultType)
+        return parser.emitError(trailingTypeLoc,
+                                "expected result to have LLVM type");
+    }
+
+    SmallVector<LLVM::LLVMType, 8> argTypes;
+    argTypes.reserve(funcType.getNumInputs());
+    for (Type ty : funcType.getInputs()) {
+      if (auto argType = ty.dyn_cast<LLVM::LLVMType>())
+        argTypes.push_back(argType);
+      else
+        return parser.emitError(trailingTypeLoc,
+                                "expected LLVM types as inputs");
+    }
+
+    auto llvmFuncType = LLVM::LLVMType::getFunctionTy(llvmResultType, argTypes,
+                                                      /*isVarArg=*/false);
+    auto wrappedFuncType = llvmFuncType.getPointerTo();
+
+    auto funcArguments = llvm::makeArrayRef(operands).drop_front();
+
+    // Make sure that the first operand (indirect callee) matches the wrapped
+    // LLVM IR function type, and that the types of the other call operands
+    // match the types of the function arguments.
+    if (parser.resolveOperand(operands[0], wrappedFuncType, result.operands) ||
+        parser.resolveOperands(funcArguments, funcType.getInputs(),
+                               parser.getNameLoc(), result.operands))
+      return failure();
+
+    result.addTypes(llvmResultType);
+  }
+  result.addSuccessor(normalDest, normalOperands);
+  result.addSuccessor(unwindDest, unwindOperands);
+  return success();
+}
+
+///===----------------------------------------------------------------------===//
+/// Verifying/Printing/Parsing for LLVM::LandingpadOp.
+///===----------------------------------------------------------------------===//
+
+static LogicalResult verify(LandingpadOp op) {
+  Value value;
+
+  if (!op.cleanup() && op.getOperands().empty())
+    return op.emitError("landingpad instruction expects at least one clause or "
+                        "cleanup attribute");
+
+  for (unsigned idx = 0, ie = op.getNumOperands(); idx < ie; idx++) {
+    value = op.getOperand(idx);
+    bool isFilter = value.getType().cast<LLVMType>().isArrayTy();
+    if (isFilter) {
+      // FIXME: Verify filter clauses when arrays are appropriately handled
+    } else {
+      // catch - global addresses only.
+      // Bitcast ops should have global addresses as their args.
+      if (auto bcOp = dyn_cast_or_null<BitcastOp>(value.getDefiningOp())) {
+        if (auto addrOp =
+                dyn_cast_or_null<AddressOfOp>(bcOp.arg().getDefiningOp()))
+          continue;
+        return op.emitError("constant clauses expected")
+                   .attachNote(bcOp.getLoc())
+               << "global addresses expected as operand to "
+                  "bitcast used in clauses for landingpad";
+      }
+      // NullOp and AddressOfOp allowed
+      if (dyn_cast_or_null<NullOp>(value.getDefiningOp()))
+        continue;
+      if (dyn_cast_or_null<AddressOfOp>(value.getDefiningOp()))
+        continue;
+      return op.emitError("clause #")
+             << idx << " is not a known constant - null, addressof, bitcast";
+    }
+  }
+  return success();
+}
+
+static void printLandingpadOp(OpAsmPrinter &p, LandingpadOp &op) {
+  p << op.getOperationName() << (op.cleanup() ? " cleanup " : " ");
+
+  // Clauses
+  for (auto value : op.getOperands()) {
+    // Similar to llvm - if clause is an array type then it is filter
+    // clause else catch clause
+    bool isArrayTy = value.getType().cast<LLVMType>().isArrayTy();
+    p << '(' << (isArrayTy ? "filter " : "catch ") << value << " : "
+      << value.getType() << ") ";
+  }
+
+  p.printOptionalAttrDict(op.getAttrs(), {"cleanup"});
+
+  p << ": " << op.getType();
+}
+
+/// <operation> ::= `llvm.landingpad` `cleanup`?
+///                 ((`catch` | `filter`) operand-type ssa-use)* attribute-dict?
+static ParseResult parseLandingpadOp(OpAsmParser &parser,
+                                     OperationState &result) {
+  // Check for cleanup
+  if (succeeded(parser.parseOptionalKeyword("cleanup")))
+    result.addAttribute("cleanup", parser.getBuilder().getUnitAttr());
+
+  // Parse clauses with types
+  while (succeeded(parser.parseOptionalLParen()) &&
+         (succeeded(parser.parseOptionalKeyword("filter")) ||
+          succeeded(parser.parseOptionalKeyword("catch")))) {
+    OpAsmParser::OperandType operand;
+    Type ty;
+    if (parser.parseOperand(operand) || parser.parseColon() ||
+        parser.parseType(ty) ||
+        parser.resolveOperand(operand, ty, result.operands) ||
+        parser.parseRParen())
+      return failure();
+  }
+
+  Type type;
+  if (parser.parseColon() || parser.parseType(type))
+    return failure();
+
+  result.addTypes(type);
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::CallOp.
 //===----------------------------------------------------------------------===//
 
 static void printCallOp(OpAsmPrinter &p, CallOp &op) {
   auto callee = op.callee();
   bool isDirect = callee.hasValue();
 

 //                 attribute-dict? `:` type
 static ParseResult parseExtractElementOp(OpAsmParser &parser,
                                          OperationState &result) {
   llvm::SMLoc loc;
   OpAsmParser::OperandType vector, position;
   Type type, positionType;
   if (parser.getCurrentLocation(&loc) || parser.parseOperand(vector) ||
       parser.parseLSquare() || parser.parseOperand(position) ||
       parser.parseColonType(positionType) || parser.parseRSquare() ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(vector, type, result.operands) ||
       parser.resolveOperand(position, positionType, result.operands))
     return failure();
   auto wrappedVectorType = type.dyn_cast<LLVM::LLVMType>();
   if (!wrappedVectorType ||
       !wrappedVectorType.getUnderlyingType()->isVectorTy())
     return parser.emitError(
         loc, "expected LLVM IR dialect vector type for operand #1");
   result.addTypes(wrappedVectorType.getVectorElementType());
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::ExtractValueOp.
 //===----------------------------------------------------------------------===//
static ParseResult parseSelectOp(OpAsmParser &parser, OperationState &result) {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::BrOp.
 //===----------------------------------------------------------------------===//
 
 static void printBrOp(OpAsmPrinter &p, BrOp &op) {
   p << op.getOperationName() << ' ';
   p.printSuccessorAndUseList(op.getOperation(), 0);
   p.printOptionalAttrDict(op.getAttrs());
 }
 
 // <operation> ::= `llvm.br` bb-id (`[` ssa-use-and-type-list `]`)?
 // attribute-dict?
 static ParseResult parseBrOp(OpAsmParser &parser, OperationState &result) {
   Block *dest;
   SmallVector<Value, 4> operands;
   if (parser.parseSuccessorAndUseList(dest, operands) ||
       parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   result.addSuccessor(dest, operands);
   return success();

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

private:
   /// Create the most accurate Location possible using a llvm::DebugLoc and
   /// possibly an llvm::Instruction to narrow the Location if debug information
   /// is unavailable.
   Location processDebugLoc(const llvm::DebugLoc &loc,
                            llvm::Instruction *inst = nullptr);
   /// `br` branches to `target`. Append the block arguments to attach to the
   /// generated branch op to `blockArguments`. These should be in the same order
   /// as the PHIs in `target`.
-  LogicalResult processBranchArgs(llvm::BranchInst *br,
+  LogicalResult processBranchArgs(llvm::Instruction *br,
                                   llvm::BasicBlock *target,
                                   SmallVectorImpl<Value> &blockArguments);
   /// Returns the standard type equivalent to be used in attributes for the
   /// given LLVM IR dialect type.
   Type getStdTypeForAttr(LLVMType type);
   /// Return `value` as an attribute to attach to a GlobalOp.
   Attribute getConstantAsAttr(llvm::Constant *value);
   /// Return `c` as an MLIR Value. This could either be a ConstantOp, or
Type Importer::getStdTypeForAttr(LLVMType type) {
   }
 
   return nullptr;
 }
 
 // Get the given constant as an attribute. Not all constants can be represented
 // as attributes.
 Attribute Importer::getConstantAsAttr(llvm::Constant *value) {
   if (auto *ci = dyn_cast<llvm::ConstantInt>(value))
     return b.getIntegerAttr(
         IntegerType::get(ci->getType()->getBitWidth(), context),
         ci->getValue());
   if (auto *c = dyn_cast<llvm::ConstantDataArray>(value))
     if (c->isString())
       return b.getStringAttr(c->getAsString());
   if (auto *c = dyn_cast<llvm::ConstantFP>(value)) {
     if (c->getType()->isDoubleTy())
       return b.getFloatAttr(FloatType::getF64(context), c->getValueAPF());
     else if (c->getType()->isFloatingPointTy())
       return b.getFloatAttr(FloatType::getF32(context), c->getValueAPF());
   }
   if (auto *f = dyn_cast<llvm::Function>(value))
if (GV->hasInitializer() && !valueAttr) {
     if (!v)
       return nullptr;
     b.create<ReturnOp>(op.getLoc(), ArrayRef<Value>({v}));
   }
   return globals[GV] = op;
 }
 
 Value Importer::processConstant(llvm::Constant *c) {
+  OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
   if (Attribute attr = getConstantAsAttr(c)) {
     // These constants can be represented as attributes.
     OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
     LLVMType type = processType(c->getType());
     if (!type)
       return nullptr;
-    return instMap[c] = b.create<ConstantOp>(unknownLoc, type, attr);
+    return instMap[c] = bEntry.create<ConstantOp>(unknownLoc, type, attr);
   }
   if (auto *cn = dyn_cast<llvm::ConstantPointerNull>(c)) {
-    OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
     LLVMType type = processType(cn->getType());
     if (!type)
       return nullptr;
-    return instMap[c] = b.create<NullOp>(unknownLoc, type);
+    return instMap[c] = bEntry.create<NullOp>(unknownLoc, type);
   }
+  if (auto *GV = dyn_cast<llvm::GlobalVariable>(c))
+    return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
+                                      processGlobal(GV),
+                                      ArrayRef<NamedAttribute>());
+
   if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
     llvm::Instruction *i = ce->getAsInstruction();
     OpBuilder::InsertionGuard guard(b);
     b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     if (failed(processInstruction(i)))
       return nullptr;
     assert(instMap.count(i));
 
if (isa<llvm::Instruction>(value)) {
     LLVMType type = processType(value->getType());
     if (!type)
       return nullptr;
     state.addTypes(type);
     unknownInstMap[value] = b.createOperation(state);
     return unknownInstMap[value]->getResult(0);
   }
 
-  if (auto *GV = dyn_cast<llvm::GlobalVariable>(value)) {
-    auto global = processGlobal(GV);
-    if (!global)
-      return nullptr;
-    return b.create<AddressOfOp>(UnknownLoc::get(context), global,
-                                 ArrayRef<NamedAttribute>());
-  }
-
-  // Note, constant global variables are both GlobalVariables and Constants,
-  // so we handle GlobalVariables first above.
   if (auto *c = dyn_cast<llvm::Constant>(value))
     return processConstant(c);
 
   emitError(unknownLoc) << "unhandled value: " << diag(*value);
   return nullptr;
 }
 
 // Maps from LLVM opcode to MLIR OperationName. This is deliberately ordered
static const DenseMap<unsigned, StringRef> opcMap = {
     INST(Trunc, Trunc), INST(ZExt, ZExt), INST(SExt, SExt),
     INST(FPToUI, FPToUI), INST(FPToSI, FPToSI), INST(UIToFP, UIToFP),
     INST(SIToFP, SIToFP), INST(FPTrunc, FPTrunc), INST(FPExt, FPExt),
     INST(PtrToInt, PtrToInt), INST(IntToPtr, IntToPtr), INST(BitCast, Bitcast),
     INST(AddrSpaceCast, AddrSpaceCast),
     // FIXME: cleanuppad
     // FIXME: catchpad
     // ICmp is handled specially.
     // FIXME: fcmp
     // PHI is handled specially.
     INST(Call, Call),
     // FIXME: select
     // FIXME: vaarg
     // FIXME: extractelement
     // FIXME: insertelement
     // FIXME: shufflevector
     // FIXME: extractvalue
     // FIXME: insertvalue
     // FIXME: landingpad
 };
 #undef INST
 
 static ICmpPredicate getICmpPredicate(llvm::CmpInst::Predicate p) {
   switch (p) {
   default:
     llvm_unreachable("incorrect comparison predicate");
   case llvm::CmpInst::Predicate::ICMP_EQ:
     return LLVM::ICmpPredicate::eq;
   case llvm::CmpInst::Predicate::ICMP_NE:
     return LLVM::ICmpPredicate::ne;
   case llvm::CmpInst::Predicate::ICMP_SLT:
     return LLVM::ICmpPredicate::slt;
   case llvm::CmpInst::Predicate::ICMP_SLE:
     return LLVM::ICmpPredicate::sle;
   case llvm::CmpInst::Predicate::ICMP_SGT:
     return LLVM::ICmpPredicate::sgt;
   case llvm::CmpInst::Predicate::ICMP_SGE:
     return LLVM::ICmpPredicate::sge;
   case llvm::CmpInst::Predicate::ICMP_ULT:
     return LLVM::ICmpPredicate::ult;
   case llvm::CmpInst::Predicate::ICMP_ULE:
     return LLVM::ICmpPredicate::ule;
   case llvm::CmpInst::Predicate::ICMP_UGT:
     return LLVM::ICmpPredicate::ugt;
   case llvm::CmpInst::Predicate::ICMP_UGE:
     return LLVM::ICmpPredicate::uge;
   }
   llvm_unreachable("incorrect comparison predicate");
 }
 
 // `br` branches to `target`. Return the branch arguments to `br`, in the
 // same order of the PHIs in `target`.
 LogicalResult
-Importer::processBranchArgs(llvm::BranchInst *br, llvm::BasicBlock *target,
+Importer::processBranchArgs(llvm::Instruction *br, llvm::BasicBlock *target,
                             SmallVectorImpl<Value> &blockArguments) {
   for (auto inst = target->begin(); isa<llvm::PHINode>(inst); ++inst) {
     auto *PN = cast<llvm::PHINode>(&*inst);
     Value value = processValue(PN->getIncomingValueForBlock(br->getParent()));
     if (!value)
       return failure();
     blockArguments.push_back(value);
   }
if (llvm::Function *callee = ci->getCalledFunction()) {
         return failure();
       ops.insert(ops.begin(), calledValue);
       op = b.create<CallOp>(loc, tys, ops, ArrayRef<NamedAttribute>());
     }
     if (!ci->getType()->isVoidTy())
       v = op->getResult(0);
     return success();
   }
+  case llvm::Instruction::LandingPad: {
+    llvm::LandingPadInst *lpi = cast<llvm::LandingPadInst>(inst);
+    SmallVector<Value, 4> ops;
+
+    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);
+    return success();
+  }
+  case llvm::Instruction::Invoke: {
+    llvm::InvokeInst *ii = cast<llvm::InvokeInst>(inst);
+
+    SmallVector<Type, 2> tys;
+    if (!ii->getType()->isVoidTy())
+      tys.push_back(processType(inst->getType()));
+
+    SmallVector<Value, 4> ops;
+    ops.reserve(inst->getNumOperands() + 1);
+    for (auto &op : ii->arg_operands())
+      ops.push_back(processValue(op.get()));
+
+    SmallVector<Value, 4> normalArgs, unwindArgs;
+    processBranchArgs(ii, ii->getNormalDest(), normalArgs);
+    processBranchArgs(ii, ii->getUnwindDest(), unwindArgs);
+
+    Operation *op;
+    if (llvm::Function *callee = ii->getCalledFunction()) {
+      op = b.create<InvokeOp>(loc, tys, b.getSymbolRefAttr(callee->getName()),
+                              ops, blocks[ii->getNormalDest()], normalArgs,
+                              blocks[ii->getUnwindDest()], unwindArgs);
+    } else {
+      ops.insert(ops.begin(), processValue(ii->getCalledValue()));
+      op = b.create<InvokeOp>(loc, tys, ops, blocks[ii->getNormalDest()],
+                              normalArgs, blocks[ii->getUnwindDest()],
+                              unwindArgs);
+    }
+
+    if (!ii->getType()->isVoidTy())
+      v = op->getResult(0);
+    return success();
+  }
   case llvm::Instruction::GetElementPtr: {
     // FIXME: Support inbounds GEPs.
     llvm::GetElementPtrInst *gep = cast<llvm::GetElementPtrInst>(inst);
     SmallVector<Value, 4> ops;
     for (auto *op : gep->operand_values()) {
       Value value = processValue(op);
       if (!value)
         return failure();
       ops.push_back(value);
     }
     Type type = processType(inst->getType());
     if (!type)
       return failure();
     v = b.create<GEPOp>(loc, type, ops, ArrayRef<NamedAttribute>());
     return success();
   }
   }
 }
 
 LogicalResult Importer::processFunction(llvm::Function *f) {
   blocks.clear();
   instMap.clear();
   unknownInstMap.clear();
 
   LLVMType functionType = processType(f->getFunctionType());
   if (!functionType)
     return failure();
 
   b.setInsertionPoint(module.getBody(), getFuncInsertPt());
   LLVMFuncOp fop = b.create<LLVMFuncOp>(UnknownLoc::get(context), f->getName(),
                                         functionType);
   if (f->isDeclaration())
     return success();
 
   // Eagerly create all blocks.
   SmallVector<Block *, 4> blockList;
   for (llvm::BasicBlock &bb : *f) {
     blockList.push_back(b.createBlock(&fop.body(), fop.body().end()));
     blocks[&bb] = blockList.back();
   }
   currentEntryBlock = blockList[0];
 
   // Add function arguments to the entry block.
   for (auto kv : llvm::enumerate(f->args()))
     instMap[&kv.value()] = blockList[0]->addArgument(
         functionType.getFunctionParamType(kv.index()));
 
   for (auto bbs : llvm::zip(*f, blockList)) {

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

static llvm::AtomicRMWInst::BinOp getLLVMAtomicBinOp(AtomicBinOp op) {
   switch (op) {
   case LLVM::AtomicBinOp::xchg:
     return llvm::AtomicRMWInst::BinOp::Xchg;
   case LLVM::AtomicBinOp::add:
     return llvm::AtomicRMWInst::BinOp::Add;
   case LLVM::AtomicBinOp::sub:
     return llvm::AtomicRMWInst::BinOp::Sub;
   case LLVM::AtomicBinOp::_and:
     return llvm::AtomicRMWInst::BinOp::And;
   case LLVM::AtomicBinOp::nand:
     return llvm::AtomicRMWInst::BinOp::Nand;
   case LLVM::AtomicBinOp::_or:
     return llvm::AtomicRMWInst::BinOp::Or;
   case LLVM::AtomicBinOp::_xor:
     return llvm::AtomicRMWInst::BinOp::Xor;
   case LLVM::AtomicBinOp::max:
     return llvm::AtomicRMWInst::BinOp::Max;
   case LLVM::AtomicBinOp::min:
     return llvm::AtomicRMWInst::BinOp::Min;
   case LLVM::AtomicBinOp::umax:
     return llvm::AtomicRMWInst::BinOp::UMax;
   case LLVM::AtomicBinOp::umin:
     return llvm::AtomicRMWInst::BinOp::UMin;
   case LLVM::AtomicBinOp::fadd:
     return llvm::AtomicRMWInst::BinOp::FAdd;
   case LLVM::AtomicBinOp::fsub:
     return llvm::AtomicRMWInst::BinOp::FSub;
   }
   llvm_unreachable("incorrect atomic binary operator");
 }
 
if (isa<LLVM::CallOp>(opInst)) {
     if (opInst.getNumResults() != 0) {
       valueMapping[opInst.getResult(0)] = result;
       return success();
     }
     // Check that LLVM call returns void for 0-result functions.
     return success(result->getType()->isVoidTy());
   }
 
+  if (auto invOp = dyn_cast<LLVM::InvokeOp>(opInst)) {
+    auto operands = lookupValues(opInst.getOperands());
+    ArrayRef<llvm::Value *> operandsRef(operands);
+    if (auto attr = opInst.getAttrOfType<FlatSymbolRefAttr>("callee"))
+      builder.CreateInvoke(functionMapping.lookup(attr.getValue()),
+                           blockMapping[invOp.getSuccessor(0)],
+                           blockMapping[invOp.getSuccessor(1)], operandsRef);
+    else
+      builder.CreateInvoke(
+          operandsRef.front(), blockMapping[invOp.getSuccessor(0)],
+          blockMapping[invOp.getSuccessor(1)], operandsRef.drop_front());
+    return success();
+  }
+
+  if (auto lpOp = dyn_cast<LLVM::LandingpadOp>(opInst)) {
+    llvm::Type *ty = lpOp.getType().dyn_cast<LLVMType>().getUnderlyingType();
+    llvm::LandingPadInst *lpi =
+        builder.CreateLandingPad(ty, lpOp.getNumOperands());
+
+    // Add clauses
+    for (auto operand : lookupValues(lpOp.getOperands())) {
+      // All operands should be constant - checked by verifier
+      if (auto constOperand = dyn_cast<llvm::Constant>(operand))
+        lpi->addClause(constOperand);
+    }
+    return success();
+  }
+
   // Emit branches.  We need to look up the remapped blocks and ignore the block
   // arguments that were transformed into PHI nodes.
   if (auto brOp = dyn_cast<LLVM::BrOp>(opInst)) {
     builder.CreateBr(blockMapping[brOp.getSuccessor(0)]);
     return success();
   }
   if (auto condbrOp = dyn_cast<LLVM::CondBrOp>(opInst)) {
     builder.CreateCondBr(valueMapping.lookup(condbrOp.getOperand(0)),

mlir/test/Dialect/LLVMIR/invalid.mlir

 // -----
 
 // CHECK-LABEL: @cmpxchg_failure_acq_rel
 func @cmpxchg_failure_acq_rel(%i32_ptr : !llvm<"i32*">, %i32 : !llvm.i32) {
   // expected-error@+1 {{failure ordering cannot be 'release' or 'acq_rel'}}
   %0 = llvm.cmpxchg %i32_ptr, %i32, %i32 acq_rel acq_rel : !llvm.i32
   llvm.return
 }
+
+// -----
+
+llvm.func @foo(!llvm.i32) -> !llvm.i32
+llvm.func @__gxx_personality_v0(...) -> !llvm.i32
+
+llvm.func @bad_landingpad(%arg0: !llvm<"i8**">) {
+  %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
+^bb1:  // pred: ^bb0
+  llvm.return %1 : !llvm.i32
+^bb2:  // pred: ^bb0
+  // expected-error@+1 {{clause #0 is not a known constant - null, addressof, bitcast}}
+  %3 = llvm.landingpad cleanup (catch %1 : !llvm.i32) (catch %arg0 : !llvm<"i8**">) : !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 {
+  %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}}
+  %2 = llvm.bitcast %1 : !llvm<"i8**"> to !llvm<"i8*">
+  %3 = 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 {{constant clauses expected}}
+  %5 = llvm.landingpad (catch %2 : !llvm<"i8*">) : !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 {
+  %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 {{landingpad instruction expects at least one clause or cleanup attribute}}
+  %2 = llvm.landingpad : !llvm<"{ i8*, i32 }">
+  llvm.return %0 : !llvm.i32
+}

mlir/test/Dialect/LLVMIR/roundtrip.mlir

 }
 
 // CHECK-LABEL: @atomicrmw
 func @atomicrmw(%ptr : !llvm<"float*">, %val : !llvm.float) {
   // CHECK: llvm.atomicrmw fadd %{{.*}}, %{{.*}} unordered : !llvm.float
   %0 = llvm.atomicrmw fadd %ptr, %val unordered : !llvm.float
   llvm.return
 }
 
 // CHECK-LABEL: @cmpxchg
 func @cmpxchg(%ptr : !llvm<"float*">, %cmp : !llvm.float, %new : !llvm.float) {
   // CHECK: llvm.cmpxchg %{{.*}}, %{{.*}}, %{{.*}} acq_rel monotonic : !llvm.float
   %0 = llvm.cmpxchg %ptr, %cmp, %new acq_rel monotonic : !llvm.float
   llvm.return
 }
+
+llvm.mlir.global external constant @_ZTIi() : !llvm<"i8*">
+llvm.func @bar(!llvm<"i8*">, !llvm<"i8*">, !llvm<"i8*">)
+llvm.func @__gxx_personality_v0(...) -> !llvm.i32
+
+// CHECK-LABEL: @invokeLandingpad
+llvm.func @invokeLandingpad() -> !llvm.i32 {
+// 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]">
+// CHECK-NEXT: %[[a3:[0-9]+]] = llvm.mlir.null : !llvm<"i8**">
+// CHECK-NEXT: %[[a4:[0-9]+]] = llvm.mlir.null : !llvm<"i8*">
+// CHECK-NEXT: %[[a5:[0-9]+]] = llvm.mlir.addressof @_ZTIi : !llvm<"i8**">
+// CHECK-NEXT: %[[a6:[0-9]+]] = llvm.bitcast %[[a5]] : !llvm<"i8**"> to !llvm<"i8*">
+// CHECK-NEXT: %[[a7:[0-9]+]] = llvm.mlir.constant(1 : i32) : !llvm.i32
+// CHECK-NEXT: %[[a8:[0-9]+]] = llvm.alloca %[[a7]] x !llvm.i8 : (!llvm.i32) -> !llvm<"i8*">
+// CHECK-NEXT: %{{[0-9]+}} = llvm.invoke @foo(%[[a7]]) to ^bb2 unwind ^bb1 : (!llvm.i32) -> !llvm<"{ i32, double, i32 }">
+  %0 = llvm.mlir.constant(0 : i32) : !llvm.i32
+  %1 = llvm.mlir.constant(3 : i32) : !llvm.i32
+  %2 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]">
+  %3 = llvm.mlir.null : !llvm<"i8**">
+  %4 = llvm.mlir.null : !llvm<"i8*">
+  %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**">
+  %6 = llvm.bitcast %5 : !llvm<"i8**"> to !llvm<"i8*">
+  %7 = llvm.mlir.constant(1 : i32) : !llvm.i32
+  %8 = llvm.alloca %7 x !llvm.i8 : (!llvm.i32) -> !llvm<"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
+^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
+
+// CHECK-NEXT: ^bb2:
+// CHECK-NEXT:   llvm.return %[[a7]] : !llvm.i32
+^bb2:
+  llvm.return %7 : !llvm.i32
+
+// CHECK-NEXT: ^bb3:
+// CHECK-NEXT:   llvm.invoke @bar(%[[a8]], %[[a6]], %[[a4]]) to ^bb2 unwind ^bb1 : (!llvm<"i8*">, !llvm<"i8*">, !llvm<"i8*">) -> ()
+^bb3:
+  llvm.invoke @bar(%8, %6, %4) to ^bb2 unwind ^bb1 : (!llvm<"i8*">, !llvm<"i8*">, !llvm<"i8*">) -> ()
+
+// CHECK-NEXT: ^bb4:
+// CHECK-NEXT:   llvm.return %[[a0]] : !llvm.i32
+^bb4:
+  llvm.return %0 : !llvm.i32
+}

mlir/test/Target/import.ll

 ; CHECK-DAG: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : !llvm.i32
 ; CHECK-DAG: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : !llvm.i32
 ; CHECK-DAG: %[[c1:[0-9]+]] = llvm.mlir.constant(1 : i1) : !llvm.i1
 ; CHECK-DAG: %[[c43:[0-9]+]] = llvm.mlir.constant(43 : i32) : !llvm.i32
 define internal dso_local i32 @f1(i64 %a) norecurse {
 entry:
 ; CHECK: %{{[0-9]+}} = llvm.inttoptr %arg0 : !llvm.i64 to !llvm<"i64*">
   %aa = inttoptr i64 %a to i64*
-; CHECK: %[[addrof:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm<"double*">
-; CHECK: %{{[0-9]+}} = llvm.ptrtoint %[[addrof]] : !llvm<"double*"> to !llvm.i64
+; %[[addrof:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm<"double*">
+; %[[addrof2:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm<"double*">
+; %{{[0-9]+}} = llvm.inttoptr %arg0 : !llvm.i64 to !llvm<"i64*">
+; %{{[0-9]+}} = llvm.ptrtoint %[[addrof2]] : !llvm<"double*"> to !llvm.i64
+; %{{[0-9]+}} = llvm.getelementptr %[[addrof]][%3] : (!llvm<"double*">, !llvm.i32) -> !llvm<"double*">
   %bb = ptrtoint double* @g2 to i64
-; CHECK-DAG: %[[addrof2:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm<"double*">
-; CHECK: %{{[0-9]+}} = llvm.getelementptr %[[addrof2]][%[[c2]]] : (!llvm<"double*">, !llvm.i32) -> !llvm<"double*">
   %cc = getelementptr double, double* @g2, i32 2
 ; CHECK: %[[b:[0-9]+]] = llvm.trunc %arg0 : !llvm.i64 to !llvm.i32
   %b = trunc i64 %a to i32
 ; CHECK: %[[c:[0-9]+]] = llvm.call @fe(%[[b]]) : (!llvm.i32) -> !llvm.float
   %c = call float @fe(i32 %b)
 ; CHECK: %[[d:[0-9]+]] = llvm.fptosi %[[c]] : !llvm.float to !llvm.i32
   %d = fptosi float %c to i32
 ; FIXME: icmp should return i1.
define i32 @postcaller() {
   ; CHECK: llvm.store %[[func]], %[[loc:.*]]
   store i32 ()* @callee, i32 ()** %1
   ; CHECK: %[[indir:.*]] = llvm.load %[[loc]]
   %2 = load i32 ()*, i32 ()** %1
   ; CHECK: llvm.call %[[indir]]()
   %3 = call i32 %2()
   ret i32 %3
 }
+
+@_ZTIi = external dso_local constant i8*
+@_ZTIii= external dso_local constant i8**
+declare void @foo(i8*)
+declare i8* @bar(i8*)
+declare i32 @__gxx_personality_v0(...)
+
+; CHECK-LABEL: @invokeLandingpad
+define i32 @invokeLandingpad() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+  ; CHECK: %[[a1:[0-9]+]] = llvm.bitcast %{{[0-9]+}} : !llvm<"i8***"> to !llvm<"i8*">
+  ; CHECK: %[[a3:[0-9]+]] = llvm.alloca %{{[0-9]+}} x !llvm.i8 : (!llvm.i32) -> !llvm<"i8*">
+  %1 = alloca i8
+  ; CHECK: llvm.invoke @foo(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm<"i8*">) -> ()
+  invoke void @foo(i8* %1) to label %4 unwind label %2
+
+; CHECK: ^bb1:
+  ; CHECK: %{{[0-9]+}} = llvm.landingpad (catch %{{[0-9]+}} : !llvm<"i8**">) (catch %[[a1]] : !llvm<"i8*">) (filter %{{[0-9]+}} : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }">
+  %3 = landingpad { i8*, i32 } catch i8** @_ZTIi catch i8* bitcast (i8*** @_ZTIii to i8*)
+  ; 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
+
+; CHECK: ^bb2:
+  ; CHECK: llvm.return %{{[0-9]+}} : !llvm.i32
+  ret i32 1
+
+; CHECK: ^bb3:
+  ; CHECK: %{{[0-9]+}} = llvm.invoke @bar(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm<"i8*">) -> !llvm<"i8*">
+  %6 = invoke i8* @bar(i8* %1) to label %4 unwind label %2
+
+; CHECK: ^bb4:
+  ; CHECK: llvm.return %{{[0-9]+}} : !llvm.i32
+  ret i32 0
+}

mlir/test/Target/llvmir.mlir

llvm.func @cmpxchg(%ptr : !llvm<"float*">, %cmp : !llvm.float, %val: !llvm.float) {
   // CHECK: cmpxchg float* %{{.*}}, float %{{.*}}, float %{{.*}} acq_rel monotonic
   %0 = llvm.cmpxchg %ptr, %cmp, %val acq_rel monotonic : !llvm.float
   // CHECK: %{{[0-9]+}} = extractvalue { float, i1 } %{{[0-9]+}}, 0
   %1 = llvm.extractvalue %0[0] : !llvm<"{ float, i1 }">
   // CHECK: %{{[0-9]+}} = extractvalue { float, i1 } %{{[0-9]+}}, 1
   %2 = llvm.extractvalue %0[1] : !llvm<"{ float, i1 }">
   llvm.return
 }
+
+llvm.mlir.global external constant @_ZTIi() : !llvm<"i8*">
+llvm.func @foo(!llvm<"i8*">)
+llvm.func @bar(!llvm<"i8*">) -> !llvm<"i8*">
+llvm.func @__gxx_personality_v0(...) -> !llvm.i32
+
+// CHECK-LABEL: @invokeLandingpad
+llvm.func @invokeLandingpad() -> !llvm.i32 {
+// CHECK: %[[a1:[0-9]+]] = alloca i8
+  %0 = llvm.mlir.constant(0 : i32) : !llvm.i32
+  %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]">
+  %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**">
+  %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*">
+  %4 = llvm.mlir.null : !llvm<"i8**">
+  %5 = llvm.mlir.constant(1 : i32) : !llvm.i32
+  %6 = llvm.alloca %5 x !llvm.i8 : (!llvm.i32) -> !llvm<"i8*">
+// CHECK: invoke void @foo(i8* %[[a1]])
+// CHECK-NEXT: to label %[[normal:[0-9]+]] unwind label %[[unwind:[0-9]+]]
+  llvm.invoke @foo(%6) to ^bb2 unwind ^bb1 : (!llvm<"i8*">) -> ()
+
+// CHECK: [[unwind]]:
+^bb1:
+// CHECK: %{{[0-9]+}} = landingpad { i8*, i32 }
+// CHECK-NEXT:             catch i8** null
+// CHECK-NEXT:             catch i8* bitcast (i8** @_ZTIi to i8*)
+// CHECK-NEXT:             filter [1 x i8] c"\01"
+  %7 = llvm.landingpad (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }">
+// CHECK: br label %[[final:[0-9]+]]
+  llvm.br ^bb3
+
+// CHECK: [[normal]]:
+// CHECK-NEXT: ret i32 1
+^bb2: // 2 preds: ^bb0, ^bb3
+  llvm.return %5 : !llvm.i32
+
+// CHECK: [[final]]:
+// CHECK-NEXT: %{{[0-9]+}} = invoke i8* @bar(i8* %[[a1]])
+// CHECK-NEXT:          to label %[[normal]] unwind label %[[unwind]]
+^bb3: // pred: ^bb1
+  %8 = llvm.invoke @bar(%6) to ^bb2 unwind ^bb1 : (!llvm<"i8*">) -> !llvm<"i8*">
+}