Add LLVM-C interface for Windows x64 SEH instructions

[Wallbraker]

Summary

This patch is orignally made by Nick Barnes, adapted by Bernard Helyer and finally submitted in its current form by Jakob Bornecrantz.

The LLVM-C interface provides no means to construct catchswitch, catchpad, catchret, cleanuppad, or cleanupret instructions, or to attach a funclet operand bundle to call or invoke instructions (which is required in cleanuppad blocks).

This patch provides the most basic functionality, and is sufficient for the project I'm working on. More could be done, but this much is required to get anywhere.

[Wallbraker]

Updated diff from Bernard.

[bhelyer]

I didn't know how to not make clang-format chew everything up, so I've tried to match the surrounding format as much as possible. I'm not super knowledgeable on the EH stuff, or LLVM's test suite, so it's very likely that I've made a mistake somewhere in adding to echo.cpp, but everything seems to work.

[deadalnix]

Please use arc to submit patches, without it there is no contaxt and it is very hard to review.

[Wallbraker]

This comment was removed by Wallbraker.

[Wallbraker]

This comment was removed by Wallbraker.

[Wallbraker]

Adding newline to end of file.

[deadalnix]

tools/llvm-c-test/echo.cpp

626

See for instance how it is done for calls.

671

It's actually quite surprising that this works at all. You need to use CloneValue to clone values (!) from the old module to the new one.

[Wallbraker]

tools/llvm-c-test/echo.cpp

671

If I change this here to:
Args.push_back(CloneValue(LLVMGetOperand(Src, i)));

I get this from the test, when llvm-c-test --echo
LLVM ERROR: Expected a constant expression

698

And this here to:
Args.push_back(CloneValue(LLVMGetOperand(Src, i)));

[Wallbraker]

Added the CloneValue call and it now passes the test again. I had to add
ConstantTokenNone and ConstantNullPointer to the clone_constant_imple
function.

Now the only thing remaining is if we should keep the non-context version
of the LLVMConstTokenNone.

[deadalnix]

include/llvm-c/Core.h

1481

Please don't add version without context. This is deprecated.

2838

Please fix indentation.

2846

This name is too generic. Please use a more specific name.

2856

For all these function, the formatting is not right. It should be

LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CleanupPad,
                                 LLVMBasicBlockRef UnwindBB);

to follow LLVM style. Same goes for others.

3032

dito

lib/IR/Core.cpp

2469

There is no test for this. Is it useful at all ?

2515

unwrap(Args, NumArgs);

2524

dito

2537

This line is more than 80 chars long.

2540

one empty line

test/Bindings/llvm-c/seh.ll

21

There need to be cleanuppad with various combination of option here not just one.

25

dito

28

dito

tools/llvm-c-test/echo.cpp

664

This isn't an int.

667

clone.

677

Clone

678

clone

682

clone

685

Use a meaningful name.

686

clone

688

clone

692

wrong type

695

clone

703

clone

704

clone

[Wallbraker]

include/llvm-c/Core.h

1481

What should I call the function that I keep, LLVMConstTokenNoneInContext or LLVMConstTokenNone?

[bhelyer]

tools/llvm-c-test/echo.cpp

664

The return value on GetNumOperands is, in fact, an int

http://llvm.org/doxygen/group__LLVMCCoreValueUser.html#ga2ad633a6afc7906f1afe329f244240f6

I can see the argument on GetOperand isn't, so I imagine this is the case of an incorrect declaration, should we fix that in this too?

[Wallbraker]

Fixes for Core.[cpp|h] files.

[Wallbraker]

lib/IR/Core.cpp

2515

That fails to compile, any ideas?

[deadalnix]

include/llvm-c/Core.h

1481

I think LLVMConstTokenNone is fine. The InContext is a bit redundant.

[deadalnix]

lib/IR/Core.cpp

2515

Never mind, this overload exists only with the downcast version of unwrap. This is fine.

tools/llvm-c-test/echo.cpp

664

Hum, that's surprising, and I don't think anyone is expecting a negative number of argument. We'll fix it in the API at some point, but that's outside the scope of this diff. Let's just use an unsigned here.

[bhelyer]

lib/IR/Core.cpp

2469

It seems to mirror LLVMBuildCallInPad. I'd be lying if I said I understood what either is for, and neither is tested. So I'm not sure what to do about it.

[deadalnix]

lib/IR/Core.cpp

2469

Let's just remove them. If someone is missing it, then we'll discover what it is for :)

[NickBarnes]

lib/IR/Core.cpp

2469

They are for calling an outlined 'finally' clause from inside a cleanuppad. Call and Invoke inside a funclet have to have funclet operand bundles, it says so in the doc.

[NickBarnes]

Sorry to be off the case for so long; I've been working on another project. Great to see that this is being taken up. The compiler I first wrote this for is now functionally complete, using (broadly) the same patch I originally submitted here on top of 3.9.1. What can I usefully do now that I'm back on this?

[NickBarnes]

lib/IR/Core.cpp

2469

http://llvm.org/docs/LangRef.html says:
"If any funclet EH pads have been “entered” but not “exited” (per the description in the EH doc), it is undefined behavior to execute a call or invoke which:

does not have a "funclet" bundle and is not a call to a nounwind intrinsic, or
has a "funclet" bundle whose operand is not the most-recently-entered not-yet-exited funclet EH pad."

[deadalnix]

lib/IR/Core.cpp

2469

Is funclet the only thing that can be into the bundle ? Of it is then that's a bit weird a bundle is needed in the first place, and if it isn't I think the API needs to be reworked.

[bhelyer]

In D30356#688421, @NickBarnes wrote:

Sorry to be off the case for so long; I've been working on another project. Great to see that this is being taken up. The compiler I first wrote this for is now functionally complete, using (broadly) the same patch I originally submitted here on top of 3.9.1. What can I usefully do now that I'm back on this?

Well, I'm out of my depth regarding the actual test file (seh.ll). It would be much better if someone that actually knew what was involved in exception handling expanded it per @deadalnix's suggestion.

[Wallbraker]

Last update from Bernard.

[Wallbraker]

I think that's the last of the changes needed for the echo.cpp files, can we agree on something for the LLVMBuildCallInPad function and have somebody that knows more of what the IR should look like comment on the IR file.

[Wallbraker]

Only spotted one case of a Value not being cloned. Others use DeclareBB.

[NickBarnes]

Compiling this with Clang generates a call instruction with a funclet operand bundle, of the same sort that I need to be able to make with LLVMBuildCallInPad(). LLVMBuildInvokeInPad() is analogous.

extern void a(void);
extern void b(void);

void c(void) {
    __try {
        a();
    } __finally {
        b();
    }
}

With Clang 3.9.1, -O3, that produces this. Note the line with "funclet" (the results without -O3 are similar but lengthier).

; ModuleID = 'finally.c'
source_filename = "finally.c"
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215"

; Function Attrs: nounwind uwtable
define i32 @main() local_unnamed_addr #0 personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
  invoke void @a() #2
          to label %1 unwind label %2

; <label>:1:                                      ; preds = %0
  tail call void @b() #3
  ret i32 0

; <label>:2:                                      ; preds = %0
  %3 = cleanuppad within none []
  tail call void @b() #3 [ "funclet"(token %3) ]
  cleanupret from %3 unwind to caller
}

declare void @b() local_unnamed_addr #1

declare void @a() local_unnamed_addr #1

declare i32 @__C_specific_handler(...)

attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #2 = { noinline }
attributes #3 = { nounwind }

!llvm.module.flags = !{!0}
!llvm.ident = !{!1}

!0 = !{i32 1, !"PIC Level", i32 2}
!1 = !{!"clang version 3.9.1 (branches/release_39)"}

I am willing to hack on this llvm-c-test, but the LLVM project pages are unclear about the pre-requisites for testing. It says that I need GnuWin32, but does not specify which GnuWin32 packages. There are about 100....

[deadalnix]

Alright, so it looks like the situation is unclear on the funclet thing. Let split that part out in another diff, so we can get what is already in good shape in.

I think the test file could be improved, by putting various combinations of parameters for the different operations. The overall thing doesn't need to be realistic or be useful in any way, just exercise the different possibilities.

include/llvm-c/Core.h

2839

Ok let's remove this guy and figure out the situation in another diff.

tools/llvm-c-test/echo.cpp

664

This is called OpCount in other cases, let's just use the same name all over the place.

[bhelyer]

In D30356#689600, @NickBarnes wrote:

I am willing to hack on this llvm-c-test, but the LLVM project pages are unclear about the pre-requisites for testing. It says that I need GnuWin32, but does not specify which GnuWin32 packages. There are about 100....

llvm-c-test itself will compile just with MSVC. The test suite uses things like diff and generally seems to assume a unixy environment, but you can actually just check that the output matches using fc seh.ll.orig seh.ll.echo in place of the diff line, and then someone else here (me or whoever) can check that the tests all work in a *nix environment.

[bhelyer]

I was just checking everything was working by running this batch file in the test folder, and once I was happy I checked in a Linux VM.

@echo off
..\..\..\build\Debug\bin\llvm-as.exe < seh.ll | ..\..\..\build\Debug\bin\llvm-dis.exe > seh.ll.orig
..\..\..\build\Debug\bin\llvm-as.exe < seh.ll | ..\..\..\build\Debug\bin\llvm-c-test.exe --echo > seh.ll.echo
fc seh.ll.orig seh.ll.echo

(with the ..\..\..\build\Debug\bin\ replaced with a path to wherever your build folder is)

[NickBarnes]

OK, I've got this working in my tree now. The test doesn't test funclet operand bundles ("...InPad") and if extended to test those then it fails (see comment to line 20 in seh.ll).

test/Bindings/llvm-c/seh.ll

21

Add "call void @g() [ "funclet"(token %0) ]" after this line to test the funclet operand bundle functionality.

[Wallbraker]

This has is already in the C API now, so closing.

[Wallbraker]

See D45100.

include/llvm-c/Core.h

 
 /**
  * Obtain a constant that is a constant pointer pointing to NULL for a
  * specified type.
  */
 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
 
 /**
+ * Obtain the constant token "none", used in SEH instructions.
+ */
+LLVMValueRef LLVMConstTokenNone(LLVMContextRef C);
+
+/**
  * @defgroup LLVMCCoreValueConstantScalar Scalar constants
  *
  * Functions in this group model LLVMValueRef instances that correspond
  * to constants referring to scalar types.
  *
  * For integer types, the LLVMTypeRef parameter should correspond to a
  * llvm::IntegerType instance and the returned LLVMValueRef will
  * correspond to a llvm::ConstantInt.

 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
                              LLVMBasicBlockRef Else, unsigned NumCases);
 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
                                  unsigned NumDests);
 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
                              LLVMValueRef *Args, unsigned NumArgs,
                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
                              const char *Name);
+LLVMValueRef LLVMBuildInvokeInPad(LLVMBuilderRef B, LLVMValueRef Fn,
+                                  LLVMValueRef *Args, unsigned NumArgs,
+                                  LLVMBasicBlockRef Then,
+                                  LLVMBasicBlockRef Catch, LLVMValueRef Pad,
+                                  const char *Name);
 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
                                  LLVMValueRef PersFn, unsigned NumClauses,
                                  const char *Name);
+LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad,
+                                  LLVMBasicBlockRef UnwindBB,
+                                  unsigned NumHandlers, const char *Name);
+void LLVMAddHandlerToCatchSwitch(LLVMValueRef CatchSwitch,
+                                 LLVMBasicBlockRef HandlerVal);
+LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
+                               LLVMValueRef *Args, unsigned NumArgs,
+                               const char *Name);
+LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
+                                 LLVMValueRef *Args, unsigned NumArgs,
+                                 const char *Name);
+LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
+                               LLVMBasicBlockRef BB);
+LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CleanupPad,
+                                 LLVMBasicBlockRef UnwindBB);
 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
 
 /* Add a case to the switch instruction */
 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
                  LLVMBasicBlockRef Dest);
 
 /* Add a destination to the indirectbr instruction */
LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
                            LLVMValueRef LHS, LLVMValueRef RHS,
                            const char *Name);
 
 /* Miscellaneous instructions */
 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
                            LLVMValueRef *Args, unsigned NumArgs,
                            const char *Name);
+LLVMValueRef LLVMBuildCallInPad(LLVMBuilderRef B, LLVMValueRef Fn,
+                                LLVMValueRef *Args, unsigned NumArgs,
+                                LLVMValueRef Pad, const char *Name);
 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
                              LLVMValueRef Then, LLVMValueRef Else,
                              const char *Name);
 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
                             const char *Name);
 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
                                      LLVMValueRef Index, const char *Name);
 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,

lib/IR/Core.cpp

 LLVMBool LLVMIsUndef(LLVMValueRef Val) {
   return isa<UndefValue>(unwrap(Val));
 }
 
 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) {
   return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
 }
 
+LLVMValueRef LLVMConstTokenNone(LLVMContextRef C) {
+  LLVMContext &Context = *unwrap(C);
+  return wrap(ConstantTokenNone::get(Context));
+}
+
 /*--.. Operations on metadata nodes ........................................--*/
 
 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
                                    unsigned SLen) {
   LLVMContext &Context = *unwrap(C);
   return wrap(MetadataAsValue::get(
       Context, MDString::get(Context, StringRef(Str, SLen))));
 }
LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
                              LLVMValueRef *Args, unsigned NumArgs,
                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
                              const char *Name) {
   return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
                                       makeArrayRef(unwrap(Args), NumArgs),
                                       Name));
 }
 
+LLVMValueRef LLVMBuildInvokeInPad(LLVMBuilderRef B, LLVMValueRef Fn,
+                                  LLVMValueRef *Args, unsigned NumArgs,
+                                  LLVMBasicBlockRef Then,
+                                  LLVMBasicBlockRef Catch,
+          LLVMValueRef Pad, const char *Name) {
+  SmallVector<OperandBundleDef, 1> BundleList;
+  BundleList.emplace_back("funclet", unwrap<Instruction>(Pad));
+  return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
+                                      makeArrayRef(unwrap(Args), NumArgs),
+                                      BundleList, Name));
+}
+
 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
                                  LLVMValueRef PersFn, unsigned NumClauses,
                                  const char *Name) {
   // The personality used to live on the landingpad instruction, but now it
   // lives on the parent function. For compatibility, take the provided
   // personality and put it on the parent function.
   if (PersFn)
     unwrap(B)->GetInsertBlock()->getParent()->setPersonalityFn(
         cast<Function>(unwrap(PersFn)));
   return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), NumClauses, Name));
 }
 
 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) {
   return wrap(unwrap(B)->CreateResume(unwrap(Exn)));
 }
 
+LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B,
+                                  LLVMValueRef ParentPad,
+                                  LLVMBasicBlockRef UnwindBB,
+                                  unsigned NumHandlers,
+                                  const char *Name) {
+  return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(UnwindBB),
+                                           NumHandlers, Name));
+}
+
+void LLVMAddHandlerToCatchSwitch(LLVMValueRef CatchSwitch,
+                                 LLVMBasicBlockRef handler) {
+  unwrap<CatchSwitchInst>(CatchSwitch)->addHandler(unwrap(handler));
+}
+
+LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B,
+                               LLVMValueRef ParentPad,
+                               LLVMValueRef *Args,
+                               unsigned NumArgs,
+                               const char *Name) {
+  ArrayRef<Value *> ArgList(unwrap(Args), NumArgs);
+  return wrap(unwrap(B)->CreateCatchPad(unwrap(ParentPad), ArgList, Name));
+}
+
+LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B,
+                                 LLVMValueRef ParentPad,
+                                 LLVMValueRef *Args,
+                                 unsigned NumArgs,
+                                 const char *Name) {
+  ArrayRef<Value *> ArgList(unwrap(Args), NumArgs);
+  return wrap(unwrap(B)->CreateCleanupPad(unwrap(ParentPad), ArgList, Name));
+}
+
+LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B,
+                               LLVMValueRef CatchPad,
+                               LLVMBasicBlockRef BB) {
+  return wrap(unwrap(B)->CreateCatchRet(unwrap<CatchPadInst>(CatchPad),
+                                        unwrap(BB)));
+}
+
+LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B,
+                                 LLVMValueRef CleanupPad,
+                                 LLVMBasicBlockRef UnwindBB) {
+  return wrap(unwrap(B)->CreateCleanupRet(unwrap<CleanupPadInst>(CleanupPad),
+                                          unwrap(UnwindBB)));
+}
+
 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
   return wrap(unwrap(B)->CreateUnreachable());
 }
 
 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
                  LLVMBasicBlockRef Dest) {
   unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
 }

 LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
                            LLVMValueRef *Args, unsigned NumArgs,
                            const char *Name) {
   return wrap(unwrap(B)->CreateCall(unwrap(Fn),
                                     makeArrayRef(unwrap(Args), NumArgs),
                                     Name));
 }
 
+LLVMValueRef LLVMBuildCallInPad(LLVMBuilderRef B, LLVMValueRef Fn,
+                                LLVMValueRef *Args, unsigned NumArgs,
+                                LLVMValueRef Pad, const char *Name) {
+  SmallVector<OperandBundleDef, 1> BundleList;
+  BundleList.emplace_back("funclet", unwrap<Instruction>(Pad));
+  return wrap(unwrap(B)->CreateCall(unwrap(Fn),
+                                    makeArrayRef(unwrap(Args), NumArgs),
+                                    BundleList,
+                                    Name));
+}
+
 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
                              LLVMValueRef Then, LLVMValueRef Else,
                              const char *Name) {
   return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else),
                                       Name));
 }
 
 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List,

test/Bindings/llvm-c/seh.ll

+; RUN: llvm-as < %s | llvm-dis > %t.orig
+; RUN: llvm-as < %s | llvm-c-test --echo > %t.echo
+; RUN: diff -w %t.orig %t.echo
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc18.0.0"
+
+define void @g() {
+  ret void
+}
+
+define void @f2() personality i32 (...)* @__CxxFrameHandler3 {
+entry:
+  %b = alloca i32
+  invoke void @g() to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  br label %try.cont
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %ehcleanup
+  %cs1 = catchswitch within none [label %catch] unwind label %ehcleanup.1
+
+catch:                                            ; preds = %catch.dispatch
+  %1 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %1 to label %catchret.dest
+
+catchret.dest:                                    ; preds = %catch
+  br label %try.cont
+
+try.cont:                                         ; preds = %catchret.dest, %invoke.cont
+  ret void
+
+ehcleanup.1:
+  %2 = cleanuppad within none [label %catch]
+  cleanupret from %2 unwind to caller
+}
+
+declare i32 @__CxxFrameHandler3(...)
 No newline at end of file

tools/llvm-c-test/echo.cpp

static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M) {
   }
 
   // Try float literal
   if (LLVMIsAConstantFP(Cst)) {
     check_value_kind(Cst, LLVMConstantFPValueKind);
     report_fatal_error("ConstantFP is not supported");
   }
 
+  // Try a null pointer
+  if (LLVMIsAConstantPointerNull(Cst)) {
+    check_value_kind(Cst, LLVMConstantPointerNullValueKind);
+    LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
+    return LLVMConstPointerNull(Ty);
+  }
+
+  // Try a none token
+  if (LLVMIsAConstantTokenNone(Cst)) {
+    check_value_kind(Cst, LLVMConstantTokenNoneValueKind);
+    return LLVMConstTokenNone(LLVMGetModuleContext(M));
+  }
+
   // This kind of constant is not supported
   if (!LLVMIsAConstantExpr(Cst))
     report_fatal_error("Expected a constant expression");
 
   // At this point, it must be a constant expression
   check_value_kind(Cst, LLVMConstantExprValueKind);
 
   LLVMOpcode Op = LLVMGetConstOpcode(Cst);
switch(Op) {
 
         LLVMAddIncoming(Dst, Values.data(), Blocks.data(), IncomingCount);
         return Dst;
       }
       case LLVMCall: {
         SmallVector<LLVMValueRef, 8> Args;
         int ArgCount = LLVMGetNumArgOperands(Src);
         for (int i = 0; i < ArgCount; i++)
           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
         Dst = LLVMBuildCall(Builder, Fn, Args.data(), ArgCount, Name);
         LLVMSetTailCall(Dst, LLVMIsTailCall(Src));
         CloneAttrs(Src, Dst);
         break;
       }
       case LLVMResume: {
         Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
switch(Op) {
         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
         if (LLVMGetNumIndices(Src) != 1)
           report_fatal_error("Expected only one indice");
         auto I = LLVMGetIndices(Src)[0];
         Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
         break;
       }
+      case LLVMCleanupPad: {
+        unsigned Operands = LLVMGetNumOperands(Src);
+        if (Operands == 0)
+          report_fatal_error("Expected at least one indice");
+        unsigned NumArgs = Operands - 1;
+        LLVMValueRef Parent = CloneValue(LLVMGetOperand(Src, Operands - 1));
+        SmallVector<LLVMValueRef, 8> Args;
+        for (unsigned i = 0; i < NumArgs; i++)
+          Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
+        Dst = LLVMBuildCleanupPad(Builder, Parent, Args.data(), NumArgs, Name);
+        break;
+      }
+      case LLVMCleanupRet: {
+        LLVMBasicBlockRef Unwind = nullptr;
+        if (LLVMGetNumOperands(Src) > 1) {
+          LLVMValueRef Unval = LLVMGetOperand(Src, 1);
+          Unwind = DeclareBB(LLVMValueAsBasicBlock(Unval));
+        }
+        LLVMValueRef Cval = CloneValue(LLVMGetOperand(Src, 0));
+        Dst = LLVMBuildCleanupRet(Builder, Cval, Unwind);
+        break;
+      }
+      case LLVMCatchSwitch: {
+        LLVMValueRef Unval = LLVMGetOperand(Src, 1);
+        LLVMBasicBlockRef Unwind = DeclareBB(LLVMValueAsBasicBlock(Unval));
+        if (LLVMGetNumOperands(Src) < 2)
+          report_fatal_error("Expected at least two operands");
+        unsigned NumHandlers = LLVMGetNumOperands(Src) - 2;
+        LLVMValueRef Parent = CloneValue(LLVMGetOperand(Src, 0));
+        Dst = LLVMBuildCatchSwitch(Builder, Parent, Unwind, NumHandlers, Name);
+        for (unsigned i = 0; i < NumHandlers; i++) {
+          LLVMBasicBlockRef BB = LLVMValueAsBasicBlock(LLVMGetOperand(Src,
+                                                                      i+2));
+          LLVMAddHandlerToCatchSwitch(Dst, DeclareBB(BB));
+        }
+        break;
+      }
+      case LLVMCatchPad: {
+        unsigned Operands = LLVMGetNumOperands(Src);
+        if (Operands == 0)
+          report_fatal_error("Expected at least one indice");
+        unsigned NumArgs = Operands - 1;
+        LLVMValueRef Parent = CloneValue(LLVMGetOperand(Src, Operands - 1));
+        SmallVector<LLVMValueRef, 8> Args;
+        for (unsigned i = 0; i < NumArgs; i++)
+          Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
+        Dst = LLVMBuildCatchPad(Builder, Parent, Args.data(), NumArgs, Name);
+        break;
+      }
+      case LLVMCatchRet: {
+        LLVMValueRef NxtVal = LLVMGetOperand(Src, 1);
+        LLVMBasicBlockRef Successor = DeclareBB(LLVMValueAsBasicBlock(NxtVal));
+        Dst = LLVMBuildCatchRet(Builder, LLVMGetOperand(Src, 0), Successor);
+        break;
+      }
       default:
         break;
     }
 
     if (Dst == nullptr) {
       fprintf(stderr, "%d is not a supported opcode\n", Op);
       exit(-1);
     }