[llvm-ocaml] Migrate from naked pointers to prepare for OCaml 5

[alan]

llvm/test/Bindings/OCaml/debuginfo.ml

293

When I ran the tests with assertions enabled, the OCaml debuginfo test at llvm/test/Bindings/OCaml/debuginfo.ml failed with the message:

File "/home/alan/llvm-project/debug/test/Bindings/OCaml/Output/debuginfo.ml.tmp/Testsuite.ml", line 1:
Warning 70 [missing-mli]: Cannot find interface file.
File "/home/alan/llvm-project/debug/test/Bindings/OCaml/Output/debuginfo.ml.tmp/debuginfo.ml", line 1:
Warning 70 [missing-mli]: Cannot find interface file.
executable: /home/alan/llvm-project/llvm/lib/IR/DIBuilder.cpp:809: llvm::DILocalVariable* llvm::DIBuilder::createParameterVariable(llvm::DIScope*, llvm::StringRef, unsigned int, llvm::DIFile*, unsigned int, llvm::DIType*, bool, llvm::DINode::DIFlags, llvm::DINodeArray): Assertion `ArgNo && "Expected non-zero argument number for parameter"' failed.
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/alan/llvm-project/debug/bin/FileCheck /home/alan/llvm-project/llvm/test/Bindings/OCaml/debuginfo.ml

The docs for createParameterVariable (https://llvm.org/doxygen/classllvm_1_1DIBuilder.html#afa7c4efcb5c40c8527c13759f10ef5ed) state that the index is 1-based, so the test code with argno:0 seems to be wrong?

[alan]

Oh no, I've always struggled with Phabricator and now I've really messed something up. Patch application failed... How do I get back to a clean state in my working copy so I can fix this?

[alan]

Undo bad patch

[alan]

I see, somebody made a commit to the OCaml bindings on main, and I did not realize and did not pull the latest code.

[alan]

Hopefully rebase onto main

[alan]

Fix suspicious test that fails with assertions on

[alan]

Fix incorrect call to alloc_temp

[alan]

Assume all pointers from LLVM are at least 2-bit aligned

[jberdine]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

13–15

A high-level question about this diff is whether you really want to change the bindings in this way. The current situation is that they intentionally take a low-level view of the FFI and have been written with that in mind and reviewed from that perspective. There is probably more chance of introducing bugs by changing this than by just adding the encoding of naked pointers and retaining the use of the low-level FFI. My personal preference would be to keep the existing low level FFI. But if such a change from the low-level to the high-level FFI is done, it should be done as a separate diff that does only that.

36

It is common practice elsewhere in the LLVM codebase to add an informative message to assertions, in a way that does not affect the meaning:

592–604

To take this function as a specific example, I think that the suggested change would be a much more minimal change that yields code that does not suffer from naked pointers, is safe in a sequential context, and is probably safe (up to the best of my understanding) in a parallel context.

llvm/test/Bindings/OCaml/debuginfo.ml

293

I think you're right.

[alan]

Rebase

[alan]

Add message to asserts

[Kakadu]

I was brought here from https://discuss.ocaml.org/t/proposal-care-more-about-ocaml-bindings-for-popular-libraries/11451 and https://discourse.llvm.org/t/rfc-moving-ocaml-bindings-to-peripheral-tier-and-disabling-them-by-default/68290/10.

I hope my comments will be helpful. There is some weird stuff here, but if author's code started to pass the tests after these changes, we could address other issues with binding in separate PRs (this is already rather long)

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

Could you add a comment why these two functions are needed? I always though that out-of-heap values should be wrapped into Abstract_tag. At least the manual says that https://v2.ocaml.org/manual/intfc.html#ss:c-outside-head

Sorry for asking stupid questions, I was teleported there from https://discuss.ocaml.org/t/proposal-care-more-about-ocaml-bindings-for-popular-libraries/11451

58

Am I understanding right... LLVM uses non-zero-terminated strings under the hood, so this function is need?

In case of zero terminated string it would be better to use caml_copy_string https://github.com/ocaml/ocaml/blob/5.0/runtime/alloc.c#L208

115–126

I'm not 100% follow the intent of this function. It looks like it tries to convert OCaml array of OCaml values to C array of OCaml values. But if it is true, I'm not sure that llvm_struct_element_types works as expected.

In I understood intent correctly, it should be renamed to array_of_ocaml_array or something.....

660

Could you double check that there is no bug here? See my comment about alloc_temp.

702

This code looks suspicious. If we are going to return an array, why not to try to use caml_alloc_array function?

937

Here we again allocate a tuple and return an array. Looks weird.

1402

I'm wondering... Is it a good idea to define a macro for more short definitions of binary operations above?

2911

Isn't that strange that argn is not used here?

3123–3124

It looks like the 'value' is not required.

[alan]

Hi, I've went over your comments and answered them. Please let me know if you have questions or concerns still.

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

When I first wrote this patch, my original approach was to wrap LLVM values in an OCaml block of Abstract_tag. In a discussion with @jberdine, he said that I could assume that all pointers from LLVM are 2-byte aligned, and set the low bit to 1 when exposing them to OCaml (https://github.com/llvm/llvm-project/issues/58134#issuecomment-1271544642). The OCaml GC distinguishes pointers from integers from the low bit; the low bit of integers is 1. Therefore, the OCaml GC will treat out-of-OCaml-heap LLVM pointers as integers.

The OCaml documentation that you link also recommends this representation:

For pointers that are at least 2-aligned (the low bit is guaranteed to be zero), we have yet another valid representation as an OCaml tagged integer.

This approach avoids an extra allocation. This design choice is documented in the comments and assert messages. Is there anything else I need to add to make it clear for people unfamiliar with the code?

58

This code is what exists on the main branch and my patch does not touch it. The code passes the tests; changing this function is not the business of my patch.

It seems that this function accepts NULL pointers and handles the NULL case by allocating a zero-length OCaml-heap-allocated string.

115–126

Yes, it converts an OCaml array to a C array. The code on the main branch uses the fact that pointers are naked to directly cast OCaml blocks to C arrays, which is no longer possible now that OCaml 5 disallows naked pointers.

The x_of_y naming style is an OCaml quirk. I don't want to name this helper function that.

660

This code allocates a temporary, intermediate array as a buffer to store the output of LLVMGetStructElementTypes. Then, it copies them over to an OCaml-heap-allocated array (which internally have the same representation as OCaml tuples) and copies over the elements, wrapping them by setting the low bit to 1.

702

The original code uses caml_alloc_tuple, so that's what I did as well. I think caml_alloc_array (which takes a callback that converts the array elements to OCaml values) would work as well. Thanks for suggesting it.

1402

For this patch, I just did things by-hand. I think this is simpler than a macro for now, as a lot of this code wraps functions by hand. If you really want a macro, I can change it to one.

2911

No. FFI functions of arity greater than five should have two functions, one for native which simply takes all the parameters, and one for bytecode which takes an arg vector and the vector's length (https://v2.ocaml.org/manual/intfc.html#ss:c-prim-impl). It's the way that interface is defined that the bytecode wrapper function receives the number of arguments, but here, we know that the function has an arity of 7 and just forward them from the bytecode wrapper function to the native wrapper function

3123–3124

By putting value, I define a new Hd local variable that shadows the outer one. This code is fine, but reusing the outer variable will also probably be fine. It just depends on your style preference.

[alan]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

13–15

I thought about this a long time, even before you left this comment. The OCaml manual instructs you to use the CAMLparam, CAMLlocal, and CAMLreturn macros for all FFI functions (https://v2.ocaml.org/manual/intfc.html#ss:c-simple-gc-harmony). It does not give any nuances, like "You don't need to register unboxed integers with CAMLparam" or "You don't need to use the macros if you never call the OCaml runtime." When I first wrote this patch, I just added all the macros to be extra safe.

I've been going through the code locally now and removing the macros, and so far the tests still pass, but there are several spots where I was unsure if removing the macro would be unsafe. (Example: Where one of the arguments is a pointer into the OCaml-managed heap, such as an OCaml string or an Abstract_tagged LLVM value for purposes of custom finalizer, and the function calls the OCaml runtime by allocating something.) I don't want a heisenbug where the code usually passes the tests, but mysteriously segfaults in some user's program if the GC kicks in at the wrong time and deallocates memory that shouldn't, because the binding code plays fast and loose with the macros.

Then, we have the issue with the diagnostic handler, meaning that the OCaml runtime could kick in at many points that may not be obvious, but the diagnostic handler could violate so many assumptions about C and C++ resource cleanup, as we've discussed, that I don't know if it should factor in to the decision whether to use the macros.

When I was thinking about whether to use the macros or drop them, my view was mainly about efficiency versus readability, where I viewed the macros as sacrificing slight efficiency (because the code spends instructions registering values with the GC, when this may not be necessary) for readability (because the code follows the rules of the OCaml FFI manual to the letter). I do not share your view that using the macros would *introduce* bugs or make the code harder to review; I always thought the macros make the code safer and easier to review. It's better to just use the macro than to think, "Do we need to use a macro here? Does the GC need to know about this value before we call caml_alloc_whatever?"

[Kakadu]

It looks like most of my comments were false alarms. Although, two places are left, which bother me.

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

Sorry, I forgot that there is an optimization to avoid Abstract_tag. It would be great to have a comment explicitly saying that.

58

Yeah, you are right. The caml_alloc_string+memcpy could be probably be replaced by caml_copy_string, but it could be a topic for a distinct patch....

660

Yes, but it looks like alloc_temp accepts array as an argument, but you pass unsigned Length here...

1402

Nonono, this patch is OK without a macro.

3123–3124

Your explanation is fine, if we talk about C++, but OCaml manual explicitly says
"Rule 2  Local variables of type value must be declared with one of the CAMLlocal macros."

[jrtc27]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

Pointers are not integers.

[jberdine]

Thanks all, it is great to get more eyes on this!

llvm/bindings/ocaml/llvm/llvm_ocaml.c

13–15

My main point is not so much about whether or not to most desirable final situation involves abiding by the simplified FFI rules, but that the changes to do so are large and orthogonal to the goal of changing the bindings to avoid naked pointers. Changing to the simplified FFI rules is a judgement call that has pros and cons, while eliminating naked pointers is a hard requirement going forward. That is why I think the two things should be done as two separate diffs.

As for potentially introducing bugs, maybe I'm just paranoid, but large changes are hard to review and not as precise when bisecting issues that are discovered later. More specifically, adding CAMLlocal and associated macros publish more locations as GC roots, and the associated changes involve more allocations. Going all the way to strictly following the simplified rules should be fine, but if there are any oversights and we only get part of the way there, it seems entirely possible to introduce bugs.

The diagnostic handler API is limited in the sense that the handler functions must not access the OCaml runtime system. But following the simplified FFI rules will not be enough to enable supporting arbitrary handler functions. That would be another orthogonal change.

45

Pointers are not integers.

From the perspective of the FFI, bit patterns with the lsb set are not interpreted as pointers that the runtime system should follow. It happens that integers in OCaml are represented with bit patterns where the lsb is set, so it is common, perhaps imprecise, usage to refer to pointers where their lsb has been set as "integers".

58

Yes, this code is old, and the same as the implementation of caml_copy_string except for also treating NULL as an empty string.

660

Yes, alloc_temp should be replaced by a call to malloc here. I made a similar comment on D136537 a while ago but didn't notice that I hadn't submitted it. :-(

[alan]

Fix incorrect usage of alloc_temp caught by Kakadu

[alan]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

660

Thank you for the catch @Kakadu! That function wasn't tested, and when I added a test, it segfaulted. I've pushed a fix. With a patch this big, it's easy for mistakes to slip under the radar, so it's important to have a lot of eyes reviewing it,

[Kakadu]

I think only minor quirks are left here. @alan , if you are going to make other patches about OCaml, don't hesitate to ping me.

llvm/bindings/ocaml/llvm/llvm_ocaml.c

659

In the function above we can see the usage of size_t instead of unsigned. I'm far from being expert about C++, but heard that size_t should be preferred nowadays. Is it? If you are going to change, than in other functions probably too.

[alan]

Remove added CAML macros as jberdine's request

[alan]

Add back deleted comment

[alan]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

13–15

I can respect the view that a smaller diff is better and that we can add the macros in a separate patch and focus this one on making the code work on OCaml 5. I've removed most of the CAML macros I added. There were some functions that took a pointer into the OCaml heap (e.g. an OCaml string) and called the OCaml runtime (e.g. to allocate a block or throw an exception), and I kept the macros in those cases because I think that not using the macros would be incorrect. Hopefully the diff should be smaller and easier to review now.

[alan]

Fix comment formatting to match original

[alan]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

702

I investigated more into [caml_alloc_array](https://github.com/ocaml/ocaml/blob/92adb0ff67dea9c14643a1c2eb6eeaf9d48629ef/runtime/alloc.c#L218) and found out that it expects the array to have a 0 sentinel value to mark the end rather than taking the length as an argument. This code can be adapted to use caml_alloc_array if it allocates Length + 1 elements instead and sets the last element to NULL. Do the reviewers think this is a change I should make?

[alan]

Check if malloc returns NULL

[Kakadu]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

702

Using caml_alloc_array is indeed cumbersome. It should be better to left it as it is. I would move allocation of OCaml array closer to the for-loop, to make more obvious that no other allocations are between these two things, but it is minor improvement.

[alan]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

From the perspective of program analysis, pointers are not integers because pointers have provenance. From the perspective of the runtime system, everything is a word. To be pedantic: A word is a sequence of bits; pointers, integers, Booleans, and nullary data constructors are all possible meanings ascribed to words. OCaml's GC, being a precise GC, distinguishes between pointers, which it may follow and relocate, and non-pointers, through the low bit. Setting the low bit of a pointer originating from LLVM causes the OCaml GC to treat it as a word that the GC does not follow.

[jberdine]

In D136400#4137328, @alan wrote:

Remove added CAML macros as jberdine's request

Thanks! I was thinking that a significantly smaller diff would be possible. Did you see the suggested version of llvm_param_types I made in a comment?

[alan]

Rebase

[alan]

In D136400#4139053, @jberdine wrote:

In D136400#4137328, @alan wrote:

Remove added CAML macros as jberdine's request

Thanks! I was thinking that a significantly smaller diff would be possible. Did you see the suggested version of llvm_param_types I made in a comment?

I saw that, but I have some mixed feelings about this suggestion. I don't think it would make the diff significantly smaller, and I think it's a little strangely written. The original code allocates from the OCaml-managed heap and casts the pointer because it uses the naked pointer assumption to freely cast between OCaml arrays and C arrays. Now that this patch gets rid of naked pointers, I think that allocating from the OCaml heap to create an array to pass to LLVM is tackier than to just allocate an array with malloc. That being said, I'm going to go and make the change because you want it. If I view the suggested code from the perspective of "mutating each element to make it appropriate for OCaml," instead of from the perspective of "reusing the same allocation for a new array," which is how I first viewed the code, the code becomes less weird in my eyes.

[alan]

Make diff of llvm_param_types smaller at jberdine's request

[alan]

I have some comments to add about the latest revision. The caml_alloc_tuple_uninit is actually not an OCaml runtime function, but a helper function that the LLVM binding code on the main branch defines as follows:

value caml_alloc_tuple_uninit(mlsize_t wosize) {
  if (wosize <= Max_young_wosize) {
    return caml_alloc_small(wosize, 0);
  } else {
    return caml_alloc_shr(wosize, 0);
  }
}

The documentation for caml_alloc_small and caml_alloc_shr state the following: https://v2.ocaml.org/manual/intfc.html#ss:c-low-level-gc-harmony

We now give the GC rules corresponding to the low-level allocation functions caml_alloc_small and caml_alloc_shr. You can ignore those rules if you stick to the simplified allocation function caml_alloc.
Rule 5  After a structured block (a block with tag less than No_scan_tag) is allocated with the low-level functions, all fields of this block must be filled with well-formed values before the next allocation operation. If the block has been allocated with caml_alloc_small, filling is performed by direct assignment to the fields of the block:

Field(v, n) = vn;

If the block has been allocated with caml_alloc_shr, filling is performed through the caml_initialize function:

caml_initialize(&Field(v, n), vn);

The next allocation can trigger a garbage collection. The garbage collector assumes that all structured blocks contain well-formed values. Newly created blocks contain random data, which generally do not represent well-formed values.

The binding code on the main branch does not follow these rules; when it calls caml_alloc_tuple_uninit, it always uses Field(v, n) to initialize the members, without checking if the amount allocated is greater than Max_young_wosize. Therefore, any code that hits the caml_alloc_shr case uses the OCaml runtime API incorrectly. I'm also not a fan of the caml_ naming scheme, which misleads the reader into thinking the function comes from the OCaml runtime API.

Instead of keeping this function and checking Max_young_wosize everywhere it's used to determine whether to use Field(v, n) or caml_initialize(&Field(v, n), vn), I just removed it and used caml_alloc_tuple everywhere, which I think results in the less intrusive diff. Allocations using caml_alloc_tuple should initialize their members with Store_field(v, n, vn) instead of Field(v, n) = vn.

[jberdine]

I agree that the caml_ prefix on caml_alloc_tuple_uninit is probably not a good idea.

Note that the intent of my comment about llvm_param_types was to show one concrete example of a pattern that occurs in several other functions, whose ml types return arrays, such as llvm_struct_element_types, llvm_subtypes, llvm_indices, etc. The added allocation seems unavoidable for the functions that accept an array and need to create an analogue where the lsbs have been cleared before passing it to an LLVM function. In a sequential setting, it would be possible to clear the lsbs of elements of the argument OCaml array in place, pass it to LLVM, and then re-set the lsbs. I am not suggesting to do that, it would be unsafely racy in a concurrent setting.

I don't know the history of what the FFI docs said when, but the OCaml bindings are *old*. The difference between caml_alloc_small and caml_alloc_shr is that the former allocates on the minor heap and the latter on the major heap. The FFI rules distinguish them since if a pointer to the/a minor heap is stored into the major heap, then the GC needs to be informed or else it may incorrectly consider the object in the minor heap to be dead. This is what caml_initialize and Store_field do. The key here is that in the case of the LLVM bindings, a crucial point of the design that sets the low bit of pointers to LLVM objects is that the memory allocated by either caml_alloc_small or caml_alloc_shr is initialized with values that the OCaml GC considers to be non-pointers. In particular, they cannot possibly be old-to-young pointers. This is the invariant across the whole of the LLVM bindings that makes the current code safe.

Replacing the existing calls to caml_alloc_tuple_uninit with caml_alloc_tuple will result in much of the memory allocated by the bindings being needlessly double-initialized. That is a change that is orthogonal to removing naked pointers, and I think that it should be considered separately. (It is not a change that I would myself like to see made, but it is a judgement call with pros and cons.)

llvm/bindings/ocaml/llvm/llvm_ocaml.c

258

Is this CAMLparam/CAMLreturn left over from combining the two diffs, or necessary for a reason I am overlooking?

372

I don't see why adding this CAMLparam is necessary

470–471

Left over from combining the 2 diffs?

819–820

Left over?

888–889

Left over?

2391–2395

I am not sure why this change is needed, rather than changing the (value) casts in the original to to_val. In particular, if V and BB are computed after Hd is allocated, they do not need to survive any allocations, so do not need to be roots.

2397–2400

List does not need to be a root since it is not live across any allocations.

2441

Left over?

2454

Left over?

3112–3113

Left over?

3242

Left over?

3266

Left over?

[alan]

Address comments

[alan]

Thank you for your code review. I didn't realize the reasoning behind the Field/caml_initialize distinction and was just following the OCaml documentation's rules to the letter. So, you taught me something new about the OCaml runtime, Perhaps this information could be included in a comment (an issue for another patch, of course).

I went and added back caml_alloc_tuple_uninit and got rid of the malloc/frees in the wrapper functions that return an array. I also removed all the CAMLparam/CAMLreturns you pointed out. (Some of the CAMLparams I had left were by accident, and others were because the wrapper function called the OCaml runtime API (e.g. by throwing an exception) and I wanted to be cautious. You're right that the roots aren't necessary.) There were some minor parts where I made the diff smaller as well.

I really appreciate your time and effort looking at my patch.

[jberdine]

Thanks for persisting with this and tolerating all my comments! This looks like it is getting very close, nice! I'm sorry for the piecemeal reviewing, but making a full pass takes longer than I can usually spend at once and I figure it is better to send comments intermittently rather than save them until the end. So far I have spent most time looking at llvm_ocaml.{c,ml,mli} and not so much on the other files, but I think that llvm_ocaml is just about there.

For info I found https://github.com/ocaml/ocaml/blob/f1550145d4ebe8ee22853d13f97fca288aaef51f/runtime/memory.c#L203 which notes that normal assignments are ok to initialize freshly allocated blocks with value that are not pointers to young blocks.

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

It might not hurt to add a comment before to_val and from_val saying that they encode pointers to LLVM objects as OCaml tagged integers, following the 3rd encoding suggested by the OCaml FFI documentation at https://ocaml.org/releases/5.0/htmlman/intfc.html#ss:c-outside-head . I don't know how stable such urls are expected to be though.

54

115–126

This function could probably use a comment explaining its usage since its functionality is quite specific and has a general sounding name. I don't feel strongly, but there might be a better name possible. It is basically from_val lifted to operate on arrays, so perhaps from_val_array.

116

Note that Wosize_val returns type mlsize_t, which is defined in a platform-specific way because it needs to be different on 32 vs 64 bit systems (it will be uint64_t on 64-bit systems, so usually wider than unsigned). It would probably be better to use mlsize_t instead of unsigned where the values come from OCaml and keep unsigned where the values come from LLVM. In cases where both are involved, I think but am not sure that it would generally be clearer to have the local variables with the unconverted types, and leave the casts between unsigned and mlsize_t implicit when passing arguments to functions.

121

Just a note to ourselves for maybe later: If we want to make the bindings safe for concurrent clients, we may want something stronger than a non-atomic store here. (The load from Elements is volatile.)

391–395

No big deal, but I don't know why this function was moved up a few lines

560

I think this CAMLparam is not needed since alloc_temp allocates off the OCaml heap. And if this one is needed, then RetTy should also be a root.

570

Same as function above

610

here too

620

and here

636

here

637

Related to the comment on alloc_temp about unsigned, I think it would be clearer if this unsigned was instead mlsize_t, leaving the case to unsigned implicit in the call to LLVMStructSetBody below.

There are several other similar uses, I would look around each call to alloc_temp and at each call to Wosize_val.

2077

Unless reordering the next several definitions is needed, it would be easier to review if they were left in the same order. They can be reordered if desired in a separate diff that only reorders things.

2250–2262

Could you double-check this one. Temp is allocated on the caml heap unlike other functions, and as written F and Index will need to be registered as roots.

2454

Still left over I think

[alan]

Rebase

[alan]

Oh no, I did something wrong with Arcanist. I ran arc diff and thought it would push a revision to this diff, but it instead made a new patch. I feel very frustrated with Arcanist, because it isn't explicit with diff IDs, and sometimes it surprises me about what patch it pushes to. I need to figure out what's wrong with the repo state on my computer and how I can fix this problem.

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

I added comments to the header file explaining how these functions work. Should I put additional comments in the source file?

2250–2262

F is an llvalue, which is represented using the low bit tagging scheme, and Index is an int, so both are unboxed and neither is a root. Is this reasoning correct?

[alan]

Address comments

[alan]

I figured out what I did wrong; I forgot --amend when I ran git commit.

[jberdine]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

The comment in the header is good but I think since it discusses the implementation details of the encoding, I would have put it in the .c and used a comment in the header that just said that the functions implement an encoding without specifying which one. But I have not checked if the uses in other files need to know about details of the encoding. Those are the things I think of, but go with your preference.

2250–2262

You're right about F and Index. I would expect an implementation more like in the suggested edit, similar to llvm_struct_element_types. In particular, Temp is an ocaml block with enough space for only 1 word, and I think LLVMGetCallSiteAttributes expects a pointer to an array with space for Length pointers.

llvm/bindings/ocaml/llvm/llvm_ocaml.h

39

46

maybe

[jberdine]

llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c

386

several unsigned ought to be mlsize_t in this file

llvm/bindings/ocaml/executionengine/executionengine_ocaml.c

107–108

left over

llvm/bindings/ocaml/llvm/llvm_ocaml.c

888–889

still left over

llvm/bindings/ocaml/llvm/llvm_ocaml.h

2

intended?

llvm/bindings/ocaml/target/target_ocaml.c

54–56

left over

61–62

left over

160

left over

171–172

left over

193–194

left over

199

left over

269–270

left over

344

left over

[alan]

There were some parts where you had commented about CAMLparam and which I had previously chosen to keep the macro because the function called the OCaml runtime, such as by raising an OCaml exception or allocating from the OCaml heap, and I wanted to be careful. However, I went and accepted your suggestions of removing them because I don't think the roots are necessary for one of two reasons:

• The local variable only exists to store the result of an OCaml heap allocation, so before the call to the OCaml runtime, it does not contain a root
• The local variable only exists to store data to pass to an LLVM API call, and by the point that the OCaml runtime is called, the local variable no longer needs to be live.

However, there is one point where I kept the CAMLparam and left a comment at, in which the function must register one of its parameters as a root as it makes an OCaml heap allocation and the argument of course needs to be live throughout the function call.

I feel a little nervous about removing the CAMLparam macros because I'm worried about mistakes.

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

The reason I would rather have the comments in the header is that if the functions were to be used for some LLVM type that is not 2-byte aligned, or the implementation of some type changed so that it is no longer 2-byte aligned, the code will break. (In that case, the specific type that is not 2-byte aligned should have a dedicated alloc_ function, just like the ones that already exist for types that need custom finalizers.) Therefore, I think that the 2-byte alignment aspect is a contract that users of the functions need to know about, not an implementation detail.

llvm/bindings/ocaml/target/target_ocaml.c

160

This root is necessary. DataLayout.t is an OCaml custom block, not a pointer with the low bit set. Int64.t is also boxed. So, this function allocates on the OCaml heap and the GC needs to know that DL is live.

[alan]

Publish changes

[jberdine]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

45

Yes, that makes sense.

2250–2251

these no longer need to be added

llvm/bindings/ocaml/target/target_ocaml.c

160

I understand that DL is a custom block, but its value is only used before the allocation in caml_copy_int64. This is the same before and after this diff, or am I overlooking something?

[alan]

Remove unnecessary CAML macros

[alan]

llvm/bindings/ocaml/target/target_ocaml.c

160

DL is a parameter, so it needs to be live when the function ends. Otherwise, a caller could pass a DataLayout.t value, and that value could be invalidated by the GC during the function call.

[alan]

I feel a little bit apprehensive about the lack of CAML macros in some places. After this patch is done, I think it might be worth it to review the code and make a patch that:

• Adds CAML macros if there are any places we left them out but shouldn't have
• Add comments documenting the justification for being loose with the OCaml runtime API rules (e.g. that using Field to initialize an allocation from caml_alloc_tuple_uninit is safe because you are never storing a pointer in it, or that omitting CAMLlocal is safe when the variable is only used to store the result of calling the OCaml runtime API).

Do you think this is necessary or advisable?

[alan]

If the reason why this patch doesn't add CAML macros is just to keep the diff small and focus on one issue (removing naked pointers), it might be worth it to have another patch that just adds CAML macros everywhere. It's a question of whether the CAML macros add any overhead that one would want to avoid, and whether the cost of being loose with the rules and adding comments to convey the rationale to other people reading the code is worth the maintenance effort versus just following the (oversimplified) rules of the OCaml docs.

[jberdine]

Adding comments about the reasoning behind e.g. avoiding the write barrier seems like a good idea. I don't know if it would be better to have one comment block near the top of the file, or many comments sprinkled around. There might be a lot of redundancy which would be noisy and easy to get out of sync.

There is some overhead to the CAMLparam, etc. macros. Each one involves some memory operations itself, checks the thread local state of the runtime system, and also increases the number of roots that need to be scanned each time the GC is run. I would be hesitant to add them uniformly without a good benchmark suite to measure the impact and see that it doesn't matter.

llvm/bindings/ocaml/target/target_ocaml.c

160

I'm sorry but I still don't understand. Suppose the GC runs when caml_copy_int64 allocates, and happens to move the value DL points to. Then note that DL is no longer needed since it is used only to compute the argument of LLVMOffsetOfElement and in particular is dead after the allocation in caml_copy_int64. Also, if the caller of llvm_datalayout_offset_of_element needs what it passed as the DL argument, then it will be live and a root in the caller, and the GC will update the caller's pointer when moving the block pointed to by DL. So I don't see the issue, but I am not sure I understand the point you are making. Do you see what I mean?

[alan]

Remove CAMLparam

[alan]

llvm/bindings/ocaml/target/target_ocaml.c

160

You're right, I made a mistake. I didn't consider that if the caller still needed to keep DL around, the caller stack frame would already have DL as a root, so this function doesn't need to register it as a root. Thank you for reviewing my code and pointing this out.

[jberdine]

I have redone my own testing with the latest version of this diff plus changes for the inline comments in this last iteration of review. This test translates each of the bitcode files in llvm-project/llvm/test to a different IR, as well as translating and doing some static analysis on several test programs. This testing did not uncover any issues with this diff.

Additionally, the test was repeated where the translation of the functions of each llvm module was done in parallel (using Domainslib.Task.parallel_for). This is not much of a parallel stress test, but it did not encounter any issues.

So these inline comments are the last minor changes, then this can be rebased, and I can commit it if you need.

llvm/bindings/ocaml/llvm/llvm_ocaml.c

842

This CAMLparam needs to be kept since Name needs to survive the allocation of Nodes.

936

It is pre-existing, but while you are at it, it may be clearer and more uniform to change to ++I.

1145

Removing these parens triggers warning: using the result of an assignment as a condition without parentheses [-Wparentheses]

[alan]

Make final requested changes

[alan]

What "rebasing" does this need? As far as I can tell, it is compatible with the main branch. The last commit to the OCaml bindings is my patch removing the PassManager functions, which this patch is already rebased on. If this weren't ready to merge, Phabricator would say "patch application failed."

Please do commit this for me.

[jberdine]

Excellent!

llvm/bindings/ocaml/all_backends/all_backends_ocaml.c

 /*===-- all_backends_ocaml.c - LLVM OCaml Glue ------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c/Target.h"
 #include "caml/alloc.h"
 #include "caml/fail.h"
 #include "caml/memory.h"
 #include "caml/custom.h"
 

llvm/bindings/ocaml/analysis/analysis_ocaml.c

 /*===-- analysis_ocaml.c - LLVM OCaml Glue ----------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c/Analysis.h"
 #include "llvm-c/Core.h"
 #include "caml/alloc.h"
 #include "caml/mlvalues.h"
 #include "caml/memory.h"
 #include "llvm_ocaml.h"
 
 /* Llvm.llmodule -> string option */
-value llvm_verify_module(LLVMModuleRef M) {
-  CAMLparam0();
+value llvm_verify_module(value M) {
+  CAMLparam1(M);
   CAMLlocal2(String, Option);
 
   char *Message;
-  int Result = LLVMVerifyModule(M, LLVMReturnStatusAction, &Message);
+  int Result =
+      LLVMVerifyModule(Module_val(M), LLVMReturnStatusAction, &Message);
 
   if (0 == Result) {
     Option = Val_none;
   } else {
-    String = copy_string(Message);
+    String = caml_copy_string(Message);
     Option = caml_alloc_some(String);
   }
 
   LLVMDisposeMessage(Message);
 
   CAMLreturn(Option);
 }
 
 /* Llvm.llvalue -> bool */
-value llvm_verify_function(LLVMValueRef Fn) {
-  return Val_bool(LLVMVerifyFunction(Fn, LLVMReturnStatusAction) == 0);
+value llvm_verify_function(value Fn) {
+  CAMLparam1(Fn);
+  CAMLreturn(
+      Val_bool(LLVMVerifyFunction(Value_val(Fn), LLVMReturnStatusAction) == 0));
 }
 
 /* Llvm.llmodule -> unit */
-value llvm_assert_valid_module(LLVMModuleRef M) {
-  LLVMVerifyModule(M, LLVMAbortProcessAction, 0);
-  return Val_unit;
+value llvm_assert_valid_module(value M) {
+  CAMLparam1(M);
+  LLVMVerifyModule(Module_val(M), LLVMAbortProcessAction, 0);
+  CAMLreturn(Val_unit);
 }
 
 /* Llvm.llvalue -> unit */
-value llvm_assert_valid_function(LLVMValueRef Fn) {
-  LLVMVerifyFunction(Fn, LLVMAbortProcessAction);
-  return Val_unit;
+value llvm_assert_valid_function(value Fn) {
+  CAMLparam1(Fn);
+  LLVMVerifyFunction(Value_val(Fn), LLVMAbortProcessAction);
+  CAMLreturn(Val_unit);
 }
 
 /* Llvm.llvalue -> unit */
-value llvm_view_function_cfg(LLVMValueRef Fn) {
-  LLVMViewFunctionCFG(Fn);
-  return Val_unit;
+value llvm_view_function_cfg(value Fn) {
+  CAMLparam1(Fn);
+  LLVMViewFunctionCFG(Value_val(Fn));
+  CAMLreturn(Val_unit);
 }
 
 /* Llvm.llvalue -> unit */
-value llvm_view_function_cfg_only(LLVMValueRef Fn) {
-  LLVMViewFunctionCFGOnly(Fn);
-  return Val_unit;
+value llvm_view_function_cfg_only(value Fn) {
+  CAMLparam1(Fn);
+  LLVMViewFunctionCFGOnly(Value_val(Fn));
+  CAMLreturn(Val_unit);
 }

llvm/bindings/ocaml/backends/backend_ocaml.c

 /*===-- backend_ocaml.c - LLVM OCaml Glue -----------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c/Target.h"
 #include "caml/alloc.h"
 #include "caml/memory.h"
 
 /* TODO: Figure out how to call these only for targets which support them.
  * LLVMInitialize ## target ## AsmPrinter();

llvm/bindings/ocaml/bitreader/CMakeLists.txt

 add_ocaml_library(llvm_bitreader
   OCAML    llvm_bitreader
   OCAMLDEP llvm
   C        bitreader_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../llvm"
   LLVM     BitReader)

llvm/bindings/ocaml/bitreader/bitreader_ocaml.c

 /*===-- bitwriter_ocaml.c - LLVM OCaml Glue ---------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include "llvm-c/BitReader.h"
-#include "llvm-c/Core.h"
 #include "caml/alloc.h"
+#include "caml/callback.h"
 #include "caml/fail.h"
 #include "caml/memory.h"
-#include "caml/callback.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/BitReader.h"
+#include "llvm-c/Core.h"
 
 void llvm_raise(value Prototype, char *Message);
 
 /* Llvm.llcontext -> Llvm.llmemorybuffer -> Llvm.llmodule */
-LLVMModuleRef llvm_get_module(LLVMContextRef C, LLVMMemoryBufferRef MemBuf) {
+value llvm_get_module(value C, value MemBuf) {
+  CAMLparam2(C, MemBuf);
   LLVMModuleRef M;
 
-  if (LLVMGetBitcodeModuleInContext2(C, MemBuf, &M))
+  if (LLVMGetBitcodeModuleInContext2(Context_val(C), MemoryBuffer_val(MemBuf),
+                                     &M))
     llvm_raise(*caml_named_value("Llvm_bitreader.Error"),
                LLVMCreateMessage(""));
 
-  return M;
+  CAMLreturn(to_val(M));
 }
 
 /* Llvm.llcontext -> Llvm.llmemorybuffer -> Llvm.llmodule */
-LLVMModuleRef llvm_parse_bitcode(LLVMContextRef C, LLVMMemoryBufferRef MemBuf) {
+value llvm_parse_bitcode(value C, value MemBuf) {
+  CAMLparam2(C, MemBuf);
   LLVMModuleRef M;
 
-  if (LLVMParseBitcodeInContext2(C, MemBuf, &M))
+  if (LLVMParseBitcodeInContext2(Context_val(C), MemoryBuffer_val(MemBuf), &M))
     llvm_raise(*caml_named_value("Llvm_bitreader.Error"),
                LLVMCreateMessage(""));
 
-  return M;
+  CAMLreturn(to_val(M));
 }

llvm/bindings/ocaml/bitwriter/CMakeLists.txt

 add_ocaml_library(llvm_bitwriter
   OCAML    llvm_bitwriter
   OCAMLDEP llvm
   C        bitwriter_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../llvm"
+  PKG      unix
   LLVM     BitWriter)

llvm/bindings/ocaml/bitwriter/bitwriter_ocaml.c

 /*===-- bitwriter_ocaml.c - LLVM OCaml Glue ---------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include "llvm-c/BitWriter.h"
-#include "llvm-c/Core.h"
 #include "caml/alloc.h"
-#include "caml/mlvalues.h"
 #include "caml/memory.h"
+#include "caml/mlvalues.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/BitWriter.h"
+#include "llvm-c/Core.h"
 
 /* Llvm.llmodule -> string -> bool */
-value llvm_write_bitcode_file(LLVMModuleRef M, value Path) {
-  int Result = LLVMWriteBitcodeToFile(M, String_val(Path));
-  return Val_bool(Result == 0);
+value llvm_write_bitcode_file(value M, value Path) {
+  CAMLparam2(M, Path);
+  int Result = LLVMWriteBitcodeToFile(Module_val(M), String_val(Path));
+  CAMLreturn(Val_bool(Result == 0));
 }
 
 /* ?unbuffered:bool -> Llvm.llmodule -> Unix.file_descr -> bool */
-value llvm_write_bitcode_to_fd(value U, LLVMModuleRef M, value FD) {
+value llvm_write_bitcode_to_fd(value U, value M, value FD) {
+  CAMLparam3(U, M, FD);
   int Unbuffered;
   int Result;
 
   if (U == Val_int(0)) {
     Unbuffered = 0;
   } else {
     Unbuffered = Bool_val(Field(U, 0));
   }
 
-  Result = LLVMWriteBitcodeToFD(M, Int_val(FD), 0, Unbuffered);
-  return Val_bool(Result == 0);
+  Result = LLVMWriteBitcodeToFD(Module_val(M), Int_val(FD), 0, Unbuffered);
+  CAMLreturn(Val_bool(Result == 0));
 }
 
 /* Llvm.llmodule -> Llvm.llmemorybuffer */
-LLVMMemoryBufferRef llvm_write_bitcode_to_memory_buffer(LLVMModuleRef M) {
-  return LLVMWriteBitcodeToMemoryBuffer(M);
+value llvm_write_bitcode_to_memory_buffer(value M) {
+  CAMLparam1(M);
+  CAMLreturn(to_val(LLVMWriteBitcodeToMemoryBuffer(Module_val(M))));
 }

llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c

 /*===-- debuginfo_ocaml.c - LLVM OCaml Glue ---------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include <string.h>
 
 #include "caml/memory.h"
 #include "caml/mlvalues.h"
 #include "llvm-c/Core.h"
 #include "llvm-c/DebugInfo.h"
static LLVMDIFlags map_DIFlag(LLVMDIFlag_i DIF) {
   case i_DIFlagAccessibility:
     return LLVMDIFlagAccessibility;
   case i_DIFlagPtrToMemberRep:
     return LLVMDIFlagPtrToMemberRep;
   }
 }
 
 value llvm_debug_metadata_version(value Unit) {
-  return Val_int(LLVMDebugMetadataVersion());
+  CAMLparam1(Unit);
+  CAMLreturn(Val_int(LLVMDebugMetadataVersion()));
 }
 
-value llvm_get_module_debug_metadata_version(LLVMModuleRef Module) {
-  return Val_int(LLVMGetModuleDebugMetadataVersion(Module));
+value llvm_get_module_debug_metadata_version(value Module) {
+  CAMLparam1(Module);
+  CAMLreturn(Val_int(LLVMGetModuleDebugMetadataVersion(Module_val(Module))));
 }
 
 #define DIFlags_val(v) (*(LLVMDIFlags *)(Data_custom_val(v)))
 
 static struct custom_operations diflags_ops = {
     (char *)"DebugInfo.lldiflags", custom_finalize_default,
     custom_compare_default,        custom_hash_default,
     custom_serialize_default,      custom_deserialize_default,
     custom_compare_ext_default};
 
 static value alloc_diflags(LLVMDIFlags Flags) {
-  value V = alloc_custom(&diflags_ops, sizeof(LLVMDIFlags), 0, 1);
+  value V = caml_alloc_custom(&diflags_ops, sizeof(LLVMDIFlags), 0, 1);
   DIFlags_val(V) = Flags;
   return V;
 }
 
 LLVMDIFlags llvm_diflags_get(value i_Flag) {
+  CAMLparam1(i_Flag);
   LLVMDIFlags Flags = map_DIFlag(Int_val(i_Flag));
-  return alloc_diflags(Flags);
+  CAMLreturn(alloc_diflags(Flags));
 }
 
 LLVMDIFlags llvm_diflags_set(value Flags, value i_Flag) {
+  CAMLparam2(Flags, i_Flag);
   LLVMDIFlags FlagsNew = DIFlags_val(Flags) | map_DIFlag(Int_val(i_Flag));
-  return alloc_diflags(FlagsNew);
+  CAMLreturn(alloc_diflags(FlagsNew));
 }
 
 value llvm_diflags_test(value Flags, value i_Flag) {
+  CAMLparam2(Flags, i_Flag);
   LLVMDIFlags Flag = map_DIFlag(Int_val(i_Flag));
-  return Val_bool((DIFlags_val(Flags) & Flag) == Flag);
+  CAMLreturn(Val_bool((DIFlags_val(Flags) & Flag) == Flag));
 }
 
 #define DIBuilder_val(v) (*(LLVMDIBuilderRef *)(Data_custom_val(v)))
 
 static void llvm_finalize_dibuilder(value B) {
   LLVMDIBuilderFinalize(DIBuilder_val(B));
   LLVMDisposeDIBuilder(DIBuilder_val(B));
 }
 
 static struct custom_operations dibuilder_ops = {
     (char *)"DebugInfo.lldibuilder", llvm_finalize_dibuilder,
     custom_compare_default,          custom_hash_default,
     custom_serialize_default,        custom_deserialize_default,
     custom_compare_ext_default};
 
 static value alloc_dibuilder(LLVMDIBuilderRef B) {
-  value V = alloc_custom(&dibuilder_ops, sizeof(LLVMDIBuilderRef), 0, 1);
+  value V = caml_alloc_custom(&dibuilder_ops, sizeof(LLVMDIBuilderRef), 0, 1);
   DIBuilder_val(V) = B;
   return V;
 }
 
 /* llmodule -> lldibuilder */
-value llvm_dibuilder(LLVMModuleRef M) {
-  return alloc_dibuilder(LLVMCreateDIBuilder(M));
+value llvm_dibuilder(value M) {
+  CAMLparam1(M);
+  CAMLreturn(alloc_dibuilder(LLVMCreateDIBuilder(Module_val(M))));
 }
 
 value llvm_dibuild_finalize(value Builder) {
   LLVMDIBuilderFinalize(DIBuilder_val(Builder));
   return Val_unit;
 }
 
-LLVMMetadataRef llvm_dibuild_create_compile_unit_native(
-    value Builder, value Lang, LLVMMetadataRef FileRef, value Producer,
-    value IsOptimized, value Flags, value RuntimeVer, value SplitName,
-    value Kind, value DWOId, value SplitDebugInline,
-    value DebugInfoForProfiling, value SysRoot, value SDK) {
-  return LLVMDIBuilderCreateCompileUnit(
-      DIBuilder_val(Builder), Int_val(Lang), FileRef, String_val(Producer),
-      caml_string_length(Producer), Bool_val(IsOptimized), String_val(Flags),
-      caml_string_length(Flags), Int_val(RuntimeVer), String_val(SplitName),
-      caml_string_length(SplitName), Int_val(Kind), Int_val(DWOId),
-      Bool_val(SplitDebugInline), Bool_val(DebugInfoForProfiling),
-      String_val(SysRoot), caml_string_length(SysRoot), String_val(SDK),
-      caml_string_length(SDK));
+value llvm_dibuild_create_compile_unit_native(
+    value Builder, value Lang, value FileRef, value Producer, value IsOptimized,
+    value Flags, value RuntimeVer, value SplitName, value Kind, value DWOId,
+    value SplitDebugInline, value DebugInfoForProfiling, value SysRoot,
+    value SDK) {
+  CAMLparam5(Builder, Lang, FileRef, Producer, IsOptimized);
+  CAMLxparam5(Flags, RuntimeVer, SplitName, Kind, DWOId);
+  CAMLxparam4(SplitDebugInline, DebugInfoForProfiling, SysRoot, SDK);
+  CAMLreturn(to_val(LLVMDIBuilderCreateCompileUnit(
+      DIBuilder_val(Builder), Int_val(Lang), Metadata_val(FileRef),
+      String_val(Producer), caml_string_length(Producer), Bool_val(IsOptimized),
+      String_val(Flags), caml_string_length(Flags), Int_val(RuntimeVer),
+      String_val(SplitName), caml_string_length(SplitName), Int_val(Kind),
+      Int_val(DWOId), Bool_val(SplitDebugInline),
+      Bool_val(DebugInfoForProfiling), String_val(SysRoot),
+      caml_string_length(SysRoot), String_val(SDK), caml_string_length(SDK))));
 }
 
-LLVMMetadataRef llvm_dibuild_create_compile_unit_bytecode(value *argv,
-                                                          int argn) {
+value llvm_dibuild_create_compile_unit_bytecode(value *argv, int argn) {
   return llvm_dibuild_create_compile_unit_native(
-      argv[0],                  // Builder
-      argv[1],                  // Lang
-      (LLVMMetadataRef)argv[2], // FileRef
-      argv[3],                  // Producer
-      argv[4],                  // IsOptimized
-      argv[5],                  // Flags
-      argv[6],                  // RuntimeVer
-      argv[7],                  // SplitName
-      argv[8],                  // Kind
-      argv[9],                  // DWOId
-      argv[10],                 // SplitDebugInline
-      argv[11],                 // DebugInfoForProfiling
-      argv[12],                 // SysRoot
-      argv[13]                  // SDK
+      argv[0],  // Builder
+      argv[1],  // Lang
+      argv[2],  // FileRef
+      argv[3],  // Producer
+      argv[4],  // IsOptimized
+      argv[5],  // Flags
+      argv[6],  // RuntimeVer
+      argv[7],  // SplitName
+      argv[8],  // Kind
+      argv[9],  // DWOId
+      argv[10], // SplitDebugInline
+      argv[11], // DebugInfoForProfiling
+      argv[12], // SysRoot
+      argv[13]  // SDK
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_file(value Builder, value Filename,
-                                         value Directory) {
-  return LLVMDIBuilderCreateFile(DIBuilder_val(Builder), String_val(Filename),
-                                 caml_string_length(Filename),
-                                 String_val(Directory),
-                                 caml_string_length(Directory));
+value llvm_dibuild_create_file(value Builder, value Filename, value Directory) {
+  CAMLparam3(Builder, Filename, Directory);
+  CAMLreturn(to_val(LLVMDIBuilderCreateFile(
+      DIBuilder_val(Builder), String_val(Filename),
+      caml_string_length(Filename), String_val(Directory),
+      caml_string_length(Directory))));
 }
 
-LLVMMetadataRef
-llvm_dibuild_create_module_native(value Builder, LLVMMetadataRef ParentScope,
+value llvm_dibuild_create_module_native(value Builder, value ParentScope,
                                         value Name, value ConfigMacros,
                                         value IncludePath, value SysRoot) {
-  return LLVMDIBuilderCreateModule(
-      DIBuilder_val(Builder), ParentScope, String_val(Name),
+  CAMLparam5(Builder, ParentScope, Name, ConfigMacros, IncludePath);
+  CAMLxparam1(SysRoot);
+  CAMLreturn(to_val(LLVMDIBuilderCreateModule(
+      DIBuilder_val(Builder), Metadata_val(ParentScope), String_val(Name),
       caml_string_length(Name), String_val(ConfigMacros),
       caml_string_length(ConfigMacros), String_val(IncludePath),
       caml_string_length(IncludePath), String_val(SysRoot),
-      caml_string_length(SysRoot));
+      caml_string_length(SysRoot))));
 }
 
-LLVMMetadataRef llvm_dibuild_create_module_bytecode(value *argv, int argn) {
-  return llvm_dibuild_create_module_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // ParentScope
-      argv[2],                  // Name
-      argv[3],                  // ConfigMacros
-      argv[4],                  // IncludePath
-      argv[5]                   // SysRoot
+value llvm_dibuild_create_module_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_module_native(argv[0], // Builder
+                                           argv[1], // ParentScope
+                                           argv[2], // Name
+                                           argv[3], // ConfigMacros
+                                           argv[4], // IncludePath
+                                           argv[5]  // SysRoot
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_namespace(value Builder,
-                                              LLVMMetadataRef ParentScope,
-                                              value Name, value ExportSymbols) {
-  return LLVMDIBuilderCreateNameSpace(
-      DIBuilder_val(Builder), ParentScope, String_val(Name),
-      caml_string_length(Name), Bool_val(ExportSymbols));
-}
-
-LLVMMetadataRef llvm_dibuild_create_function_native(
-    value Builder, LLVMMetadataRef Scope, value Name, value LinkageName,
-    LLVMMetadataRef File, value LineNo, LLVMMetadataRef Ty, value IsLocalToUnit,
-    value IsDefinition, value ScopeLine, value Flags, value IsOptimized) {
-  return LLVMDIBuilderCreateFunction(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      String_val(LinkageName), caml_string_length(LinkageName), File,
-      Int_val(LineNo), Ty, Bool_val(IsLocalToUnit), Bool_val(IsDefinition),
-      Int_val(ScopeLine), DIFlags_val(Flags), Bool_val(IsOptimized));
+value llvm_dibuild_create_namespace(value Builder, value ParentScope,
+  CAMLparam4(Builder, ParentScope, Name, ExportSymbols);
+  CAMLreturn(to_val(LLVMDIBuilderCreateNameSpace(
+      DIBuilder_val(Builder), Metadata_val(ParentScope), String_val(Name),
+      caml_string_length(Name), Bool_val(ExportSymbols))));
+}
+
+value llvm_dibuild_create_function_native(value Builder, value Scope,
+                                          value Name, value LinkageName,
+                                          value File, value LineNo, value Ty,
+                                          value IsLocalToUnit,
+                                          value IsDefinition, value ScopeLine,
+                                          value Flags, value IsOptimized) {
+  CAMLparam5(Builder, Scope, Name, LinkageName, File);
+  CAMLxparam5(LineNo, Ty, IsLocalToUnit, IsDefinition, ScopeLine);
+  CAMLxparam2(Flags, IsOptimized);
+  CAMLreturn(to_val(LLVMDIBuilderCreateFunction(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), String_val(LinkageName),
+      caml_string_length(LinkageName), Metadata_val(File), Int_val(LineNo),
+      Metadata_val(Ty), Bool_val(IsLocalToUnit), Bool_val(IsDefinition),
+      Int_val(ScopeLine), DIFlags_val(Flags), Bool_val(IsOptimized))));
 }
 
-LLVMMetadataRef llvm_dibuild_create_function_bytecode(value *argv, int argn) {
-  return llvm_dibuild_create_function_native(argv[0], // Builder,
-                                             (LLVMMetadataRef)argv[1], // Scope
-                                             argv[2],                  // Name
-                                             argv[3], // LinkageName
-                                             (LLVMMetadataRef)argv[4], // File
-                                             argv[5],                  // LineNo
-                                             (LLVMMetadataRef)argv[6], // Ty
+value llvm_dibuild_create_function_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_function_native(argv[0],  // Builder,
+                                             argv[1],  // Scope
+                                             argv[2],  // Name
+                                             argv[3],  // LinkageName
+                                             argv[4],  // File
+                                             argv[5],  // LineNo
+                                             argv[6],  // Ty
                                              argv[7],  // IsLocalUnit
                                              argv[8],  // IsDefinition
                                              argv[9],  // ScopeLine
                                              argv[10], // Flags
                                              argv[11]  // IsOptimized
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_lexical_block(value Builder,
-                                                  LLVMMetadataRef Scope,
-                                                  LLVMMetadataRef File,
-                                                  value Line, value Column) {
-  return LLVMDIBuilderCreateLexicalBlock(DIBuilder_val(Builder), Scope, File,
-                                         Int_val(Line), Int_val(Column));
+value llvm_dibuild_create_lexical_block(value Builder, value Scope, value File,
+  CAMLparam5(Builder, Scope, File, Line, Column);
+  CAMLreturn(to_val(LLVMDIBuilderCreateLexicalBlock(
+      DIBuilder_val(Builder), Metadata_val(Scope), Metadata_val(File),
+      Int_val(Line), Int_val(Column))));
 }
 
-LLVMMetadataRef llvm_metadata_null() { return (LLVMMetadataRef)NULL; }
+value llvm_metadata_null(value Unit) {
+  CAMLparam1(Unit);
+  CAMLreturn(to_val(NULL));
+}
 
-LLVMMetadataRef llvm_dibuild_create_debug_location(LLVMContextRef Ctx,
-                                                   value Line, value Column,
-                                                   LLVMMetadataRef Scope,
-                                                   LLVMMetadataRef InlinedAt) {
-  return LLVMDIBuilderCreateDebugLocation(Ctx, Int_val(Line), Int_val(Column),
-                                          Scope, InlinedAt);
+value llvm_dibuild_create_debug_location(value Ctx, value Line, value Column,
+                                         value Scope, value InlinedAt) {
+  CAMLparam5(Ctx, Line, Column, Scope, InlinedAt);
+  CAMLreturn(to_val(LLVMDIBuilderCreateDebugLocation(
+      Context_val(Ctx), Int_val(Line), Int_val(Column), Metadata_val(Scope),
+      Metadata_val(InlinedAt))));
 }
 
-value llvm_di_location_get_line(LLVMMetadataRef Location) {
-  return Val_int(LLVMDILocationGetLine(Location));
+value llvm_di_location_get_line(value Location) {
+  CAMLparam1(Location);
+  CAMLreturn(Val_int(LLVMDILocationGetLine(Metadata_val(Location))));
 }
 
-value llvm_di_location_get_column(LLVMMetadataRef Location) {
-  return Val_int(LLVMDILocationGetColumn(Location));
+value llvm_di_location_get_column(value Location) {
+  CAMLparam1(Location);
+  CAMLreturn(Val_int(LLVMDILocationGetColumn(Metadata_val(Location))));
 }
 
-LLVMMetadataRef llvm_di_location_get_scope(LLVMMetadataRef Location) {
-  return LLVMDILocationGetScope(Location);
+value llvm_di_location_get_scope(value Location) {
+  CAMLparam1(Location);
+  CAMLreturn(to_val(LLVMDILocationGetScope(Metadata_val(Location))));
 }
 
-value llvm_di_location_get_inlined_at(LLVMMetadataRef Location) {
-  return (ptr_to_option(LLVMDILocationGetInlinedAt(Location)));
+value llvm_di_location_get_inlined_at(value Location) {
+  CAMLparam1(Location);
+  CAMLreturn(ptr_to_option(LLVMDILocationGetInlinedAt(Metadata_val(Location))));
 }
 
-value llvm_di_scope_get_file(LLVMMetadataRef Scope) {
-  return (ptr_to_option(LLVMDIScopeGetFile(Scope)));
+value llvm_di_scope_get_file(value Scope) {
+  CAMLparam1(Scope);
+  CAMLreturn(ptr_to_option(LLVMDIScopeGetFile(Metadata_val(Scope))));
 }
 
-value llvm_di_file_get_directory(LLVMMetadataRef File) {
+value llvm_di_file_get_directory(value File) {
+  CAMLparam1(File);
   unsigned Len;
-  const char *Directory = LLVMDIFileGetDirectory(File, &Len);
-  return cstr_to_string(Directory, Len);
+  const char *Directory = LLVMDIFileGetDirectory(Metadata_val(File), &Len);
+  CAMLreturn(cstr_to_string(Directory, Len));
 }
 
-value llvm_di_file_get_filename(LLVMMetadataRef File) {
+value llvm_di_file_get_filename(value File) {
+  CAMLparam1(File);
   unsigned Len;
-  const char *Filename = LLVMDIFileGetFilename(File, &Len);
-  return cstr_to_string(Filename, Len);
+  const char *Filename = LLVMDIFileGetFilename(Metadata_val(File), &Len);
+  CAMLreturn(cstr_to_string(Filename, Len));
 }
 
-value llvm_di_file_get_source(LLVMMetadataRef File) {
+value llvm_di_file_get_source(value File) {
   unsigned Len;
-  const char *Source = LLVMDIFileGetSource(File, &Len);
+  const char *Source = LLVMDIFileGetSource(Metadata_val(File), &Len);
   return cstr_to_string(Source, Len);
 }
 
-LLVMMetadataRef llvm_dibuild_get_or_create_type_array(value Builder,
-                                                      value Data) {
-
-  return LLVMDIBuilderGetOrCreateTypeArray(DIBuilder_val(Builder),
-                                           (LLVMMetadataRef *)Op_val(Data),
-                                           Wosize_val(Data));
-}
-
-LLVMMetadataRef llvm_dibuild_get_or_create_array(value Builder, value Data) {
-
-  return LLVMDIBuilderGetOrCreateArray(DIBuilder_val(Builder),
-                                       (LLVMMetadataRef *)Op_val(Data),
-                                       Wosize_val(Data));
-}
-
-LLVMMetadataRef llvm_dibuild_create_subroutine_type(value Builder,
-                                                    LLVMMetadataRef File,
-                                                    value ParameterTypes,
-                                                    value Flags) {
-
-  return LLVMDIBuilderCreateSubroutineType(
-      DIBuilder_val(Builder), File, (LLVMMetadataRef *)Op_val(ParameterTypes),
+value llvm_dibuild_get_or_create_type_array(value Builder, value Data) {
+  CAMLparam2(Builder, Data);
+  unsigned int Count = Wosize_val(Data);
+  LLVMMetadataRef *Temp = alloc_temp(Data);
+  LLVMMetadataRef Metadata =
+      LLVMDIBuilderGetOrCreateTypeArray(DIBuilder_val(Builder), Temp, Count);
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
+}
+
+value llvm_dibuild_get_or_create_array(value Builder, value Data) {
+  CAMLparam2(Builder, Data);
+  unsigned int Count = Wosize_val(Data);
+  LLVMMetadataRef *Temp = alloc_temp(Data);
+  LLVMMetadataRef Metadata =
+      LLVMDIBuilderGetOrCreateArray(DIBuilder_val(Builder), Temp, Count);
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
+}
+
+value llvm_dibuild_create_subroutine_type(value Builder, value File,
+                                          value ParameterTypes, value Flags) {
+  CAMLparam4(Builder, File, ParameterTypes, Flags);
+  unsigned int Count = Wosize_val(ParameterTypes);
+  LLVMMetadataRef *Temp = alloc_temp(ParameterTypes);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateSubroutineType(
+      DIBuilder_val(Builder), Metadata_val(File), Temp,
       Wosize_val(ParameterTypes), DIFlags_val(Flags));
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_enumerator(value Builder, value Name,
-                                               value Value, value IsUnsigned) {
-  return LLVMDIBuilderCreateEnumerator(
+value llvm_dibuild_create_enumerator(value Builder, value Name, value Value,
+                                     value IsUnsigned) {
+  CAMLparam4(Builder, Name, Value, IsUnsigned);
+  CAMLreturn(to_val(LLVMDIBuilderCreateEnumerator(
       DIBuilder_val(Builder), String_val(Name), caml_string_length(Name),
-      (int64_t)Int_val(Value), Bool_val(IsUnsigned));
+      (int64_t)Int_val(Value), Bool_val(IsUnsigned))));
 }
 
-LLVMMetadataRef llvm_dibuild_create_enumeration_type_native(
-    value Builder, LLVMMetadataRef Scope, value Name, LLVMMetadataRef File,
-    value LineNumber, value SizeInBits, value AlignInBits, value Elements,
-    LLVMMetadataRef ClassTy) {
-  return LLVMDIBuilderCreateEnumerationType(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      File, Int_val(LineNumber), (uint64_t)Int_val(SizeInBits),
-      Int_val(AlignInBits), (LLVMMetadataRef *)Op_val(Elements),
-      Wosize_val(Elements), ClassTy);
-}
-
-LLVMMetadataRef llvm_dibuild_create_enumeration_type_bytecode(value *argv,
-                                                              int argn) {
-  return llvm_dibuild_create_enumeration_type_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Scope
-      argv[2],                  // Name
-      (LLVMMetadataRef)argv[3], // File
-      argv[4],                  // LineNumber
-      argv[5],                  // SizeInBits
-      argv[6],                  // AlignInBits
-      argv[7],                  // Elements
-      (LLVMMetadataRef)argv[8]  // ClassTy
+value llvm_dibuild_create_enumeration_type_native(
+    value Builder, value Scope, value Name, value File, value LineNumber,
+    value SizeInBits, value AlignInBits, value Elements, value ClassTy) {
+  CAMLparam5(Builder, Scope, Name, File, LineNumber);
+  CAMLxparam4(SizeInBits, AlignInBits, Elements, ClassTy);
+  unsigned int Count = Wosize_val(Elements);
+  LLVMMetadataRef *Temp = alloc_temp(Elements);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateEnumerationType(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
+      (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits), Temp, Count,
+      Metadata_val(ClassTy));
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
+}
+
+value llvm_dibuild_create_enumeration_type_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_enumeration_type_native(argv[0], // Builder
+                                                     argv[1], // Scope
+                                                     argv[2], // Name
+                                                     argv[3], // File
+                                                     argv[4], // LineNumber
+                                                     argv[5], // SizeInBits
+                                                     argv[6], // AlignInBits
+                                                     argv[7], // Elements
+                                                     argv[8]  // ClassTy
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_union_type_native(
-    value Builder, LLVMMetadataRef Scope, value Name, LLVMMetadataRef File,
-    value LineNumber, value SizeInBits, value AlignInBits, value Flags,
-    value Elements, value RunTimeLanguage, value UniqueId) {
-
-  return LLVMDIBuilderCreateUnionType(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      File, Int_val(LineNumber), (uint64_t)Int_val(SizeInBits),
-      Int_val(AlignInBits), DIFlags_val(Flags),
-      (LLVMMetadataRef *)Op_val(Elements), Wosize_val(Elements),
-      Int_val(RunTimeLanguage), String_val(UniqueId),
-      caml_string_length(UniqueId));
-}
-
-LLVMMetadataRef llvm_dibuild_create_union_type_bytecode(value *argv, int argn) {
-  return llvm_dibuild_create_union_type_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Scope
-      argv[2],                  // Name
-      (LLVMMetadataRef)argv[3], // File
-      argv[4],                  // LineNumber
-      argv[5],                  // SizeInBits
-      argv[6],                  // AlignInBits
-      argv[7],                  // Flags
-      argv[8],                  // Elements
-      argv[9],                  // RunTimeLanguage
-      argv[10]                  // UniqueId
+value llvm_dibuild_create_union_type_native(
+    value Builder, value Scope, value Name, value File, value LineNumber,
+    value SizeInBits, value AlignInBits, value Flags, value Elements,
+    value RunTimeLanguage, value UniqueId) {
+  CAMLparam5(Builder, Scope, Name, File, LineNumber);
+  CAMLxparam5(SizeInBits, AlignInBits, Flags, Elements, RunTimeLanguage);
+  CAMLxparam1(UniqueId);
+  LLVMMetadataRef *Temp = alloc_temp(Elements);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateUnionType(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
+      (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits), DIFlags_val(Flags),
+      Temp, Wosize_val(Elements), Int_val(RunTimeLanguage),
+      String_val(UniqueId), caml_string_length(UniqueId));
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
+}
+
+value llvm_dibuild_create_union_type_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_union_type_native(argv[0], // Builder
+                                               argv[1], // Scope
+                                               argv[2], // Name
+                                               argv[3], // File
+                                               argv[4], // LineNumber
+                                               argv[5], // SizeInBits
+                                               argv[6], // AlignInBits
+                                               argv[7], // Flags
+                                               argv[8], // Elements
+                                               argv[9], // RunTimeLanguage
+                                               argv[10] // UniqueId
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_array_type(value Builder, value Size,
-                                               value AlignInBits,
-                                               LLVMMetadataRef Ty,
-                                               value Subscripts) {
-  return LLVMDIBuilderCreateArrayType(
-      DIBuilder_val(Builder), (uint64_t)Int_val(Size), Int_val(AlignInBits), Ty,
-      (LLVMMetadataRef *)Op_val(Subscripts), Wosize_val(Subscripts));
+value llvm_dibuild_create_array_type(value Builder, value Size,
+                                     value AlignInBits, value Ty,
+  CAMLparam5(Builder, Size, AlignInBits, Ty, Subscripts);
+  LLVMMetadataRef *Temp = alloc_temp(Subscripts);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateArrayType(
+      DIBuilder_val(Builder), (uint64_t)Int_val(Size), Int_val(AlignInBits),
+      Metadata_val(Ty), Temp, Wosize_val(Subscripts));
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_vector_type(value Builder, value Size,
-                                                value AlignInBits,
-                                                LLVMMetadataRef Ty,
-                                                value Subscripts) {
-  return LLVMDIBuilderCreateVectorType(
-      DIBuilder_val(Builder), (uint64_t)Int_val(Size), Int_val(AlignInBits), Ty,
-      (LLVMMetadataRef *)Op_val(Subscripts), Wosize_val(Subscripts));
+value llvm_dibuild_create_vector_type(value Builder, value Size,
+                                      value AlignInBits, value Ty,
+  CAMLparam5(Builder, Size, AlignInBits, Ty, Subscripts);
+  LLVMMetadataRef *Temp = alloc_temp(Subscripts);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateVectorType(
+      DIBuilder_val(Builder), (uint64_t)Int_val(Size), Int_val(AlignInBits),
+      Metadata_val(Ty), Temp, Wosize_val(Subscripts));
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_unspecified_type(value Builder,
-                                                     value Name) {
-  return LLVMDIBuilderCreateUnspecifiedType(
+value llvm_dibuild_create_unspecified_type(value Builder, value Name) {
+  CAMLparam2(Builder, Name);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateUnspecifiedType(
       DIBuilder_val(Builder), String_val(Name), caml_string_length(Name));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_basic_type(value Builder, value Name,
-                                               value SizeInBits, value Encoding,
-                                               value Flags) {
-
-  return LLVMDIBuilderCreateBasicType(
+value llvm_dibuild_create_basic_type(value Builder, value Name,
+  CAMLparam5(Builder, Name, SizeInBits, Encoding, Flags);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateBasicType(
       DIBuilder_val(Builder), String_val(Name), caml_string_length(Name),
       (uint64_t)Int_val(SizeInBits), Int_val(Encoding), DIFlags_val(Flags));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_pointer_type_native(
-    value Builder, LLVMMetadataRef PointeeTy, value SizeInBits,
-    value AlignInBits, value AddressSpace, value Name) {
-  return LLVMDIBuilderCreatePointerType(
-      DIBuilder_val(Builder), PointeeTy, (uint64_t)Int_val(SizeInBits),
-      Int_val(AlignInBits), Int_val(AddressSpace), String_val(Name),
-      caml_string_length(Name));
+value llvm_dibuild_create_pointer_type_native(value Builder, value PointeeTy,
+                                              value SizeInBits,
+                                              value AlignInBits,
+                                              value AddressSpace, value Name) {
+  CAMLparam5(Builder, PointeeTy, SizeInBits, AlignInBits, AddressSpace);
+  CAMLxparam1(Name);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreatePointerType(
+      DIBuilder_val(Builder), Metadata_val(PointeeTy),
+      (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits),
+      Int_val(AddressSpace), String_val(Name), caml_string_length(Name));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_pointer_type_bytecode(value *argv,
-                                                          int argn) {
-  return llvm_dibuild_create_pointer_type_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // PointeeTy
-      argv[2],                  // SizeInBits
-      argv[3],                  // AlignInBits
-      argv[4],                  // AddressSpace
-      argv[5]                   // Name
+value llvm_dibuild_create_pointer_type_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_pointer_type_native(argv[0], // Builder
+                                                 argv[1], // PointeeTy
+                                                 argv[2], // SizeInBits
+                                                 argv[3], // AlignInBits
+                                                 argv[4], // AddressSpace
+                                                 argv[5]  // Name
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_struct_type_native(
-    value Builder, LLVMMetadataRef Scope, value Name, LLVMMetadataRef File,
-    value LineNumber, value SizeInBits, value AlignInBits, value Flags,
-    LLVMMetadataRef DerivedFrom, value Elements, value RunTimeLanguage,
-    LLVMMetadataRef VTableHolder, value UniqueId) {
-
-  return LLVMDIBuilderCreateStructType(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      File, Int_val(LineNumber), (uint64_t)Int_val(SizeInBits),
-      Int_val(AlignInBits), DIFlags_val(Flags), DerivedFrom,
-      (LLVMMetadataRef *)Op_val(Elements), Wosize_val(Elements),
-      Int_val(RunTimeLanguage), VTableHolder, String_val(UniqueId),
-      caml_string_length(UniqueId));
-}
-
-LLVMMetadataRef llvm_dibuild_create_struct_type_bytecode(value *argv,
-                                                         int argn) {
-  return llvm_dibuild_create_struct_type_native(
-      argv[0],                   // Builder
-      (LLVMMetadataRef)argv[1],  // Scope
-      argv[2],                   // Name
-      (LLVMMetadataRef)argv[3],  // File
-      argv[4],                   // LineNumber
-      argv[5],                   // SizeInBits
-      argv[6],                   // AlignInBits
-      argv[7],                   // Flags
-      (LLVMMetadataRef)argv[8],  // DeriviedFrom
-      argv[9],                   // Elements
-      argv[10],                  // RunTimeLanguage
-      (LLVMMetadataRef)argv[11], // VTableHolder
-      argv[12]                   // UniqueId
+value llvm_dibuild_create_struct_type_native(
+    value Builder, value Scope, value Name, value File, value LineNumber,
+    value SizeInBits, value AlignInBits, value Flags, value DerivedFrom,
+    value Elements, value RunTimeLanguage, value VTableHolder, value UniqueId) {
+  CAMLparam5(Builder, Scope, Name, File, LineNumber);
+  CAMLxparam5(SizeInBits, AlignInBits, Flags, DerivedFrom, Elements);
+  CAMLxparam3(RunTimeLanguage, VTableHolder, UniqueId);
+  LLVMMetadataRef *Temp = alloc_temp(Elements);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateStructType(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
+      (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits), DIFlags_val(Flags),
+      Metadata_val(DerivedFrom), Temp, Wosize_val(Elements),
+      Int_val(RunTimeLanguage), Metadata_val(VTableHolder),
+      String_val(UniqueId), caml_string_length(UniqueId));
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
+}
+
+value llvm_dibuild_create_struct_type_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_struct_type_native(argv[0],  // Builder
+                                                argv[1],  // Scope
+                                                argv[2],  // Name
+                                                argv[3],  // File
+                                                argv[4],  // LineNumber
+                                                argv[5],  // SizeInBits
+                                                argv[6],  // AlignInBits
+                                                argv[7],  // Flags
+                                                argv[8],  // DeriviedFrom
+                                                argv[9],  // Elements
+                                                argv[10], // RunTimeLanguage
+                                                argv[11], // VTableHolder
+                                                argv[12]  // UniqueId
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_member_type_native(
-    value Builder, LLVMMetadataRef Scope, value Name, LLVMMetadataRef File,
-    value LineNumber, value SizeInBits, value AlignInBits, value OffsetInBits,
-    value Flags, LLVMMetadataRef Ty) {
-
-  return LLVMDIBuilderCreateMemberType(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      File, Int_val(LineNumber), (uint64_t)Int_val(SizeInBits),
-      Int_val(AlignInBits), (uint64_t)Int_val(OffsetInBits), DIFlags_val(Flags),
-      Ty);
+value llvm_dibuild_create_member_type_native(value Builder, value Scope,
+                                             value Name, value File,
+                                             value LineNumber, value SizeInBits,
+                                             value AlignInBits,
+                                             value OffsetInBits, value Flags,
+                                             value Ty) {
+  CAMLparam5(Builder, Scope, Name, File, LineNumber);
+  CAMLxparam5(SizeInBits, AlignInBits, OffsetInBits, Flags, Ty);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateMemberType(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
+      (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits),
+      (uint64_t)Int_val(OffsetInBits), DIFlags_val(Flags), Metadata_val(Ty));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_member_type_bytecode(value *argv,
-                                                         int argn) {
-  return llvm_dibuild_create_member_type_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Scope
-      argv[2],                  // Name
-      (LLVMMetadataRef)argv[3], // File
-      argv[4],                  // LineNumber
-      argv[5],                  // SizeInBits
-      argv[6],                  // AlignInBits
-      argv[7],                  // OffsetInBits
-      argv[8],                  // Flags
-      (LLVMMetadataRef)argv[9]  // Ty
+value llvm_dibuild_create_member_type_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_member_type_native(argv[0], // Builder
+                                                argv[1], // Scope
+                                                argv[2], // Name
+                                                argv[3], // File
+                                                argv[4], // LineNumber
+                                                argv[5], // SizeInBits
+                                                argv[6], // AlignInBits
+                                                argv[7], // OffsetInBits
+                                                argv[8], // Flags
+                                                argv[9]  // Ty
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_static_member_type_native(
-    value Builder, LLVMMetadataRef Scope, value Name, LLVMMetadataRef File,
-    value LineNumber, LLVMMetadataRef Type, value Flags,
-    LLVMValueRef ConstantVal, value AlignInBits) {
-
-  return LLVMDIBuilderCreateStaticMemberType(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      File, Int_val(LineNumber), Type, DIFlags_val(Flags), ConstantVal,
+value llvm_dibuild_create_static_member_type_native(
+    value Builder, value Scope, value Name, value File, value LineNumber,
+    value Type, value Flags, value ConstantVal, value AlignInBits) {
+  CAMLparam5(Builder, Scope, Name, File, LineNumber);
+  CAMLxparam4(Type, Flags, ConstantVal, AlignInBits);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateStaticMemberType(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
+      Metadata_val(Type), DIFlags_val(Flags), Value_val(ConstantVal),
       Int_val(AlignInBits));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_static_member_type_bytecode(value *argv,
-                                                                int argn) {
-  return llvm_dibuild_create_static_member_type_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Scope
-      argv[2],                  // Name
-      (LLVMMetadataRef)argv[3], // File
-      argv[4],                  // LineNumber
-      (LLVMMetadataRef)argv[5], // Type
-      argv[6],                  // Flags,
-      (LLVMValueRef)argv[7],    // ConstantVal
-      argv[8]                   // AlignInBits
+value llvm_dibuild_create_static_member_type_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_static_member_type_native(argv[0], // Builder
+                                                       argv[1], // Scope
+                                                       argv[2], // Name
+                                                       argv[3], // File
+                                                       argv[4], // LineNumber
+                                                       argv[5], // Type
+                                                       argv[6], // Flags,
+                                                       argv[7], // ConstantVal
+                                                       argv[8]  // AlignInBits
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_member_pointer_type_native(
-    value Builder, LLVMMetadataRef PointeeType, LLVMMetadataRef ClassType,
-    uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags) {
-
-  return LLVMDIBuilderCreateMemberPointerType(
-      DIBuilder_val(Builder), PointeeType, ClassType,
-      (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits), Flags);
-}
-
-LLVMMetadataRef llvm_dibuild_create_member_pointer_type_bytecode(value *argv,
-                                                                 int argn) {
-  return llvm_dibuild_create_member_pointer_type_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // PointeeType
-      (LLVMMetadataRef)argv[2], // ClassType
-      argv[3],                  // SizeInBits
-      argv[4],                  // AlignInBits
-      argv[5]                   // Flags
+value llvm_dibuild_create_member_pointer_type_native(
+    value Builder, value PointeeType, value ClassType, value SizeInBits,
+    value AlignInBits, value Flags) {
+  CAMLparam5(Builder, PointeeType, ClassType, SizeInBits, AlignInBits);
+  CAMLxparam1(Flags);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateMemberPointerType(
+      DIBuilder_val(Builder), Metadata_val(PointeeType),
+      Metadata_val(ClassType), (uint64_t)Int_val(SizeInBits),
+      Int_val(AlignInBits), llvm_diflags_get(Flags));
+  CAMLreturn(to_val(Metadata));
+}
+
+value llvm_dibuild_create_member_pointer_type_bytecode(value *argv, int argn) {
+  return llvm_dibuild_create_member_pointer_type_native(argv[0], // Builder
+                                                        argv[1], // PointeeType
+                                                        argv[2], // ClassType
+                                                        argv[3], // SizeInBits
+                                                        argv[4], // AlignInBits
+                                                        argv[5]  // Flags
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_object_pointer_type(value Builder,
-                                                        LLVMMetadataRef Type) {
-  return LLVMDIBuilderCreateObjectPointerType(DIBuilder_val(Builder), Type);
+value llvm_dibuild_create_object_pointer_type(value Builder, value Type) {
+  CAMLparam2(Builder, Type);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateObjectPointerType(
+      DIBuilder_val(Builder), Metadata_val(Type));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_qualified_type(value Builder, value Tag,
-                                                   LLVMMetadataRef Type) {
-
-  return LLVMDIBuilderCreateQualifiedType(DIBuilder_val(Builder), Int_val(Tag),
-                                          Type);
+value llvm_dibuild_create_qualified_type(value Builder, value Tag, value Type) {
+  CAMLparam3(Builder, Tag, Type);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateQualifiedType(
+      DIBuilder_val(Builder), Int_val(Tag), Metadata_val(Type));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_reference_type(value Builder, value Tag,
-                                                   LLVMMetadataRef Type) {
-
-  return LLVMDIBuilderCreateReferenceType(DIBuilder_val(Builder), Int_val(Tag),
-                                          Type);
+value llvm_dibuild_create_reference_type(value Builder, value Tag, value Type) {
+  CAMLparam3(Builder, Tag, Type);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateReferenceType(
+      DIBuilder_val(Builder), Int_val(Tag), Metadata_val(Type));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_null_ptr_type(value Builder) {
+value llvm_dibuild_create_null_ptr_type(value Builder) {
 
-  return LLVMDIBuilderCreateNullPtrType(DIBuilder_val(Builder));
+  CAMLparam1(Builder);
+  CAMLreturn(to_val(LLVMDIBuilderCreateNullPtrType(DIBuilder_val(Builder))));
 }
 
-LLVMMetadataRef llvm_dibuild_create_typedef_native(
-    value Builder, LLVMMetadataRef Type, value Name, LLVMMetadataRef File,
-    value LineNo, LLVMMetadataRef Scope, value AlignInBits) {
+value llvm_dibuild_create_typedef_native(value Builder, value Type, value Name,
+                                         value File, value LineNo, value Scope,
+                                         value AlignInBits) {
 
-  return LLVMDIBuilderCreateTypedef(
-      DIBuilder_val(Builder), Type, String_val(Name), caml_string_length(Name),
-      File, Int_val(LineNo), Scope, Int_val(AlignInBits));
+  CAMLparam5(Builder, Type, Name, File, LineNo);
+  CAMLxparam2(Scope, AlignInBits);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateTypedef(
+      DIBuilder_val(Builder), Metadata_val(Type), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(LineNo),
+      Metadata_val(Scope), Int_val(AlignInBits));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_typedef_bytecode(value *argv, int argn) {
+value llvm_dibuild_create_typedef_bytecode(value *argv, int argn) {
 
-  return llvm_dibuild_create_typedef_native(argv[0],                  // Builder
-                                            (LLVMMetadataRef)argv[1], // Type
-                                            argv[2],                  // Name
-                                            (LLVMMetadataRef)argv[3], // File
-                                            argv[4],                  // LineNo
-                                            (LLVMMetadataRef)argv[5], // Scope
-                                            argv[6] // AlignInBits
+  return llvm_dibuild_create_typedef_native(argv[0], // Builder
+                                            argv[1], // Type
+                                            argv[2], // Name
+                                            argv[3], // File
+                                            argv[4], // LineNo
+                                            argv[5], // Scope
+                                            argv[6]  // AlignInBits
   );
 }
 
-LLVMMetadataRef
-llvm_dibuild_create_inheritance_native(value Builder, LLVMMetadataRef Ty,
-                                       LLVMMetadataRef BaseTy, value BaseOffset,
+value llvm_dibuild_create_inheritance_native(value Builder, value Ty,
+                                             value BaseTy, value BaseOffset,
                                              value VBPtrOffset, value Flags) {
-
-  return LLVMDIBuilderCreateInheritance(DIBuilder_val(Builder), Ty, BaseTy,
-                                        (uint64_t)Int_val(BaseOffset),
-                                        Int_val(VBPtrOffset), Flags);
+  CAMLparam5(Builder, Ty, BaseTy, BaseOffset, VBPtrOffset);
+  CAMLxparam1(Flags);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateInheritance(
+      DIBuilder_val(Builder), Metadata_val(Ty), Metadata_val(BaseTy),
+      (uint64_t)Int_val(BaseOffset), Int_val(VBPtrOffset), DIFlags_val(Flags));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_inheritance_bytecode(value *argv, int arg) {
-
-  return llvm_dibuild_create_inheritance_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Ty
-      (LLVMMetadataRef)argv[2], // BaseTy
-      argv[3],                  // BaseOffset
-      argv[4],                  // VBPtrOffset
-      argv[5]                   // Flags
+value llvm_dibuild_create_inheritance_bytecode(value *argv, int arg) {
+
+  return llvm_dibuild_create_inheritance_native(argv[0], // Builder
+                                                argv[1], // Ty
+                                                argv[2], // BaseTy
+                                                argv[3], // BaseOffset
+                                                argv[4], // VBPtrOffset
+                                                argv[5]  // Flags
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_forward_decl_native(
-    value Builder, value Tag, value Name, LLVMMetadataRef Scope,
-    LLVMMetadataRef File, value Line, value RuntimeLang, value SizeInBits,
-    value AlignInBits, value UniqueIdentifier) {
-  return LLVMDIBuilderCreateForwardDecl(
+value llvm_dibuild_create_forward_decl_native(
+    value Builder, value Tag, value Name, value Scope, value File, value Line,
+    value RuntimeLang, value SizeInBits, value AlignInBits,
+    value UniqueIdentifier) {
+  CAMLparam5(Builder, Tag, Name, Scope, File);
+  CAMLxparam5(Line, RuntimeLang, SizeInBits, AlignInBits, UniqueIdentifier);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateForwardDecl(
       DIBuilder_val(Builder), Int_val(Tag), String_val(Name),
-      caml_string_length(Name), Scope, File, Int_val(Line),
-      Int_val(RuntimeLang), (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits),
-      String_val(UniqueIdentifier), caml_string_length(UniqueIdentifier));
+      caml_string_length(Name), Metadata_val(Scope), Metadata_val(File),
+      Int_val(Line), Int_val(RuntimeLang), (uint64_t)Int_val(SizeInBits),
+      Int_val(AlignInBits), String_val(UniqueIdentifier),
+      caml_string_length(UniqueIdentifier));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_forward_decl_bytecode(value *argv,
-                                                          int arg) {
+value llvm_dibuild_create_forward_decl_bytecode(value *argv, int arg) {
 
-  return llvm_dibuild_create_forward_decl_native(
-      argv[0],                  // Builder
-      argv[1],                  // Tag
-      argv[2],                  // Name
-      (LLVMMetadataRef)argv[3], // Scope
-      (LLVMMetadataRef)argv[4], // File
-      argv[5],                  // Line
-      argv[6],                  // RuntimeLang
-      argv[7],                  // SizeInBits
-      argv[8],                  // AlignInBits
-      argv[9]                   // UniqueIdentifier
+  return llvm_dibuild_create_forward_decl_native(argv[0], // Builder
+                                                 argv[1], // Tag
+                                                 argv[2], // Name
+                                                 argv[3], // Scope
+                                                 argv[4], // File
+                                                 argv[5], // Line
+                                                 argv[6], // RuntimeLang
+                                                 argv[7], // SizeInBits
+                                                 argv[8], // AlignInBits
+                                                 argv[9]  // UniqueIdentifier
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_replaceable_composite_type_native(
-    value Builder, value Tag, value Name, LLVMMetadataRef Scope,
-    LLVMMetadataRef File, value Line, value RuntimeLang, value SizeInBits,
-    value AlignInBits, value Flags, value UniqueIdentifier) {
-
-  return LLVMDIBuilderCreateReplaceableCompositeType(
+value llvm_dibuild_create_replaceable_composite_type_native(
+    value Builder, value Tag, value Name, value Scope, value File, value Line,
+    value RuntimeLang, value SizeInBits, value AlignInBits, value Flags,
+    value UniqueIdentifier) {
+  CAMLparam5(Builder, Tag, Name, Scope, File);
+  CAMLxparam5(Line, RuntimeLang, SizeInBits, AlignInBits, Flags);
+  CAMLxparam1(UniqueIdentifier);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateReplaceableCompositeType(
       DIBuilder_val(Builder), Int_val(Tag), String_val(Name),
-      caml_string_length(Name), Scope, File, Int_val(Line),
-      Int_val(RuntimeLang), (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits),
-      DIFlags_val(Flags), String_val(UniqueIdentifier),
+      caml_string_length(Name), Metadata_val(Scope), Metadata_val(File),
+      Int_val(Line), Int_val(RuntimeLang), (uint64_t)Int_val(SizeInBits),
+      Int_val(AlignInBits), DIFlags_val(Flags), String_val(UniqueIdentifier),
       caml_string_length(UniqueIdentifier));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef
-llvm_dibuild_create_replaceable_composite_type_bytecode(value *argv, int arg) {
+value llvm_dibuild_create_replaceable_composite_type_bytecode(value *argv,
+                                                              int arg) {
 
   return llvm_dibuild_create_replaceable_composite_type_native(
-      argv[0],                  // Builder
-      argv[1],                  // Tag
-      argv[2],                  // Name
-      (LLVMMetadataRef)argv[3], // Scope
-      (LLVMMetadataRef)argv[4], // File
-      argv[5],                  // Line
-      argv[6],                  // RuntimeLang
-      argv[7],                  // SizeInBits
-      argv[8],                  // AlignInBits
-      argv[9],                  // Flags
-      argv[10]                  // UniqueIdentifier
+      argv[0], // Builder
+      argv[1], // Tag
+      argv[2], // Name
+      argv[3], // Scope
+      argv[4], // File
+      argv[5], // Line
+      argv[6], // RuntimeLang
+      argv[7], // SizeInBits
+      argv[8], // AlignInBits
+      argv[9], // Flags
+      argv[10] // UniqueIdentifier
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_bit_field_member_type_native(
-    value Builder, LLVMMetadataRef Scope, value Name, LLVMMetadataRef File,
-    value LineNum, value SizeInBits, value OffsetInBits,
-    value StorageOffsetInBits, value Flags, LLVMMetadataRef Ty) {
-
-  return LLVMDIBuilderCreateBitFieldMemberType(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      File, Int_val(LineNum), (uint64_t)Int_val(SizeInBits),
-      (uint64_t)Int_val(OffsetInBits), (uint64_t)Int_val(StorageOffsetInBits),
-      DIFlags_val(Flags), Ty);
+value llvm_dibuild_create_bit_field_member_type_native(
+    value Builder, value Scope, value Name, value File, value LineNum,
+    value SizeInBits, value OffsetInBits, value StorageOffsetInBits,
+    value Flags, value Ty) {
+  CAMLparam5(Builder, Scope, Name, File, LineNum);
+  CAMLxparam5(SizeInBits, OffsetInBits, StorageOffsetInBits, Flags, Ty);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateBitFieldMemberType(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(LineNum),
+      (uint64_t)Int_val(SizeInBits), (uint64_t)Int_val(OffsetInBits),
+      (uint64_t)Int_val(StorageOffsetInBits), DIFlags_val(Flags),
+      Metadata_val(Ty));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_bit_field_member_type_bytecode(value *argv,
-                                                                   int arg) {
+value llvm_dibuild_create_bit_field_member_type_bytecode(value *argv, int arg) {
 
   return llvm_dibuild_create_bit_field_member_type_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Scope
-      argv[2],                  // Name
-      (LLVMMetadataRef)argv[3], // File
-      argv[4],                  // LineNum
-      argv[5],                  // SizeInBits
-      argv[6],                  // OffsetInBits
-      argv[7],                  // StorageOffsetInBits
-      argv[8],                  // Flags
-      (LLVMMetadataRef)argv[9]  // Ty
+      argv[0], // Builder
+      argv[1], // Scope
+      argv[2], // Name
+      argv[3], // File
+      argv[4], // LineNum
+      argv[5], // SizeInBits
+      argv[6], // OffsetInBits
+      argv[7], // StorageOffsetInBits
+      argv[8], // Flags
+      argv[9]  // Ty
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_class_type_native(
-    value Builder, LLVMMetadataRef Scope, value Name, LLVMMetadataRef File,
-    value LineNumber, value SizeInBits, value AlignInBits, value OffsetInBits,
-    value Flags, LLVMMetadataRef DerivedFrom, value Elements,
-    LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode,
-    value UniqueIdentifier) {
-
-  return LLVMDIBuilderCreateClassType(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      File, Int_val(LineNumber), (uint64_t)Int_val(SizeInBits),
-      Int_val(AlignInBits), (uint64_t)Int_val(OffsetInBits), DIFlags_val(Flags),
-      DerivedFrom, (LLVMMetadataRef *)Op_val(Elements), Wosize_val(Elements),
-      VTableHolder, TemplateParamsNode, String_val(UniqueIdentifier),
-      caml_string_length(UniqueIdentifier));
+value llvm_dibuild_create_class_type_native(
+    value Builder, value Scope, value Name, value File, value LineNumber,
+    value SizeInBits, value AlignInBits, value OffsetInBits, value Flags,
+    value DerivedFrom, value Elements, value VTableHolder,
+    value TemplateParamsNode, value UniqueIdentifier) {
+  CAMLparam5(Builder, Scope, Name, File, LineNumber);
+  CAMLxparam5(SizeInBits, AlignInBits, OffsetInBits, Flags, DerivedFrom);
+  CAMLxparam4(Elements, VTableHolder, TemplateParamsNode, UniqueIdentifier);
+  LLVMMetadataRef *Temp = alloc_temp(Elements);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateClassType(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
+      (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits),
+      (uint64_t)Int_val(OffsetInBits), DIFlags_val(Flags),
+      Metadata_val(DerivedFrom), Temp, Wosize_val(Elements),
+      Metadata_val(VTableHolder), Metadata_val(TemplateParamsNode),
+      String_val(UniqueIdentifier), caml_string_length(UniqueIdentifier));
+  free(Temp);
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_class_type_bytecode(value *argv, int arg) {
+value llvm_dibuild_create_class_type_bytecode(value *argv, int arg) {
 
-  return llvm_dibuild_create_class_type_native(
-      argv[0],                   // Builder
-      (LLVMMetadataRef)argv[1],  // Scope
-      argv[2],                   // Name
-      (LLVMMetadataRef)argv[3],  // File
-      argv[4],                   // LineNumber
-      argv[5],                   // SizeInBits
-      argv[6],                   // AlignInBits
-      argv[7],                   // OffsetInBits
-      argv[8],                   // Flags
-      (LLVMMetadataRef)argv[9],  // DerivedFrom
-      argv[10],                  // Elements
-      (LLVMMetadataRef)argv[11], // VTableHolder
-      (LLVMMetadataRef)argv[12], // TemplateParamsNode
-      argv[13]                   // UniqueIdentifier
+  return llvm_dibuild_create_class_type_native(argv[0],  // Builder
+                                               argv[1],  // Scope
+                                               argv[2],  // Name
+                                               argv[3],  // File
+                                               argv[4],  // LineNumber
+                                               argv[5],  // SizeInBits
+                                               argv[6],  // AlignInBits
+                                               argv[7],  // OffsetInBits
+                                               argv[8],  // Flags
+                                               argv[9],  // DerivedFrom
+                                               argv[10], // Elements
+                                               argv[11], // VTableHolder
+                                               argv[12], // TemplateParamsNode
+                                               argv[13]  // UniqueIdentifier
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_artificial_type(value Builder,
-                                                    LLVMMetadataRef Type) {
-  return LLVMDIBuilderCreateArtificialType(DIBuilder_val(Builder), Type);
+value llvm_dibuild_create_artificial_type(value Builder, value Type) {
+  CAMLparam2(Builder, Type);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateArtificialType(
+      DIBuilder_val(Builder), Metadata_val(Type));
+  CAMLreturn(to_val(Metadata));
 }
 
-value llvm_di_type_get_name(LLVMMetadataRef DType) {
+value llvm_di_type_get_name(value DType) {
+  CAMLparam1(DType);
   size_t Len;
-  const char *Name = LLVMDITypeGetName(DType, &Len);
-  return cstr_to_string(Name, Len);
+  const char *Name = LLVMDITypeGetName(Metadata_val(DType), &Len);
+  CAMLreturn(cstr_to_string(Name, Len));
 }
 
-value llvm_di_type_get_size_in_bits(LLVMMetadataRef DType) {
-  uint64_t Size = LLVMDITypeGetSizeInBits(DType);
-  return Val_int((int)Size);
+value llvm_di_type_get_size_in_bits(value DType) {
+  CAMLparam1(DType);
+  uint64_t Size = LLVMDITypeGetSizeInBits(Metadata_val(DType));
+  CAMLreturn(Val_int((int)Size));
 }
 
-value llvm_di_type_get_offset_in_bits(LLVMMetadataRef DType) {
-  uint64_t Size = LLVMDITypeGetOffsetInBits(DType);
-  return Val_int((int)Size);
+value llvm_di_type_get_offset_in_bits(value DType) {
+  CAMLparam1(DType);
+  uint64_t Size = LLVMDITypeGetOffsetInBits(Metadata_val(DType));
+  CAMLreturn(Val_int((int)Size));
 }
 
-value llvm_di_type_get_align_in_bits(LLVMMetadataRef DType) {
-  uint32_t Size = LLVMDITypeGetAlignInBits(DType);
-  return Val_int(Size);
+value llvm_di_type_get_align_in_bits(value DType) {
+  CAMLparam1(DType);
+  uint32_t Size = LLVMDITypeGetAlignInBits(Metadata_val(DType));
+  CAMLreturn(Val_int(Size));
 }
 
-value llvm_di_type_get_line(LLVMMetadataRef DType) {
-  unsigned Line = LLVMDITypeGetLine(DType);
-  return Val_int(Line);
+value llvm_di_type_get_line(value DType) {
+  CAMLparam1(DType);
+  unsigned Line = LLVMDITypeGetLine(Metadata_val(DType));
+  CAMLreturn(Val_int(Line));
 }
 
-value llvm_di_type_get_flags(LLVMMetadataRef DType) {
-  LLVMDIFlags Flags = LLVMDITypeGetLine(DType);
-  return alloc_diflags(Flags);
+value llvm_di_type_get_flags(value DType) {
+  CAMLparam1(DType);
+  LLVMDIFlags Flags = LLVMDITypeGetLine(Metadata_val(DType));
+  CAMLreturn(alloc_diflags(Flags));
 }
 
-value llvm_get_subprogram(LLVMValueRef Func) {
-  return (ptr_to_option(LLVMGetSubprogram(Func)));
+value llvm_get_subprogram(value Func) {
+  CAMLparam1(Func);
+  CAMLreturn(ptr_to_option(LLVMGetSubprogram(Value_val(Func))));
 }
 
-value llvm_set_subprogram(LLVMValueRef Func, LLVMMetadataRef SP) {
-  LLVMSetSubprogram(Func, SP);
-  return Val_unit;
+value llvm_set_subprogram(value Func, value SP) {
+  CAMLparam2(Func, SP);
+  LLVMSetSubprogram(Value_val(Func), Metadata_val(SP));
+  CAMLreturn(Val_unit);
 }
 
-value llvm_di_subprogram_get_line(LLVMMetadataRef Subprogram) {
-  return Val_int(LLVMDISubprogramGetLine(Subprogram));
+value llvm_di_subprogram_get_line(value Subprogram) {
+  CAMLparam1(Subprogram);
+  CAMLreturn(Val_int(LLVMDISubprogramGetLine(Metadata_val(Subprogram))));
 }
 
-value llvm_instr_get_debug_loc(LLVMValueRef Inst) {
-  return (ptr_to_option(LLVMInstructionGetDebugLoc(Inst)));
+value llvm_instr_get_debug_loc(value Inst) {
+  CAMLparam1(Inst);
+  CAMLreturn(ptr_to_option(LLVMInstructionGetDebugLoc(Value_val(Inst))));
 }
 
-value llvm_instr_set_debug_loc(LLVMValueRef Inst, LLVMMetadataRef Loc) {
-  LLVMInstructionSetDebugLoc(Inst, Loc);
-  return Val_unit;
+value llvm_instr_set_debug_loc(value Inst, value Loc) {
+  CAMLparam2(Inst, Loc);
+  LLVMInstructionSetDebugLoc(Value_val(Inst), Metadata_val(Loc));
+  CAMLreturn(Val_unit);
 }
 
-LLVMMetadataRef llvm_dibuild_create_constant_value_expression(value Builder,
-                                                              value Value) {
-  return LLVMDIBuilderCreateConstantValueExpression(DIBuilder_val(Builder),
-                                                    (uint64_t)Int_val(Value));
+value llvm_dibuild_create_constant_value_expression(value Builder,
+  CAMLparam2(Builder, Value);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateConstantValueExpression(
+      DIBuilder_val(Builder), (uint64_t)Int_val(Value));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_global_variable_expression_native(
-    value Builder, LLVMMetadataRef Scope, value Name, value Linkage,
-    LLVMMetadataRef File, value Line, LLVMMetadataRef Ty, value LocalToUnit,
-    LLVMMetadataRef Expr, LLVMMetadataRef Decl, value AlignInBits) {
-  return LLVMDIBuilderCreateGlobalVariableExpression(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      String_val(Linkage), caml_string_length(Linkage), File, Int_val(Line), Ty,
-      Bool_val(LocalToUnit), Expr, Decl, Int_val(AlignInBits));
+value llvm_dibuild_create_global_variable_expression_native(
+    value Builder, value Scope, value Name, value Linkage, value File,
+    value Line, value Ty, value LocalToUnit, value Expr, value Decl,
+    value AlignInBits) {
+  CAMLparam5(Builder, Scope, Name, Linkage, File);
+  CAMLxparam5(Line, Ty, LocalToUnit, Expr, Decl);
+  CAMLxparam1(AlignInBits);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateGlobalVariableExpression(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), String_val(Linkage),
+      caml_string_length(Linkage), Metadata_val(File), Int_val(Line),
+      Metadata_val(Ty), Bool_val(LocalToUnit), Metadata_val(Expr),
+      Metadata_val(Decl), Int_val(AlignInBits));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef
-llvm_dibuild_create_global_variable_expression_bytecode(value *argv, int arg) {
+value llvm_dibuild_create_global_variable_expression_bytecode(value *argv,
+                                                              int arg) {
 
   return llvm_dibuild_create_global_variable_expression_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Scope
-      argv[2],                  // Name
-      argv[3],                  // Linkage
-      (LLVMMetadataRef)argv[4], // File
-      argv[5],                  // Line
-      (LLVMMetadataRef)argv[6], // Ty
-      argv[7],                  // LocalToUnit
-      (LLVMMetadataRef)argv[8], // Expr
-      (LLVMMetadataRef)argv[9], // Decl
-      argv[10]                  // AlignInBits
+      argv[0], // Builder
+      argv[1], // Scope
+      argv[2], // Name
+      argv[3], // Linkage
+      argv[4], // File
+      argv[5], // Line
+      argv[6], // Ty
+      argv[7], // LocalToUnit
+      argv[8], // Expr
+      argv[9], // Decl
+      argv[10] // AlignInBits
   );
 }
 
-value llvm_di_global_variable_expression_get_variable(LLVMMetadataRef GVE) {
-  return (ptr_to_option(LLVMDIGlobalVariableExpressionGetVariable(GVE)));
+value llvm_di_global_variable_expression_get_variable(value GVE) {
+  CAMLparam1(GVE);
+  CAMLreturn(ptr_to_option(
+      LLVMDIGlobalVariableExpressionGetVariable(Metadata_val(GVE))));
 }
 
-value llvm_di_variable_get_line(LLVMMetadataRef Variable) {
-  return Val_int(LLVMDIVariableGetLine(Variable));
+value llvm_di_variable_get_line(value Variable) {
+  CAMLparam1(Variable);
+  CAMLreturn(Val_int(LLVMDIVariableGetLine(Metadata_val(Variable))));
 }
 
-value llvm_di_variable_get_file(LLVMMetadataRef Variable) {
-  return (ptr_to_option(LLVMDIVariableGetFile(Variable)));
+value llvm_di_variable_get_file(value Variable) {
+  CAMLparam1(Variable);
+  CAMLreturn(ptr_to_option(LLVMDIVariableGetFile(Metadata_val(Variable))));
 }
 
-value llvm_get_metadata_kind(LLVMMetadataRef Metadata) {
-  return Val_int(LLVMGetMetadataKind(Metadata));
+value llvm_get_metadata_kind(value Metadata) {
+  CAMLparam1(Metadata);
+  CAMLreturn(Val_int(LLVMGetMetadataKind(Metadata_val(Metadata))));
 }
 
-LLVMMetadataRef llvm_dibuild_create_auto_variable_native(
-    value Builder, LLVMMetadataRef Scope, value Name, LLVMMetadataRef File,
-    value Line, LLVMMetadataRef Ty, value AlwaysPreserve, value Flags,
-    value AlignInBits) {
-  return LLVMDIBuilderCreateAutoVariable(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      File, Int_val(Line), Ty, Bool_val(AlwaysPreserve), DIFlags_val(Flags),
-      Int_val(AlignInBits));
+value llvm_dibuild_create_auto_variable_native(value Builder, value Scope,
+                                               value Name, value File,
+                                               value Line, value Ty,
+                                               value AlwaysPreserve,
+                                               value Flags, value AlignInBits) {
+  CAMLparam5(Builder, Scope, Name, File, Line);
+  CAMLxparam4(Ty, AlwaysPreserve, Flags, AlignInBits);
+  CAMLreturn(to_val(LLVMDIBuilderCreateAutoVariable(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), Metadata_val(File), Int_val(Line),
+      Metadata_val(Ty), Bool_val(AlwaysPreserve), DIFlags_val(Flags),
+      Int_val(AlignInBits))));
 }
 
-LLVMMetadataRef llvm_dibuild_create_auto_variable_bytecode(value *argv,
-                                                           int arg) {
+value llvm_dibuild_create_auto_variable_bytecode(value *argv, int arg) {
 
-  return llvm_dibuild_create_auto_variable_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Scope
-      argv[2],                  // Name
-      (LLVMMetadataRef)argv[3], // File
-      argv[4],                  // Line
-      (LLVMMetadataRef)argv[5], // Ty
-      argv[6],                  // AlwaysPreserve
-      argv[7],                  // Flags
-      argv[8]                   // AlignInBits
+  return llvm_dibuild_create_auto_variable_native(argv[0], // Builder
+                                                  argv[1], // Scope
+                                                  argv[2], // Name
+                                                  argv[3], // File
+                                                  argv[4], // Line
+                                                  argv[5], // Ty
+                                                  argv[6], // AlwaysPreserve
+                                                  argv[7], // Flags
+                                                  argv[8]  // AlignInBits
   );
 }
 
-LLVMMetadataRef llvm_dibuild_create_parameter_variable_native(
-    value Builder, LLVMMetadataRef Scope, value Name, unsigned ArgNo,
-    LLVMMetadataRef File, value Line, LLVMMetadataRef Ty, value AlwaysPreserve,
-    value Flags) {
-  return LLVMDIBuilderCreateParameterVariable(
-      DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),
-      ArgNo, File, Int_val(Line), Ty, Bool_val(AlwaysPreserve),
+value llvm_dibuild_create_parameter_variable_native(
+    value Builder, value Scope, value Name, value ArgNo, value File, value Line,
+    value Ty, value AlwaysPreserve, value Flags) {
+  CAMLparam5(Builder, Scope, Name, ArgNo, File);
+  CAMLxparam4(Line, Ty, AlwaysPreserve, Flags);
+  LLVMMetadataRef Metadata = LLVMDIBuilderCreateParameterVariable(
+      DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
+      caml_string_length(Name), (unsigned)Int_val(ArgNo), Metadata_val(File),
+      Int_val(Line), Metadata_val(Ty), Bool_val(AlwaysPreserve),
       DIFlags_val(Flags));
+  CAMLreturn(to_val(Metadata));
 }
 
-LLVMMetadataRef llvm_dibuild_create_parameter_variable_bytecode(value *argv,
-                                                                int arg) {
-
+value llvm_dibuild_create_parameter_variable_bytecode(value *argv, int arg) {
   return llvm_dibuild_create_parameter_variable_native(
-      argv[0],                  // Builder
-      (LLVMMetadataRef)argv[1], // Scope
-      argv[2],                  // Name
-      argv[3],                  // ArgNo
-      (LLVMMetadataRef)argv[4], // File
-      argv[5],                  // Line
-      (LLVMMetadataRef)argv[6], // Ty
-      argv[7],                  // AlwaysPreserve
-      argv[8]                   // Flags
+      argv[0], // Builder
+      argv[1], // Scope
+      argv[2], // Name
+      argv[3], // ArgNo
+      argv[4], // File
+      argv[5], // Line
+      argv[6], // Ty
+      argv[7], // AlwaysPreserve
+      argv[8]  // Flags
   );
 }
 
-LLVMValueRef llvm_dibuild_insert_declare_before_native(
-    value Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo,
-    LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr) {
-  return LLVMDIBuilderInsertDeclareBefore(DIBuilder_val(Builder), Storage,
-                                          VarInfo, Expr, DebugLoc, Instr);
-}
-
-LLVMValueRef llvm_dibuild_insert_declare_before_bytecode(value *argv, int arg) {
-
-  return llvm_dibuild_insert_declare_before_native(
-      argv[0],                  // Builder
-      (LLVMValueRef)argv[1],    // Storage
-      (LLVMMetadataRef)argv[2], // VarInfo
-      (LLVMMetadataRef)argv[3], // Expr
-      (LLVMMetadataRef)argv[4], // DebugLoc
-      (LLVMValueRef)argv[5]     // Instr
+value llvm_dibuild_insert_declare_before_native(value Builder, value Storage,
+                                                value VarInfo, value Expr,
+                                                value DebugLoc, value Instr) {
+  CAMLparam5(Builder, Storage, VarInfo, Expr, DebugLoc);
+  CAMLxparam1(Instr);
+  LLVMValueRef Value = LLVMDIBuilderInsertDeclareBefore(
+      DIBuilder_val(Builder), Value_val(Storage), Metadata_val(VarInfo),
+      Metadata_val(Expr), Metadata_val(DebugLoc), Value_val(Instr));
+  CAMLreturn(to_val(Value));
+}
+
+value llvm_dibuild_insert_declare_before_bytecode(value *argv, int arg) {
+
+  return llvm_dibuild_insert_declare_before_native(argv[0], // Builder
+                                                   argv[1], // Storage
+                                                   argv[2], // VarInfo
+                                                   argv[3], // Expr
+                                                   argv[4], // DebugLoc
+                                                   argv[5]  // Instr
   );
 }
 
-LLVMValueRef llvm_dibuild_insert_declare_at_end_native(
-    value Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo,
-    LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block) {
-  return LLVMDIBuilderInsertDeclareAtEnd(DIBuilder_val(Builder), Storage,
-                                         VarInfo, Expr, DebugLoc, Block);
-}
-
-LLVMValueRef llvm_dibuild_insert_declare_at_end_bytecode(value *argv, int arg) {
-
-  return llvm_dibuild_insert_declare_at_end_native(
-      argv[0],                   // Builder
-      (LLVMValueRef)argv[1],     // Storage
-      (LLVMMetadataRef)argv[2],  // VarInfo
-      (LLVMMetadataRef)argv[3],  // Expr
-      (LLVMMetadataRef)argv[4],  // DebugLoc
-      (LLVMBasicBlockRef)argv[5] // Block
+value llvm_dibuild_insert_declare_at_end_native(value Builder, value Storage,
+                                                value VarInfo, value Expr,
+                                                value DebugLoc, value Block) {
+  CAMLparam5(Builder, Storage, VarInfo, Expr, DebugLoc);
+  CAMLxparam1(Block);
+  LLVMValueRef Value = LLVMDIBuilderInsertDeclareAtEnd(
+      DIBuilder_val(Builder), Value_val(Storage), Metadata_val(VarInfo),
+      Metadata_val(Expr), Metadata_val(DebugLoc), BasicBlock_val(Block));
+  CAMLreturn(to_val(Value));
+}
+
+value llvm_dibuild_insert_declare_at_end_bytecode(value *argv, int arg) {
+  return llvm_dibuild_insert_declare_at_end_native(argv[0], // Builder
+                                                   argv[1], // Storage
+                                                   argv[2], // VarInfo
+                                                   argv[3], // Expr
+                                                   argv[4], // DebugLoc
+                                                   argv[5]  // Block
   );
 }
 
-LLVMMetadataRef llvm_dibuild_expression(value Builder, value Addr) {
-  return LLVMDIBuilderCreateExpression(
-      DIBuilder_val(Builder), (uint64_t *)Op_val(Addr), Wosize_val(Addr));
+value llvm_dibuild_expression(value Builder, value Addr) {
+  CAMLparam2(Builder, Addr);
+  CAMLreturn(to_val(LLVMDIBuilderCreateExpression(
+      DIBuilder_val(Builder), (uint64_t *)Op_val(Addr), Wosize_val(Addr))));
 }

llvm/bindings/ocaml/executionengine/CMakeLists.txt

 add_ocaml_library(llvm_executionengine
   OCAML    llvm_executionengine
   OCAMLDEP llvm llvm_target
   C        executionengine_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../llvm"
   LLVM     ExecutionEngine MCJIT native
   PKG      ctypes)

llvm/bindings/ocaml/executionengine/executionengine_ocaml.c

 /*===-- executionengine_ocaml.c - LLVM OCaml Glue ---------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include <string.h>
-#include <assert.h>
-#include "llvm-c/Core.h"
-#include "llvm-c/ExecutionEngine.h"
-#include "llvm-c/Target.h"
 #include "caml/alloc.h"
+#include "caml/callback.h"
 #include "caml/custom.h"
 #include "caml/fail.h"
 #include "caml/memory.h"
-#include "caml/callback.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/Core.h"
+#include "llvm-c/ExecutionEngine.h"
+#include "llvm-c/Target.h"
+#include <assert.h>
+#include <string.h>
+
+#define ExecutionEngine_val(v) ((LLVMExecutionEngineRef)from_val(v))
 
 void llvm_raise(value Prototype, char *Message);
 
 /* unit -> bool */
 value llvm_ee_initialize(value Unit) {
   LLVMLinkInMCJIT();
 
   return Val_bool(!LLVMInitializeNativeTarget() &&
                   !LLVMInitializeNativeAsmParser() &&
                   !LLVMInitializeNativeAsmPrinter());
 }
 
-/* llmodule -> llcompileroption -> ExecutionEngine.t */
-LLVMExecutionEngineRef llvm_ee_create(value OptRecordOpt, LLVMModuleRef M) {
-  value OptRecord;
+/* llcompileroption -> llmodule -> ExecutionEngine.t */
+value llvm_ee_create(value OptRecordOpt, value M) {
+  CAMLparam2(OptRecordOpt, M);
+  CAMLlocal1(OptRecord);
   LLVMExecutionEngineRef MCJIT;
   char *Error;
   struct LLVMMCJITCompilerOptions Options;
 
   LLVMInitializeMCJITCompilerOptions(&Options, sizeof(Options));
   if (OptRecordOpt != Val_int(0)) {
     OptRecord = Field(OptRecordOpt, 0);
     Options.OptLevel = Int_val(Field(OptRecord, 0));
     Options.CodeModel = Int_val(Field(OptRecord, 1));
     Options.NoFramePointerElim = Int_val(Field(OptRecord, 2));
     Options.EnableFastISel = Int_val(Field(OptRecord, 3));
     Options.MCJMM = NULL;
   }
 
-  if (LLVMCreateMCJITCompilerForModule(&MCJIT, M, &Options, sizeof(Options),
-                                       &Error))
+  if (LLVMCreateMCJITCompilerForModule(&MCJIT, Module_val(M), &Options,
+                                       sizeof(Options), &Error))
     llvm_raise(*caml_named_value("Llvm_executionengine.Error"), Error);
-  return MCJIT;
+  CAMLreturn(to_val(MCJIT));
 }
 
 /* ExecutionEngine.t -> unit */
-value llvm_ee_dispose(LLVMExecutionEngineRef EE) {
-  LLVMDisposeExecutionEngine(EE);
-  return Val_unit;
+value llvm_ee_dispose(value EE) {
+  CAMLparam1(EE);
+  LLVMDisposeExecutionEngine(ExecutionEngine_val(EE));
+  CAMLreturn(Val_unit);
 }
 
 /* llmodule -> ExecutionEngine.t -> unit */
-value llvm_ee_add_module(LLVMModuleRef M, LLVMExecutionEngineRef EE) {
-  LLVMAddModule(EE, M);
-  return Val_unit;
+value llvm_ee_add_module(value M, value EE) {
+  CAMLparam2(M, EE);
+  LLVMAddModule(ExecutionEngine_val(EE), Module_val(M));
+  CAMLreturn(Val_unit);
 }
 
 /* llmodule -> ExecutionEngine.t -> llmodule */
-value llvm_ee_remove_module(LLVMModuleRef M, LLVMExecutionEngineRef EE) {
+value llvm_ee_remove_module(value M, value EE) {
+  CAMLparam2(M, EE);
   LLVMModuleRef RemovedModule;
   char *Error;
-  if (LLVMRemoveModule(EE, M, &RemovedModule, &Error))
+  if (LLVMRemoveModule(ExecutionEngine_val(EE), Module_val(M), &RemovedModule,
+                       &Error))
     llvm_raise(*caml_named_value("Llvm_executionengine.Error"), Error);
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* ExecutionEngine.t -> unit */
-value llvm_ee_run_static_ctors(LLVMExecutionEngineRef EE) {
-  LLVMRunStaticConstructors(EE);
-  return Val_unit;
+value llvm_ee_run_static_ctors(value EE) {
+  CAMLparam1(EE);
+  LLVMRunStaticConstructors(ExecutionEngine_val(EE));
+  CAMLreturn(Val_unit);
 }
 
 /* ExecutionEngine.t -> unit */
-value llvm_ee_run_static_dtors(LLVMExecutionEngineRef EE) {
-  LLVMRunStaticDestructors(EE);
-  return Val_unit;
+value llvm_ee_run_static_dtors(value EE) {
+  CAMLparam1(EE);
+  LLVMRunStaticDestructors(ExecutionEngine_val(EE));
+  CAMLreturn(Val_unit);
 }
 
 extern value llvm_alloc_data_layout(LLVMTargetDataRef TargetData);
 
 /* ExecutionEngine.t -> Llvm_target.DataLayout.t */
-value llvm_ee_get_data_layout(LLVMExecutionEngineRef EE) {
-  value DataLayout;
+value llvm_ee_get_data_layout(value EE) {
+  CAMLparam1(EE);
+  CAMLlocal1(DataLayout);
   LLVMTargetDataRef OrigDataLayout;
   char *TargetDataCStr;
 
-  OrigDataLayout = LLVMGetExecutionEngineTargetData(EE);
+  OrigDataLayout = LLVMGetExecutionEngineTargetData(ExecutionEngine_val(EE));
   TargetDataCStr = LLVMCopyStringRepOfTargetData(OrigDataLayout);
   DataLayout = llvm_alloc_data_layout(LLVMCreateTargetData(TargetDataCStr));
   LLVMDisposeMessage(TargetDataCStr);
 
-  return DataLayout;
+  CAMLreturn(DataLayout);
 }
 
 /* Llvm.llvalue -> int64 -> llexecutionengine -> unit */
-value llvm_ee_add_global_mapping(LLVMValueRef Global, value Ptr,
-                                 LLVMExecutionEngineRef EE) {
-  LLVMAddGlobalMapping(EE, Global, (void *)(Int64_val(Ptr)));
-  return Val_unit;
-}
-
-value llvm_ee_get_global_value_address(value Name, LLVMExecutionEngineRef EE) {
-  return caml_copy_int64(
-      (int64_t)LLVMGetGlobalValueAddress(EE, String_val(Name)));
-}
-
-value llvm_ee_get_function_address(value Name, LLVMExecutionEngineRef EE) {
-  return caml_copy_int64((int64_t)LLVMGetFunctionAddress(EE, String_val(Name)));
+value llvm_ee_add_global_mapping(value Global, value Ptr, value EE) {
+  CAMLparam3(Global, Ptr, EE);
+  LLVMAddGlobalMapping(ExecutionEngine_val(EE), Value_val(Global),
+                       (void *)(Int64_val(Ptr)));
+  CAMLreturn(Val_unit);
+}
+
+value llvm_ee_get_global_value_address(value Name, value EE) {
+  CAMLparam2(Name, EE);
+  CAMLreturn(caml_copy_int64((int64_t)LLVMGetGlobalValueAddress(
+      ExecutionEngine_val(EE), String_val(Name))));
+}
+
+value llvm_ee_get_function_address(value Name, value EE) {
+  CAMLparam2(Name, EE);
+  CAMLreturn(caml_copy_int64((int64_t)LLVMGetFunctionAddress(
+      ExecutionEngine_val(EE), String_val(Name))));
 }

llvm/bindings/ocaml/irreader/CMakeLists.txt

 add_ocaml_library(llvm_irreader
   OCAML    llvm_irreader
   OCAMLDEP llvm
   C        irreader_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../llvm"
   LLVM     IRReader)

llvm/bindings/ocaml/irreader/irreader_ocaml.c

 /*===-- irreader_ocaml.c - LLVM OCaml Glue ----------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include "llvm-c/IRReader.h"
 #include "caml/alloc.h"
+#include "caml/callback.h"
 #include "caml/fail.h"
 #include "caml/memory.h"
-#include "caml/callback.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/IRReader.h"
 
 void llvm_raise(value Prototype, char *Message);
 
 /* Llvm.llcontext -> Llvm.llmemorybuffer -> Llvm.llmodule */
-value llvm_parse_ir(LLVMContextRef C, LLVMMemoryBufferRef MemBuf) {
-  CAMLparam0();
+value llvm_parse_ir(value C, value MemBuf) {
+  CAMLparam2(C, MemBuf);
   CAMLlocal2(Variant, MessageVal);
   LLVMModuleRef M;
   char *Message;
 
-  if (LLVMParseIRInContext(C, MemBuf, &M, &Message))
+  if (LLVMParseIRInContext(Context_val(C), MemoryBuffer_val(MemBuf), &M,
+                           &Message))
     llvm_raise(*caml_named_value("Llvm_irreader.Error"), Message);
 
-  CAMLreturn((value)M);
+  CAMLreturn(to_val(M));
 }

llvm/bindings/ocaml/linker/CMakeLists.txt

 add_ocaml_library(llvm_linker
   OCAML    llvm_linker
   OCAMLDEP llvm
   C        linker_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../llvm"
   LLVM     Linker)

llvm/bindings/ocaml/linker/linker_ocaml.c

 /*===-- linker_ocaml.c - LLVM OCaml Glue ------------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include "llvm-c/Core.h"
-#include "llvm-c/Linker.h"
 #include "caml/alloc.h"
-#include "caml/memory.h"
-#include "caml/fail.h"
 #include "caml/callback.h"
+#include "caml/fail.h"
+#include "caml/memory.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/Core.h"
+#include "llvm-c/Linker.h"
 
 void llvm_raise(value Prototype, char *Message);
 
 /* llmodule -> llmodule -> unit */
-value llvm_link_modules(LLVMModuleRef Dst, LLVMModuleRef Src) {
-  if (LLVMLinkModules2(Dst, Src))
+value llvm_link_modules(value Dst, value Src) {
+  CAMLparam2(Dst, Src);
+  if (LLVMLinkModules2(Module_val(Dst), Module_val(Src)))
     llvm_raise(*caml_named_value("Llvm_linker.Error"),
                LLVMCreateMessage("Linking failed"));
 
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }

llvm/bindings/ocaml/llvm/llvm.ml

external data_layout: llmodule -> string
                     = "llvm_data_layout"
 external set_data_layout: string -> llmodule -> unit
                         = "llvm_set_data_layout"
 external dump_module : llmodule -> unit = "llvm_dump_module"
 external print_module : string -> llmodule -> unit = "llvm_print_module"
 external string_of_llmodule : llmodule -> string = "llvm_string_of_llmodule"
 external set_module_inline_asm : llmodule -> string -> unit
                                = "llvm_set_module_inline_asm"
-external module_context : llmodule -> llcontext = "LLVMGetModuleContext"
+external module_context : llmodule -> llcontext = "llvm_get_module_context"
 
 external get_module_identifier : llmodule -> string
                                = "llvm_get_module_identifier"
 
 external set_module_identifer : llmodule -> string -> unit
                               = "llvm_set_module_identifier"
 
 external get_module_flag : llmodule -> string -> llmetadata option

 external fp128_type : llcontext -> lltype = "llvm_fp128_type"
 external ppc_fp128_type : llcontext -> lltype = "llvm_ppc_fp128_type"
 
 (*--... Operations on function types .......................................--*)
 external function_type : lltype -> lltype array -> lltype = "llvm_function_type"
 external var_arg_function_type : lltype -> lltype array -> lltype
                                = "llvm_var_arg_function_type"
 external is_var_arg : lltype -> bool = "llvm_is_var_arg"
-external return_type : lltype -> lltype = "LLVMGetReturnType"
+external return_type : lltype -> lltype = "llvm_return_type"
 external param_types : lltype -> lltype array = "llvm_param_types"
 
 (*--... Operations on struct types .........................................--*)
 external struct_type : llcontext -> lltype array -> lltype = "llvm_struct_type"
 external packed_struct_type : llcontext -> lltype array -> lltype
                             = "llvm_packed_struct_type"
 external struct_name : lltype -> string option = "llvm_struct_name"
 external named_struct_type : llcontext -> string -> lltype =

 
 external subtypes : lltype -> lltype array = "llvm_subtypes"
 external array_type : lltype -> int -> lltype = "llvm_array_type"
 external pointer_type : llcontext -> lltype = "llvm_pointer_type"
 external qualified_pointer_type : llcontext -> int -> lltype
                                 = "llvm_qualified_pointer_type"
 external vector_type : lltype -> int -> lltype = "llvm_vector_type"
 
-external element_type : lltype -> lltype = "LLVMGetElementType"
+external element_type : lltype -> lltype = "llvm_get_element_type"
 external array_length : lltype -> int = "llvm_array_length"
 external address_space : lltype -> int = "llvm_address_space"
 external vector_size : lltype -> int = "llvm_vector_size"
 
 (*--... Operations on other types ..........................................--*)
 external void_type : llcontext -> lltype = "llvm_void_type"
 external label_type : llcontext -> lltype = "llvm_label_type"
 external x86_mmx_type : llcontext -> lltype = "llvm_x86_mmx_type"

 external operand : llvalue -> int -> llvalue = "llvm_operand"
 external operand_use : llvalue -> int -> lluse = "llvm_operand_use"
 external set_operand : llvalue -> int -> llvalue -> unit = "llvm_set_operand"
 external num_operands : llvalue -> int = "llvm_num_operands"
 external indices : llvalue -> int array = "llvm_indices"
 
 (*--... Operations on constants of (mostly) any type .......................--*)
 external is_constant : llvalue -> bool = "llvm_is_constant"
-external const_null : lltype -> llvalue = "LLVMConstNull"
-external const_all_ones : (*int|vec*)lltype -> llvalue = "LLVMConstAllOnes"
-external const_pointer_null : lltype -> llvalue = "LLVMConstPointerNull"
-external undef : lltype -> llvalue = "LLVMGetUndef"
-external poison : lltype -> llvalue = "LLVMGetPoison"
+external const_null : lltype -> llvalue = "llvm_const_null"
+external const_all_ones : (*int|vec*)lltype -> llvalue = "llvm_const_all_ones"
+external const_pointer_null : lltype -> llvalue = "llvm_const_pointer_null"
+external undef : lltype -> llvalue = "llvm_get_undef"
+external poison : lltype -> llvalue = "llvm_get_poison"
 external is_null : llvalue -> bool = "llvm_is_null"
 external is_undef : llvalue -> bool = "llvm_is_undef"
 external is_poison : llvalue -> bool = "llvm_is_poison"
 external constexpr_opcode : llvalue -> Opcode.t = "llvm_constexpr_get_opcode"
 
 (*--... Operations on instructions .........................................--*)
 external has_metadata : llvalue -> bool = "llvm_has_metadata"
 external metadata : llvalue -> llmdkind -> llvalue option = "llvm_metadata"

 external const_packed_struct : llcontext -> llvalue array -> llvalue
                              = "llvm_const_packed_struct"
 external const_vector : llvalue array -> llvalue = "llvm_const_vector"
 external string_of_const : llvalue -> string option = "llvm_string_of_const"
 external aggregate_element : llvalue -> int -> llvalue option
                            = "llvm_aggregate_element"
 
 (*--... Constant expressions ...............................................--*)
-external align_of : lltype -> llvalue = "LLVMAlignOf"
-external size_of : lltype -> llvalue = "LLVMSizeOf"
-external const_neg : llvalue -> llvalue = "LLVMConstNeg"
-external const_nsw_neg : llvalue -> llvalue = "LLVMConstNSWNeg"
-external const_nuw_neg : llvalue -> llvalue = "LLVMConstNUWNeg"
-external const_not : llvalue -> llvalue = "LLVMConstNot"
-external const_add : llvalue -> llvalue -> llvalue = "LLVMConstAdd"
-external const_nsw_add : llvalue -> llvalue -> llvalue = "LLVMConstNSWAdd"
-external const_nuw_add : llvalue -> llvalue -> llvalue = "LLVMConstNUWAdd"
-external const_sub : llvalue -> llvalue -> llvalue = "LLVMConstSub"
-external const_nsw_sub : llvalue -> llvalue -> llvalue = "LLVMConstNSWSub"
-external const_nuw_sub : llvalue -> llvalue -> llvalue = "LLVMConstNUWSub"
-external const_mul : llvalue -> llvalue -> llvalue = "LLVMConstMul"
-external const_nsw_mul : llvalue -> llvalue -> llvalue = "LLVMConstNSWMul"
-external const_nuw_mul : llvalue -> llvalue -> llvalue = "LLVMConstNUWMul"
-external const_and : llvalue -> llvalue -> llvalue = "LLVMConstAnd"
-external const_or : llvalue -> llvalue -> llvalue = "LLVMConstOr"
-external const_xor : llvalue -> llvalue -> llvalue = "LLVMConstXor"
+external align_of : lltype -> llvalue = "llvm_align_of"
+external size_of : lltype -> llvalue = "llvm_size_of"
+external const_neg : llvalue -> llvalue = "llvm_const_neg"
+external const_nsw_neg : llvalue -> llvalue = "llvm_const_nsw_neg"
+external const_nuw_neg : llvalue -> llvalue = "llvm_const_nuw_neg"
+external const_not : llvalue -> llvalue = "llvm_const_not"
+external const_add : llvalue -> llvalue -> llvalue = "llvm_const_add"
+external const_nsw_add : llvalue -> llvalue -> llvalue = "llvm_const_nsw_add"
+external const_nuw_add : llvalue -> llvalue -> llvalue = "llvm_const_nuw_add"
+external const_sub : llvalue -> llvalue -> llvalue = "llvm_const_sub"
+external const_nsw_sub : llvalue -> llvalue -> llvalue = "llvm_const_nsw_sub"
+external const_nuw_sub : llvalue -> llvalue -> llvalue = "llvm_const_nuw_sub"
+external const_mul : llvalue -> llvalue -> llvalue = "llvm_const_mul"
+external const_nsw_mul : llvalue -> llvalue -> llvalue = "llvm_const_nsw_mul"
+external const_nuw_mul : llvalue -> llvalue -> llvalue = "llvm_const_nuw_mul"
+external const_and : llvalue -> llvalue -> llvalue = "llvm_const_and"
+external const_or : llvalue -> llvalue -> llvalue = "llvm_const_or"
+external const_xor : llvalue -> llvalue -> llvalue = "llvm_const_xor"
 external const_icmp : Icmp.t -> llvalue -> llvalue -> llvalue
                     = "llvm_const_icmp"
 external const_fcmp : Fcmp.t -> llvalue -> llvalue -> llvalue
                     = "llvm_const_fcmp"
-external const_shl : llvalue -> llvalue -> llvalue = "LLVMConstShl"
-external const_lshr : llvalue -> llvalue -> llvalue = "LLVMConstLShr"
-external const_ashr : llvalue -> llvalue -> llvalue = "LLVMConstAShr"
+external const_shl : llvalue -> llvalue -> llvalue = "llvm_const_shl"
+external const_lshr : llvalue -> llvalue -> llvalue = "llvm_const_lshr"
+external const_ashr : llvalue -> llvalue -> llvalue = "llvm_const_ashr"
 external const_gep : lltype -> llvalue -> llvalue array -> llvalue
-                    = "llvm_const_gep"
 external const_in_bounds_gep : lltype -> llvalue -> llvalue array -> llvalue
                              = "llvm_const_in_bounds_gep"
-external const_trunc : llvalue -> lltype -> llvalue = "LLVMConstTrunc"
-external const_sext : llvalue -> lltype -> llvalue = "LLVMConstSExt"
-external const_zext : llvalue -> lltype -> llvalue = "LLVMConstZExt"
-external const_fptrunc : llvalue -> lltype -> llvalue = "LLVMConstFPTrunc"
-external const_fpext : llvalue -> lltype -> llvalue = "LLVMConstFPExt"
-external const_uitofp : llvalue -> lltype -> llvalue = "LLVMConstUIToFP"
-external const_sitofp : llvalue -> lltype -> llvalue = "LLVMConstSIToFP"
-external const_fptoui : llvalue -> lltype -> llvalue = "LLVMConstFPToUI"
-external const_fptosi : llvalue -> lltype -> llvalue = "LLVMConstFPToSI"
-external const_ptrtoint : llvalue -> lltype -> llvalue = "LLVMConstPtrToInt"
-external const_inttoptr : llvalue -> lltype -> llvalue = "LLVMConstIntToPtr"
-external const_bitcast : llvalue -> lltype -> llvalue = "LLVMConstBitCast"
+external const_trunc : llvalue -> lltype -> llvalue = "llvm_const_trunc"
+external const_sext : llvalue -> lltype -> llvalue = "llvm_const_sext"
+external const_zext : llvalue -> lltype -> llvalue = "llvm_const_zext"
+external const_fptrunc : llvalue -> lltype -> llvalue = "llvm_const_fptrunc"
+external const_fpext : llvalue -> lltype -> llvalue = "llvm_const_fpext"
+external const_uitofp : llvalue -> lltype -> llvalue = "llvm_const_uitofp"
+external const_sitofp : llvalue -> lltype -> llvalue = "llvm_const_sitofp"
+external const_fptoui : llvalue -> lltype -> llvalue = "llvm_const_fptoui"
+external const_fptosi : llvalue -> lltype -> llvalue = "llvm_const_fptosi"
+external const_ptrtoint : llvalue -> lltype -> llvalue = "llvm_const_ptrtoint"
+external const_inttoptr : llvalue -> lltype -> llvalue = "llvm_const_inttoptr"
+external const_bitcast : llvalue -> lltype -> llvalue = "llvm_const_bitcast"
 external const_zext_or_bitcast : llvalue -> lltype -> llvalue
-                             = "LLVMConstZExtOrBitCast"
+                               = "llvm_const_zext_or_bitcast"
 external const_sext_or_bitcast : llvalue -> lltype -> llvalue
-                             = "LLVMConstSExtOrBitCast"
+                               = "llvm_const_sext_or_bitcast"
 external const_trunc_or_bitcast : llvalue -> lltype -> llvalue
-                              = "LLVMConstTruncOrBitCast"
+                                = "llvm_const_trunc_or_bitcast"
 external const_pointercast : llvalue -> lltype -> llvalue
-                           = "LLVMConstPointerCast"
+                           = "llvm_const_pointercast"
 external const_intcast : llvalue -> lltype -> is_signed:bool -> llvalue
                        = "llvm_const_intcast"
-external const_fpcast : llvalue -> lltype -> llvalue = "LLVMConstFPCast"
+external const_fpcast : llvalue -> lltype -> llvalue = "llvm_const_fpcast"
 external const_select : llvalue -> llvalue -> llvalue -> llvalue
-                      = "LLVMConstSelect"
+                      = "llvm_const_select"
 external const_extractelement : llvalue -> llvalue -> llvalue
-                              = "LLVMConstExtractElement"
+                              = "llvm_const_extractelement"
 external const_insertelement : llvalue -> llvalue -> llvalue -> llvalue
-                             = "LLVMConstInsertElement"
+                             = "llvm_const_insertelement"
 external const_shufflevector : llvalue -> llvalue -> llvalue -> llvalue
-                             = "LLVMConstShuffleVector"
+                             = "llvm_const_shufflevector"
 external const_inline_asm : lltype -> string -> string -> bool -> bool ->
                             llvalue
                           = "llvm_const_inline_asm"
-external block_address : llvalue -> llbasicblock -> llvalue = "LLVMBlockAddress"
+external block_address : llvalue -> llbasicblock -> llvalue
+                       = "llvm_blockaddress"
 
 (*--... Operations on global variables, functions, and aliases (globals) ...--*)
-external global_parent : llvalue -> llmodule = "LLVMGetGlobalParent"
+external global_parent : llvalue -> llmodule = "llvm_global_parent"
 external is_declaration : llvalue -> bool = "llvm_is_declaration"
 external linkage : llvalue -> Linkage.t = "llvm_linkage"
 external set_linkage : Linkage.t -> llvalue -> unit = "llvm_set_linkage"
 external unnamed_addr : llvalue -> bool = "llvm_unnamed_addr"
 external set_unnamed_addr : bool -> llvalue -> unit = "llvm_set_unnamed_addr"
 external section : llvalue -> string = "llvm_section"
 external set_section : string -> llvalue -> unit = "llvm_set_section"
 external visibility : llvalue -> Visibility.t = "llvm_visibility"

 let remove_enum_function_attr f k i =
   llvm_remove_enum_function_attr f k (AttrIndex.to_int i)
 let remove_string_function_attr f k i =
   llvm_remove_string_function_attr f k (AttrIndex.to_int i)
 
 (*--... Operations on params ...............................................--*)
 external params : llvalue -> llvalue array = "llvm_params"
 external param : llvalue -> int -> llvalue = "llvm_param"
-external param_parent : llvalue -> llvalue = "LLVMGetParamParent"
+external param_parent : llvalue -> llvalue = "llvm_param_parent"
 external param_begin : llvalue -> (llvalue, llvalue) llpos = "llvm_param_begin"
 external param_succ : llvalue -> (llvalue, llvalue) llpos = "llvm_param_succ"
 external param_end : llvalue -> (llvalue, llvalue) llrev_pos = "llvm_param_end"
 external param_pred : llvalue -> (llvalue, llvalue) llrev_pos ="llvm_param_pred"
 
 let rec iter_param_range f i e =
   if i = e then () else
   match i with
let rec fold_right_param_range f init i e =
   match i with
   | At_start _ -> raise (Invalid_argument "Invalid parameter range.")
   | After p -> fold_right_param_range f (f p init) (param_pred p) e
 
 let fold_right_params f fn init =
   fold_right_param_range f init (param_end fn) (At_start fn)
 
 (*--... Operations on basic blocks .........................................--*)
-external value_of_block : llbasicblock -> llvalue = "LLVMBasicBlockAsValue"
+external value_of_block : llbasicblock -> llvalue = "llvm_value_of_block"
 external value_is_block : llvalue -> bool = "llvm_value_is_block"
-external block_of_value : llvalue -> llbasicblock = "LLVMValueAsBasicBlock"
-external block_parent : llbasicblock -> llvalue = "LLVMGetBasicBlockParent"
+external block_of_value : llvalue -> llbasicblock = "llvm_block_of_value"
+external block_parent : llbasicblock -> llvalue = "llvm_block_parent"
 external basic_blocks : llvalue -> llbasicblock array = "llvm_basic_blocks"
-external entry_block : llvalue -> llbasicblock = "LLVMGetEntryBasicBlock"
+external entry_block : llvalue -> llbasicblock = "llvm_entry_block"
 external delete_block : llbasicblock -> unit = "llvm_delete_block"
 external remove_block : llbasicblock -> unit = "llvm_remove_block"
 external move_block_before : llbasicblock -> llbasicblock -> unit
                            = "llvm_move_block_before"
 external move_block_after : llbasicblock -> llbasicblock -> unit
                           = "llvm_move_block_after"
 external append_block : llcontext -> string -> llvalue -> llbasicblock
                       = "llvm_append_block"
let rec fold_right_block_range f init i e =
   match i with
   | At_start _ -> raise (Invalid_argument "Invalid block range.")
   | After bb -> fold_right_block_range f (f bb init) (block_pred bb) e
 
 let fold_right_blocks f fn init =
   fold_right_block_range f init (block_end fn) (At_start fn)
 
 (*--... Operations on instructions .........................................--*)
-external instr_parent : llvalue -> llbasicblock = "LLVMGetInstructionParent"
+external instr_parent : llvalue -> llbasicblock = "llvm_instr_parent"
 external instr_begin : llbasicblock -> (llbasicblock, llvalue) llpos
                      = "llvm_instr_begin"
 external instr_succ : llvalue -> (llbasicblock, llvalue) llpos
                      = "llvm_instr_succ"
 external instr_end : llbasicblock -> (llbasicblock, llvalue) llrev_pos
                      = "llvm_instr_end"
 external instr_pred : llvalue -> (llbasicblock, llvalue) llrev_pos
                      = "llvm_instr_pred"
let remove_enum_call_site_attr f k i =
   llvm_remove_enum_call_site_attr f k (AttrIndex.to_int i)
 let remove_string_call_site_attr f k i =
   llvm_remove_string_call_site_attr f k (AttrIndex.to_int i)
 
 (*--... Operations on call and invoke instructions (only) ..................--*)
 external num_arg_operands : llvalue -> int = "llvm_num_arg_operands"
 external is_tail_call : llvalue -> bool = "llvm_is_tail_call"
 external set_tail_call : bool -> llvalue -> unit = "llvm_set_tail_call"
-external get_normal_dest : llvalue -> llbasicblock = "LLVMGetNormalDest"
-external get_unwind_dest : llvalue -> llbasicblock = "LLVMGetUnwindDest"
+external get_normal_dest : llvalue -> llbasicblock = "llvm_get_normal_dest"
+external get_unwind_dest : llvalue -> llbasicblock = "llvm_get_unwind_dest"
 
 (*--... Operations on load/store instructions (only) .......................--*)
 external is_volatile : llvalue -> bool = "llvm_is_volatile"
 external set_volatile : bool -> llvalue -> unit = "llvm_set_volatile"
 
 (*--... Operations on terminators ..........................................--*)
 
 let is_terminator llv =

 external build_malloc : lltype -> string -> llbuilder -> llvalue =
     "llvm_build_malloc"
 external build_array_malloc : lltype -> llvalue -> string -> llbuilder ->
     llvalue = "llvm_build_array_malloc"
 external build_free : llvalue -> llbuilder -> llvalue = "llvm_build_free"
 external add_case : llvalue -> llvalue -> llbasicblock -> unit
                   = "llvm_add_case"
 external switch_default_dest : llvalue -> llbasicblock =
-    "LLVMGetSwitchDefaultDest"
+    "llvm_switch_default_dest"
 external build_indirect_br : llvalue -> int -> llbuilder -> llvalue
                            = "llvm_build_indirect_br"
 external add_destination : llvalue -> llbasicblock -> unit
                          = "llvm_add_destination"
 external build_invoke : lltype -> llvalue -> llvalue array -> llbasicblock ->
                         llbasicblock -> string -> llbuilder -> llvalue
                       = "llvm_build_invoke_bc" "llvm_build_invoke_nat"
 external build_landingpad : lltype -> llvalue -> int -> string -> llbuilder ->

 
 (*===-- Pass Manager ------------------------------------------------------===*)
 
 module PassManager = struct
   type 'a t
   type any = [ `Module | `Function ]
   external create : unit -> [ `Module ] t = "llvm_passmanager_create"
   external create_function : llmodule -> [ `Function ] t
-                           = "LLVMCreateFunctionPassManager"
+                           = "llvm_passmanager_create_function"
   external run_module : llmodule -> [ `Module ] t -> bool
                       = "llvm_passmanager_run_module"
   external initialize : [ `Function ] t -> bool = "llvm_passmanager_initialize"
   external run_function : llvalue -> [ `Function ] t -> bool
                         = "llvm_passmanager_run_function"
   external finalize : [ `Function ] t -> bool = "llvm_passmanager_finalize"
   external dispose : [< any ] t -> unit = "llvm_passmanager_dispose"
 end

llvm/bindings/ocaml/llvm/llvm_ocaml.h

+
 /*===-- llvm_ocaml.h - LLVM OCaml Glue --------------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|

 #define Val_none Val_int(0)
 #define Some_val(v) Field(v, 0)
 #define Tag_some 0
 #define Is_none(v) ((v) == Val_none)
 #define Is_some(v) Is_block(v)
 value caml_alloc_some(value);
 #endif
 
+/* to_val and from_val convert between an OCaml value and a pointer from LLVM,
+   which points outside the OCaml heap. They assume that all pointers from LLVM
+   are 2-bit aligned: to_val sets the low bit so that OCaml treats the value
+   as an integer, and from_val clears the low bit. */
+value to_val(void *ptr);
+
+void *from_val(value v);
+
+void *alloc_temp(value Elements);
+
+#define DiagnosticInfo_val(v) ((LLVMDiagnosticInfoRef)from_val(v))
+#define Context_val(v) ((LLVMContextRef)from_val(v))
+#define Attribute_val(v) ((LLVMAttributeRef)from_val(v))
+#define Module_val(v) ((LLVMModuleRef)from_val(v))
+#define Metadata_val(v) ((LLVMMetadataRef)from_val(v))
+#define Type_val(v) ((LLVMTypeRef)from_val(v))
+#define Value_val(v) ((LLVMValueRef)from_val(v))
+#define Use_val(v) ((LLVMUseRef)from_val(v))
+#define BasicBlock_val(v) ((LLVMBasicBlockRef)from_val(v))
+#define MemoryBuffer_val(v) ((LLVMMemoryBufferRef)from_val(v))
+#define PassManager_val(v) ((LLVMPassManagerRef)from_val(v))
+
 /* Convert a C pointer to an OCaml option */
 value ptr_to_option(void *Ptr);
 
 /* Convert a C string into an OCaml string */
 value cstr_to_string(const char *Str, mlsize_t Len);
 
 #endif // LLVM_LLVM_OCAML_H

llvm/bindings/ocaml/llvm/llvm_ocaml.c

 /*===-- llvm_ocaml.c - LLVM OCaml Glue --------------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include "llvm-c/Core.h"
 #include "llvm-c/Support.h"
 #include "llvm/Config/llvm-config.h"
 #include "caml/memory.h"
 #include "caml/fail.h"
 #include "caml/callback.h"
 #include "llvm_ocaml.h"
 
 #if OCAML_VERSION < 41200
 value caml_alloc_some(value v) {
   CAMLparam1(v);
   value Some = caml_alloc_small(1, 0);
   Field(Some, 0) = v;
   CAMLreturn(Some);
 }
 #endif
 
-value caml_alloc_tuple_uninit(mlsize_t wosize) {
-  if (wosize <= Max_young_wosize) {
-    return caml_alloc_small(wosize, 0);
-  } else {
-    return caml_alloc_shr(wosize, 0);
-  }
+value to_val(void *ptr) {
+  assert((((value)ptr) & 1) == 0);
+  return ((value)ptr) | 1;
+
+void *from_val(value v) {
+  assert(Is_long(v));
+  return (void *)(v ^ 1);
 }
 
 value llvm_string_of_message(char *Message) {
   value String = caml_copy_string(Message);
   LLVMDisposeMessage(Message);
 
   return String;
 }
 
 value ptr_to_option(void *Ptr) {
   if (!Ptr)
     return Val_none;
-  return caml_alloc_some((value)Ptr);
+  return caml_alloc_some(to_val(Ptr));
 }
 
 value cstr_to_string(const char *Str, mlsize_t Len) {
   if (!Str)
     return caml_alloc_string(0);
   value String = caml_alloc_string(Len);
   memcpy((char *)String_val(String), Str, Len);
   return String;
 }
 
 value cstr_to_string_option(const char *CStr, mlsize_t Len) {
   if (!CStr)
     return Val_none;
   value String = caml_alloc_string(Len);
   memcpy((char *)String_val(String), CStr, Len);
   return caml_alloc_some(String);
 }
 
 void llvm_raise(value Prototype, char *Message) {
   caml_raise_with_arg(Prototype, llvm_string_of_message(Message));
 }
 
 static value llvm_fatal_error_handler;
 
 static void llvm_fatal_error_trampoline(const char *Reason) {
-  callback(llvm_fatal_error_handler, caml_copy_string(Reason));
+  caml_callback(llvm_fatal_error_handler, caml_copy_string(Reason));
 }
 
 value llvm_install_fatal_error_handler(value Handler) {
   LLVMInstallFatalErrorHandler(llvm_fatal_error_trampoline);
   llvm_fatal_error_handler = Handler;
   caml_register_global_root(&llvm_fatal_error_handler);
   return Val_unit;
 }
 
 value llvm_reset_fatal_error_handler(value Unit) {
   caml_remove_global_root(&llvm_fatal_error_handler);
   LLVMResetFatalErrorHandler();
   return Val_unit;
 }
 
 value llvm_enable_pretty_stacktrace(value Unit) {
   LLVMEnablePrettyStackTrace();
   return Val_unit;
 }
 
 value llvm_parse_command_line_options(value Overview, value Args) {
+  CAMLparam2(Overview, Args);
   const char *COverview;
   if (Overview == Val_int(0)) {
     COverview = NULL;
   } else {
     COverview = String_val(Field(Overview, 0));
   }
   LLVMParseCommandLineOptions(Wosize_val(Args),
                               (const char *const *)Op_val(Args), COverview);
-  return Val_unit;
+  CAMLreturn(Val_unit);
+}
+
+void *alloc_temp(value Elements) {
+  unsigned Length = Wosize_val(Elements);
+  void **Temp = malloc(sizeof(void *) * Length);
+  if (Temp == NULL)
+    caml_raise_out_of_memory();
+  for (unsigned I = 0; I < Length; ++I) {
+    Temp[I] = from_val(Field(Elements, I));
+  }
+  return Temp;
 }
 
-static value alloc_variant(int tag, void *Value) {
+static value alloc_variant(int tag, value Value) {
   value Iter = caml_alloc_small(1, tag);
-  Field(Iter, 0) = Val_op(Value);
+  Field(Iter, 0) = Value;
   return Iter;
 }
 
 /* Macro to convert the C first/next/last/prev idiom to the Ocaml llpos/
    llrev_pos idiom. */
-#define DEFINE_ITERATORS(camlname, cname, pty, cty, pfun) \
-  /* llmodule -> ('a, 'b) llpos */                        \
-  value llvm_##camlname##_begin(pty Mom) {       \
-    cty First = LLVMGetFirst##cname(Mom);                 \
-    if (First)                                            \
-      return alloc_variant(1, First);                     \
-    return alloc_variant(0, Mom);                         \
-  }                                                       \
+#define DEFINE_ITERATORS(camlname, cname, pty_val, cty, cty_val, pfun)         \
+  /* llmodule -> ('a, 'b) llpos */                                             \
+  value llvm_##camlname##_begin(value Mom) {                                   \
+    CAMLparam1(Mom);                                                           \
+    cty First = LLVMGetFirst##cname(pty_val(Mom));                             \
+    if (First) {                                                               \
+      CAMLreturn(alloc_variant(1, to_val(First)));                             \
+    }                                                                          \
+    CAMLreturn(alloc_variant(0, Mom));                                         \
+  }                                                                            \
                                                                                \
-  /* llvalue -> ('a, 'b) llpos */                         \
-  value llvm_##camlname##_succ(cty Kid) {        \
-    cty Next = LLVMGetNext##cname(Kid);                   \
-    if (Next)                                             \
-      return alloc_variant(1, Next);                      \
-    return alloc_variant(0, pfun(Kid));                   \
-  }                                                       \
+  /* llvalue -> ('a, 'b) llpos */                                              \
+  value llvm_##camlname##_succ(value Kid) {                                    \
+    CAMLparam1(Kid);                                                           \
+    cty Next = LLVMGetNext##cname(cty_val(Kid));                               \
+    if (Next) {                                                                \
+      CAMLreturn(alloc_variant(1, to_val(Next)));                              \
+    }                                                                          \
+    CAMLreturn(alloc_variant(0, to_val(pfun(cty_val(Kid)))));                  \
+  }                                                                            \
                                                                                \
-  /* llmodule -> ('a, 'b) llrev_pos */                    \
-  value llvm_##camlname##_end(pty Mom) {         \
-    cty Last = LLVMGetLast##cname(Mom);                   \
-    if (Last)                                             \
-      return alloc_variant(1, Last);                      \
-    return alloc_variant(0, Mom);                         \
-  }                                                       \
+  /* llmodule -> ('a, 'b) llrev_pos */                                         \
+  value llvm_##camlname##_end(value Mom) {                                     \
+    CAMLparam1(Mom);                                                           \
+    cty Last = LLVMGetLast##cname(pty_val(Mom));                               \
+    if (Last) {                                                                \
+      CAMLreturn(alloc_variant(1, to_val(Last)));                              \
+    }                                                                          \
+    CAMLreturn(alloc_variant(0, Mom));                                         \
+  }                                                                            \
                                                                                \
-  /* llvalue -> ('a, 'b) llrev_pos */                     \
-  value llvm_##camlname##_pred(cty Kid) {        \
-    cty Prev = LLVMGetPrevious##cname(Kid);               \
-    if (Prev)                                             \
-      return alloc_variant(1, Prev);                      \
-    return alloc_variant(0, pfun(Kid));                   \
+  /* llvalue -> ('a, 'b) llrev_pos */                                          \
+  value llvm_##camlname##_pred(value Kid) {                                    \
+    CAMLparam1(Kid);                                                           \
+    cty Prev = LLVMGetPrevious##cname(cty_val(Kid));                           \
+    if (Prev) {                                                                \
+      CAMLreturn(alloc_variant(1, to_val(Prev)));                              \
+    }                                                                          \
+    CAMLreturn(alloc_variant(0, to_val(pfun(cty_val(Kid)))));                  \
   }
 
 /*===-- Context error handling --------------------------------------------===*/
 
 void llvm_diagnostic_handler_trampoline(LLVMDiagnosticInfoRef DI,
                                         void *DiagnosticContext) {
-  caml_callback(*((value *)DiagnosticContext), (value)DI);
+  caml_callback(*((value *)DiagnosticContext), to_val(DI));
 }
 
 /* Diagnostic.t -> string */
 value llvm_get_diagnostic_description(value Diagnostic) {
   return llvm_string_of_message(
-      LLVMGetDiagInfoDescription((LLVMDiagnosticInfoRef)Diagnostic));
+      LLVMGetDiagInfoDescription(DiagnosticInfo_val(Diagnostic)));
 }
 
 /* Diagnostic.t -> DiagnosticSeverity.t */
 value llvm_get_diagnostic_severity(value Diagnostic) {
-  return Val_int(LLVMGetDiagInfoSeverity((LLVMDiagnosticInfoRef)Diagnostic));
+  return Val_int(LLVMGetDiagInfoSeverity(DiagnosticInfo_val(Diagnostic)));
 }
 
-static void llvm_remove_diagnostic_handler(LLVMContextRef C) {
-  if (LLVMContextGetDiagnosticHandler(C) ==
+static void llvm_remove_diagnostic_handler(value C) {
+  CAMLparam1(C);
+  LLVMContextRef context = Context_val(C);
+  if (LLVMContextGetDiagnosticHandler(context) ==
       llvm_diagnostic_handler_trampoline) {
-    value *Handler = (value *)LLVMContextGetDiagnosticContext(C);
-    remove_global_root(Handler);
+    value *Handler = (value *)LLVMContextGetDiagnosticContext(context);
+    caml_remove_global_root(Handler);
     free(Handler);
   }
+  CAMLreturn0;
 }
 
 /* llcontext -> (Diagnostic.t -> unit) option -> unit */
-value llvm_set_diagnostic_handler(LLVMContextRef C, value Handler) {
+value llvm_set_diagnostic_handler(value C, value Handler) {
+  CAMLparam2(C, Handler);
+  LLVMContextRef context = Context_val(C);
   llvm_remove_diagnostic_handler(C);
   if (Handler == Val_none) {
-    LLVMContextSetDiagnosticHandler(C, NULL, NULL);
+    LLVMContextSetDiagnosticHandler(context, NULL, NULL);
   } else {
     value *DiagnosticContext = malloc(sizeof(value));
     if (DiagnosticContext == NULL)
       caml_raise_out_of_memory();
     caml_register_global_root(DiagnosticContext);
     *DiagnosticContext = Field(Handler, 0);
-    LLVMContextSetDiagnosticHandler(C, llvm_diagnostic_handler_trampoline,
+    LLVMContextSetDiagnosticHandler(context, llvm_diagnostic_handler_trampoline,
                                     DiagnosticContext);
   }
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /*===-- Contexts ----------------------------------------------------------===*/
 
 /* unit -> llcontext */
-LLVMContextRef llvm_create_context(value Unit) { return LLVMContextCreate(); }
+value llvm_create_context(value Unit) {
+  CAMLparam1(Unit);
+  CAMLreturn(to_val(LLVMContextCreate()));
+}
 
 /* llcontext -> unit */
-value llvm_dispose_context(LLVMContextRef C) {
+value llvm_dispose_context(value C) {
+  CAMLparam1(C);
   llvm_remove_diagnostic_handler(C);
-  LLVMContextDispose(C);
-  return Val_unit;
+  LLVMContextDispose(Context_val(C));
+  CAMLreturn(Val_unit);
 }
 
 /* unit -> llcontext */
-LLVMContextRef llvm_global_context(value Unit) {
-  return LLVMGetGlobalContext();
+value llvm_global_context(value Unit) {
+  CAMLparam1(Unit);
+  CAMLreturn(to_val(LLVMGetGlobalContext()));
 }
 
 /* llcontext -> string -> int */
-value llvm_mdkind_id(LLVMContextRef C, value Name) {
-  unsigned MDKindID =
-      LLVMGetMDKindIDInContext(C, String_val(Name), caml_string_length(Name));
-  return Val_int(MDKindID);
+value llvm_mdkind_id(value C, value Name) {
+  CAMLparam2(C, Name);
+  unsigned MDKindID = LLVMGetMDKindIDInContext(Context_val(C), String_val(Name),
+                                               caml_string_length(Name));
+  CAMLreturn(Val_int(MDKindID));
 }
 
 /*===-- Attributes --------------------------------------------------------===*/
 
 /* string -> llattrkind */
 value llvm_enum_attr_kind(value Name) {
+  CAMLparam1(Name);
   unsigned Kind = LLVMGetEnumAttributeKindForName(String_val(Name),
                                                   caml_string_length(Name));
   if (Kind == 0)
     caml_raise_with_arg(*caml_named_value("Llvm.UnknownAttribute"), Name);
-  return Val_int(Kind);
+  CAMLreturn(Val_int(Kind));
 }
 
 /* llcontext -> int -> int64 -> llattribute */
-LLVMAttributeRef llvm_create_enum_attr_by_kind(LLVMContextRef C, value Kind,
-                                               value Value) {
-  return LLVMCreateEnumAttribute(C, Int_val(Kind), Int64_val(Value));
+value llvm_create_enum_attr_by_kind(value C, value Kind, value Value) {
+  CAMLparam3(C, Kind, Value);
+  CAMLreturn(to_val(LLVMCreateEnumAttribute(Context_val(C), Int_val(Kind),
+                                            Int64_val(Value))));
 }
 
 /* llattribute -> bool */
-value llvm_is_enum_attr(LLVMAttributeRef A) {
-  return Val_int(LLVMIsEnumAttribute(A));
+value llvm_is_enum_attr(value A) {
+  CAMLparam1(A);
+  CAMLreturn(Val_int(LLVMIsEnumAttribute(Attribute_val(A))));
 }
 
 /* llattribute -> llattrkind */
-value llvm_get_enum_attr_kind(LLVMAttributeRef A) {
-  return Val_int(LLVMGetEnumAttributeKind(A));
+value llvm_get_enum_attr_kind(value A) {
+  CAMLparam1(A);
+  CAMLreturn(Val_int(LLVMGetEnumAttributeKind(Attribute_val(A))));
 }
 
 /* llattribute -> int64 */
-value llvm_get_enum_attr_value(LLVMAttributeRef A) {
-  return caml_copy_int64(LLVMGetEnumAttributeValue(A));
+value llvm_get_enum_attr_value(value A) {
+  CAMLparam1(A);
+  CAMLreturn(caml_copy_int64(LLVMGetEnumAttributeValue(Attribute_val(A))));
 }
 
 /* llcontext -> kind:string -> name:string -> llattribute */
-LLVMAttributeRef llvm_create_string_attr(LLVMContextRef C, value Kind,
-                                         value Value) {
-  return LLVMCreateStringAttribute(C, String_val(Kind),
-                                   caml_string_length(Kind), String_val(Value),
-                                   caml_string_length(Value));
+value llvm_create_string_attr(value C, value Kind, value Value) {
+  CAMLparam3(C, Kind, Value);
+  CAMLreturn(to_val(LLVMCreateStringAttribute(
+      Context_val(C), String_val(Kind), caml_string_length(Kind),
+      String_val(Value), caml_string_length(Value))));
 }
 
 /* llattribute -> bool */
-value llvm_is_string_attr(LLVMAttributeRef A) {
-  return Val_int(LLVMIsStringAttribute(A));
+value llvm_is_string_attr(value A) {
+  CAMLparam1(A);
+  CAMLreturn(Val_int(LLVMIsStringAttribute(Attribute_val(A))));
 }
 
 /* llattribute -> string */
-value llvm_get_string_attr_kind(LLVMAttributeRef A) {
+value llvm_get_string_attr_kind(value A) {
+  CAMLparam1(A);
   unsigned Length;
-  const char *String = LLVMGetStringAttributeKind(A, &Length);
-  return cstr_to_string(String, Length);
+  const char *String = LLVMGetStringAttributeKind(Attribute_val(A), &Length);
+  CAMLreturn(cstr_to_string(String, Length));
 }
 
 /* llattribute -> string */
-value llvm_get_string_attr_value(LLVMAttributeRef A) {
+value llvm_get_string_attr_value(value A) {
+  CAMLparam1(A);
   unsigned Length;
-  const char *String = LLVMGetStringAttributeValue(A, &Length);
-  return cstr_to_string(String, Length);
+  const char *String = LLVMGetStringAttributeValue(Attribute_val(A), &Length);
+  CAMLreturn(cstr_to_string(String, Length));
 }
 
 /*===-- Modules -----------------------------------------------------------===*/
 
 /* llcontext -> string -> llmodule */
-LLVMModuleRef llvm_create_module(LLVMContextRef C, value ModuleID) {
-  return LLVMModuleCreateWithNameInContext(String_val(ModuleID), C);
+value llvm_create_module(value C, value ModuleID) {
+  CAMLparam2(C, ModuleID);
+  CAMLreturn(to_val(
+      LLVMModuleCreateWithNameInContext(String_val(ModuleID), Context_val(C))));
 }
 
 /* llmodule -> unit */
-value llvm_dispose_module(LLVMModuleRef M) {
-  LLVMDisposeModule(M);
-  return Val_unit;
+value llvm_dispose_module(value M) {
+  CAMLparam1(M);
+  LLVMDisposeModule(Module_val(M));
+  CAMLreturn(Val_unit);
 }
 
 /* llmodule -> string */
-value llvm_target_triple(LLVMModuleRef M) {
-  return caml_copy_string(LLVMGetTarget(M));
+value llvm_target_triple(value M) {
+  CAMLparam1(M);
+  CAMLreturn(caml_copy_string(LLVMGetTarget(Module_val(M))));
 }
 
 /* string -> llmodule -> unit */
-value llvm_set_target_triple(value Trip, LLVMModuleRef M) {
-  LLVMSetTarget(M, String_val(Trip));
-  return Val_unit;
+value llvm_set_target_triple(value Trip, value M) {
+  CAMLparam2(Trip, M);
+  LLVMSetTarget(Module_val(M), String_val(Trip));
+  CAMLreturn(Val_unit);
 }
 
 /* llmodule -> string */
-value llvm_data_layout(LLVMModuleRef M) {
-  return caml_copy_string(LLVMGetDataLayout(M));
+value llvm_data_layout(value M) {
+  CAMLparam1(M);
+  CAMLreturn(caml_copy_string(LLVMGetDataLayout(Module_val(M))));
 }
 
 /* string -> llmodule -> unit */
-value llvm_set_data_layout(value Layout, LLVMModuleRef M) {
-  LLVMSetDataLayout(M, String_val(Layout));
-  return Val_unit;
+value llvm_set_data_layout(value Layout, value M) {
+  CAMLparam2(Layout, M);
+  LLVMSetDataLayout(Module_val(M), String_val(Layout));
+  CAMLreturn(Val_unit);
 }
 
 /* llmodule -> unit */
-value llvm_dump_module(LLVMModuleRef M) {
-  LLVMDumpModule(M);
-  return Val_unit;
+value llvm_dump_module(value M) {
+  CAMLparam1(M);
+  LLVMDumpModule(Module_val(M));
+  CAMLreturn(Val_unit);
 }
 
 /* string -> llmodule -> unit */
-value llvm_print_module(value Filename, LLVMModuleRef M) {
+value llvm_print_module(value Filename, value M) {
+  CAMLparam2(Filename, M);
   char *Message;
 
-  if (LLVMPrintModuleToFile(M, String_val(Filename), &Message))
+  if (LLVMPrintModuleToFile(Module_val(M), String_val(Filename), &Message))
     llvm_raise(*caml_named_value("Llvm.IoError"), Message);
 
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* llmodule -> string */
-value llvm_string_of_llmodule(LLVMModuleRef M) {
-  char *ModuleCStr = LLVMPrintModuleToString(M);
+value llvm_string_of_llmodule(value M) {
+  CAMLparam1(M);
+  char *ModuleCStr = LLVMPrintModuleToString(Module_val(M));
   value ModuleStr = caml_copy_string(ModuleCStr);
   LLVMDisposeMessage(ModuleCStr);
 
-  return ModuleStr;
+  CAMLreturn(ModuleStr);
 }
 
-/* llmodule -> string */
-value llvm_get_module_identifier(LLVMModuleRef M) {
-  size_t Len;
-  const char *Name = LLVMGetModuleIdentifier(M, &Len);
-  return cstr_to_string(Name, (mlsize_t)Len);
+/* llmodule -> string -> unit */
+value llvm_set_module_inline_asm(value M, value Asm) {
+  CAMLparam2(M, Asm);
+  LLVMSetModuleInlineAsm(Module_val(M), String_val(Asm));
+  CAMLreturn(Val_unit);
 }
 
-/* llmodule -> string -> unit */
-value llvm_set_module_identifier(LLVMModuleRef M, value Id) {
-  LLVMSetModuleIdentifier(M, String_val(Id), caml_string_length(Id));
-  return Val_unit;
+/* llmodule -> llcontext */
+value llvm_get_module_context(value M) {
+  CAMLparam1(M);
+  LLVMContextRef C = LLVMGetModuleContext(Module_val(M));
+  CAMLreturn(to_val(C));
+}
+
+/* llmodule -> string */
+value llvm_get_module_identifier(value M) {
+  CAMLparam1(M);
+  size_t Len;
+  const char *Name = LLVMGetModuleIdentifier(Module_val(M), &Len);
+  CAMLreturn(cstr_to_string(Name, (mlsize_t)Len));
 }
 
 /* llmodule -> string -> unit */
-value llvm_set_module_inline_asm(LLVMModuleRef M, value Asm) {
-  LLVMSetModuleInlineAsm(M, String_val(Asm));
-  return Val_unit;
+value llvm_set_module_identifier(value M, value Id) {
+  CAMLparam2(M, Id);
+  LLVMSetModuleIdentifier(Module_val(M), String_val(Id),
+                          caml_string_length(Id));
+  CAMLreturn(Val_unit);
 }
 
 /* llmodule -> string -> llmetadata option */
-value llvm_get_module_flag(LLVMModuleRef M, value Key) {
-  return ptr_to_option(
-      LLVMGetModuleFlag(M, String_val(Key), caml_string_length(Key)));
+value llvm_get_module_flag(value M, value Key) {
+  CAMLparam2(M, Key);
+  CAMLreturn(ptr_to_option(LLVMGetModuleFlag(Module_val(M), String_val(Key),
+                                             caml_string_length(Key))));
 }
 
-value llvm_add_module_flag(LLVMModuleRef M, LLVMModuleFlagBehavior Behaviour,
-                           value Key, LLVMMetadataRef Val) {
-  LLVMAddModuleFlag(M, Int_val(Behaviour), String_val(Key),
-                    caml_string_length(Key), Val);
-  return Val_unit;
+/* llmodule -> ModuleFlagBehavior.t -> string -> llmetadata -> unit */
+value llvm_add_module_flag(value M, value Behaviour, value Key, value Val) {
+  CAMLparam4(M, Behaviour, Key, Val);
+  LLVMAddModuleFlag(Module_val(M), Int_val(Behaviour), String_val(Key),
+                    caml_string_length(Key), Metadata_val(Val));
+  CAMLreturn(Val_unit);
 }
 
 /*===-- Types -------------------------------------------------------------===*/
 
 /* lltype -> TypeKind.t */
-value llvm_classify_type(LLVMTypeRef Ty) {
-  return Val_int(LLVMGetTypeKind(Ty));
+value llvm_classify_type(value Ty) {
+  CAMLparam1(Ty);
+  CAMLreturn(Val_int(LLVMGetTypeKind(Type_val(Ty))));
 }
 
-value llvm_type_is_sized(LLVMTypeRef Ty) {
-  return Val_bool(LLVMTypeIsSized(Ty));
+/* lltype -> bool */
+value llvm_type_is_sized(value Ty) {
+  CAMLparam1(Ty);
+  CAMLreturn(Val_bool(LLVMTypeIsSized(Type_val(Ty))));
 }
 
 /* lltype -> llcontext */
-LLVMContextRef llvm_type_context(LLVMTypeRef Ty) {
-  return LLVMGetTypeContext(Ty);
+value llvm_type_context(value Ty) {
+  CAMLparam1(Ty);
+  CAMLreturn(to_val(LLVMGetTypeContext(Type_val(Ty))));
 }
 
 /* lltype -> unit */
-value llvm_dump_type(LLVMTypeRef Val) {
+value llvm_dump_type(value Val) {
+  CAMLparam1(Val);
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  LLVMDumpType(Val);
+  LLVMDumpType(Type_val(Val));
 #else
   caml_raise_with_arg(*caml_named_value("Llvm.FeatureDisabled"),
                       caml_copy_string("dump"));
 #endif
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* lltype -> string */
-value llvm_string_of_lltype(LLVMTypeRef M) {
-  char *TypeCStr = LLVMPrintTypeToString(M);
-  value TypeStr = caml_copy_string(TypeCStr);
+value llvm_string_of_lltype(value M) {
+  CAMLparam1(M);
+  CAMLlocal1(TypeStr);
+  char *TypeCStr = LLVMPrintTypeToString(Type_val(M));
+  TypeStr = caml_copy_string(TypeCStr);
   LLVMDisposeMessage(TypeCStr);
 
-  return TypeStr;
+  CAMLreturn(TypeStr);
 }
 
 /*--... Operations on integer types ........................................--*/
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_i1_type(LLVMContextRef Context) {
-  return LLVMInt1TypeInContext(Context);
+value llvm_i1_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMInt1TypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_i8_type(LLVMContextRef Context) {
-  return LLVMInt8TypeInContext(Context);
+value llvm_i8_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMInt8TypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_i16_type(LLVMContextRef Context) {
-  return LLVMInt16TypeInContext(Context);
+value llvm_i16_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMInt16TypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_i32_type(LLVMContextRef Context) {
-  return LLVMInt32TypeInContext(Context);
+value llvm_i32_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMInt32TypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_i64_type(LLVMContextRef Context) {
-  return LLVMInt64TypeInContext(Context);
+value llvm_i64_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMInt64TypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> int -> lltype */
-LLVMTypeRef llvm_integer_type(LLVMContextRef Context, value Width) {
-  return LLVMIntTypeInContext(Context, Int_val(Width));
+value llvm_integer_type(value Context, value Width) {
+  CAMLparam2(Context, Width);
+  CAMLreturn(
+      to_val(LLVMIntTypeInContext(Context_val(Context), Int_val(Width))));
 }
 
 /* lltype -> int */
-value llvm_integer_bitwidth(LLVMTypeRef IntegerTy) {
-  return Val_int(LLVMGetIntTypeWidth(IntegerTy));
+value llvm_integer_bitwidth(value IntegerTy) {
+  CAMLparam1(IntegerTy);
+  CAMLreturn(Val_int(LLVMGetIntTypeWidth(Type_val(IntegerTy))));
 }
 
 /*--... Operations on real types ...........................................--*/
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_float_type(LLVMContextRef Context) {
-  return LLVMFloatTypeInContext(Context);
+value llvm_float_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMFloatTypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_double_type(LLVMContextRef Context) {
-  return LLVMDoubleTypeInContext(Context);
+value llvm_double_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMDoubleTypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_x86fp80_type(LLVMContextRef Context) {
-  return LLVMX86FP80TypeInContext(Context);
+value llvm_x86fp80_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMX86FP80TypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_fp128_type(LLVMContextRef Context) {
-  return LLVMFP128TypeInContext(Context);
+value llvm_fp128_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMFP128TypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_ppc_fp128_type(LLVMContextRef Context) {
-  return LLVMPPCFP128TypeInContext(Context);
+value llvm_ppc_fp128_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMPPCFP128TypeInContext(Context_val(Context))));
 }
 
 /*--... Operations on function types .......................................--*/
 
 /* lltype -> lltype array -> lltype */
-LLVMTypeRef llvm_function_type(LLVMTypeRef RetTy, value ParamTys) {
-  return LLVMFunctionType(RetTy, (LLVMTypeRef *)ParamTys, Wosize_val(ParamTys),
-                          0);
+value llvm_function_type(value RetTy, value ParamTys) {
+  CAMLparam2(RetTy, ParamTys);
+  size_t len = Wosize_val(ParamTys);
+  LLVMTypeRef *Temp = alloc_temp(ParamTys);
+  LLVMTypeRef Type = LLVMFunctionType(Type_val(RetTy), Temp, len, 0);
+  free(Temp);
+  CAMLreturn(to_val(Type));
 }
 
 /* lltype -> lltype array -> lltype */
-LLVMTypeRef llvm_var_arg_function_type(LLVMTypeRef RetTy, value ParamTys) {
-  return LLVMFunctionType(RetTy, (LLVMTypeRef *)ParamTys, Wosize_val(ParamTys),
-                          1);
+value llvm_var_arg_function_type(value RetTy, value ParamTys) {
+  CAMLparam2(RetTy, ParamTys);
+  size_t len = Wosize_val(ParamTys);
+  LLVMTypeRef *Temp = alloc_temp(ParamTys);
+  LLVMTypeRef Type = LLVMFunctionType(Type_val(RetTy), Temp, len, 1);
+  free(Temp);
+  CAMLreturn(to_val(Type));
 }
 
 /* lltype -> bool */
-value llvm_is_var_arg(LLVMTypeRef FunTy) {
-  return Val_bool(LLVMIsFunctionVarArg(FunTy));
+value llvm_is_var_arg(value FunTy) {
+  CAMLparam1(FunTy);
+  CAMLreturn(Val_bool(LLVMIsFunctionVarArg(Type_val(FunTy))));
+}
+
+/* lltype -> lltype */
+value llvm_return_type(value FunTy) {
+  CAMLparam1(FunTy);
+  LLVMTypeRef Type = LLVMGetReturnType(Type_val(FunTy));
+  CAMLreturn(to_val(Type));
 }
 
 /* lltype -> lltype array */
-value llvm_param_types(LLVMTypeRef FunTy) {
-  value Tys = caml_alloc_tuple_uninit(LLVMCountParamTypes(FunTy));
-  LLVMGetParamTypes(FunTy, (LLVMTypeRef *)Op_val(Tys));
-  return Tys;
+value llvm_param_types(value FunTy) {
+  CAMLparam1(FunTy);
+  CAMLlocal1(Tys);
+  unsigned Length = LLVMCountParamTypes(Type_val(FunTy));
+  LLVMTypeRef *Temp = malloc(sizeof(LLVMTypeRef) * Length);
+  LLVMGetParamTypes(Type_val(FunTy), Temp);
+  Tys = caml_alloc_tuple(Length);
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(Tys, I, to_val(Temp[I]));
+  }
+  free(Temp);
+  CAMLreturn(Tys);
 }
 
 /*--... Operations on struct types .........................................--*/
 
 /* llcontext -> lltype array -> lltype */
-LLVMTypeRef llvm_struct_type(LLVMContextRef C, value ElementTypes) {
-  return LLVMStructTypeInContext(C, (LLVMTypeRef *)ElementTypes,
-                                 Wosize_val(ElementTypes), 0);
+value llvm_struct_type(value C, value ElementTypes) {
+  CAMLparam2(C, ElementTypes);
+  size_t Length = Wosize_val(ElementTypes);
+  LLVMTypeRef *Temp = alloc_temp(ElementTypes);
+  LLVMTypeRef Type = LLVMStructTypeInContext(Context_val(C), Temp, Length, 0);
+  free(Temp);
+  CAMLreturn(to_val(Type));
 }
 
 /* llcontext -> lltype array -> lltype */
-LLVMTypeRef llvm_packed_struct_type(LLVMContextRef C, value ElementTypes) {
-  return LLVMStructTypeInContext(C, (LLVMTypeRef *)ElementTypes,
-                                 Wosize_val(ElementTypes), 1);
+value llvm_packed_struct_type(value C, value ElementTypes) {
+  CAMLparam2(C, ElementTypes);
+  size_t Length = Wosize_val(ElementTypes);
+  LLVMTypeRef *Temp = alloc_temp(ElementTypes);
+  LLVMTypeRef Type = LLVMStructTypeInContext(Context_val(C), Temp, Length, 1);
+  free(Temp);
+  CAMLreturn(to_val(Type));
 }
 
 /* llcontext -> string -> lltype */
-LLVMTypeRef llvm_named_struct_type(LLVMContextRef C, value Name) {
-  return LLVMStructCreateNamed(C, String_val(Name));
+value llvm_named_struct_type(value C, value Name) {
+  CAMLparam2(C, Name);
+  CAMLreturn(to_val(LLVMStructCreateNamed(Context_val(C), String_val(Name))));
 }
 
-value llvm_struct_set_body(LLVMTypeRef Ty, value ElementTypes, value Packed) {
-  LLVMStructSetBody(Ty, (LLVMTypeRef *)ElementTypes, Wosize_val(ElementTypes),
-                    Bool_val(Packed));
-  return Val_unit;
+/* lltype -> lltype array -> bool -> unit */
+value llvm_struct_set_body(value Ty, value ElementTypes, value Packed) {
+  CAMLparam3(Ty, ElementTypes, Packed);
+  unsigned Length = Wosize_val(ElementTypes);
+  LLVMTypeRef *Temp = alloc_temp(ElementTypes);
+  LLVMStructSetBody(Type_val(Ty), Temp, Length, Bool_val(Packed));
+  CAMLreturn(Val_unit);
 }
 
 /* lltype -> string option */
-value llvm_struct_name(LLVMTypeRef Ty) {
-  const char *CStr = LLVMGetStructName(Ty);
+value llvm_struct_name(value Ty) {
+  CAMLparam1(Ty);
+  const char *CStr = LLVMGetStructName(Type_val(Ty));
   size_t Len;
-  if (!CStr)
-    return Val_none;
+  if (!CStr) {
+    CAMLreturn(Val_none);
+  }
   Len = strlen(CStr);
-  return cstr_to_string_option(CStr, Len);
+  CAMLreturn(cstr_to_string_option(CStr, Len));
 }
 
 /* lltype -> lltype array */
-value llvm_struct_element_types(LLVMTypeRef StructTy) {
-  value Tys = caml_alloc_tuple_uninit(LLVMCountStructElementTypes(StructTy));
-  LLVMGetStructElementTypes(StructTy, (LLVMTypeRef *)Op_val(Tys));
-  return Tys;
+value llvm_struct_element_types(value StructTy) {
+  CAMLparam1(StructTy);
+  CAMLlocal1(Tys);
+  unsigned Length = LLVMCountStructElementTypes(Type_val(StructTy));
+  LLVMTypeRef *Temp = alloc_temp(Length);
+  LLVMGetStructElementTypes(Type_val(StructTy), Temp);
+  Tys = caml_alloc_tuple(Length);
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(Tys, I, to_val(Temp[I]));
+  }
+  free(Temp);
+  CAMLreturn(Tys);
 }
 
 /* lltype -> bool */
-value llvm_is_packed(LLVMTypeRef StructTy) {
-  return Val_bool(LLVMIsPackedStruct(StructTy));
+value llvm_is_packed(value StructTy) {
+  CAMLparam1(StructTy);
+  CAMLreturn(Val_bool(LLVMIsPackedStruct(Type_val(StructTy))));
 }
 
 /* lltype -> bool */
-value llvm_is_opaque(LLVMTypeRef StructTy) {
-  return Val_bool(LLVMIsOpaqueStruct(StructTy));
+value llvm_is_opaque(value StructTy) {
+  CAMLparam1(StructTy);
+  CAMLreturn(Val_bool(LLVMIsOpaqueStruct(Type_val(StructTy))));
 }
 
 /* lltype -> bool */
-value llvm_is_literal(LLVMTypeRef StructTy) {
-  return Val_bool(LLVMIsLiteralStruct(StructTy));
+value llvm_is_literal(value StructTy) {
+  CAMLparam1(StructTy);
+  CAMLreturn(Val_bool(LLVMIsLiteralStruct(Type_val(StructTy))));
 }
 
 /*--... Operations on array, pointer, and vector types .....................--*/
 
 /* lltype -> lltype array */
-value llvm_subtypes(LLVMTypeRef Ty) {
-  unsigned Size = LLVMGetNumContainedTypes(Ty);
-  value Arr = caml_alloc_tuple_uninit(Size);
-  LLVMGetSubtypes(Ty, (LLVMTypeRef *)Op_val(Arr));
-  return Arr;
+value llvm_subtypes(value Ty) {
+  CAMLparam1(Ty);
+  CAMLlocal1(Arr);
+  unsigned Length = LLVMGetNumContainedTypes(Type_val(Ty));
+  Arr = caml_alloc_tuple(Length);
+  LLVMTypeRef *Temp = malloc(sizeof(LLVMTypeRef) * Length);
+  LLVMGetSubtypes(Type_val(Ty), Temp);
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(Arr, I, to_val(Temp[I]));
+  }
+  free(Temp);
+  CAMLreturn(Arr);
 }
 
 /* lltype -> int -> lltype */
-LLVMTypeRef llvm_array_type(LLVMTypeRef ElementTy, value Count) {
-  return LLVMArrayType(ElementTy, Int_val(Count));
+value llvm_array_type(value ElementTy, value Count) {
+  CAMLparam2(ElementTy, Count);
+  CAMLreturn(to_val(LLVMArrayType(Type_val(ElementTy), Int_val(Count))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_pointer_type(LLVMContextRef C) {
-  return LLVMPointerTypeInContext(C, 0);
+value llvm_pointer_type(value C) {
+  CAMLparam1(C);
+  LLVMTypeRef Type = LLVMPointerTypeInContext(Context_val(C), 0);
+  CAMLreturn(to_val(Type));
 }
 
 /* llcontext -> int -> lltype */
-LLVMTypeRef llvm_qualified_pointer_type(LLVMContextRef C, value AddressSpace) {
-  return LLVMPointerTypeInContext(C, Int_val(AddressSpace));
+value llvm_qualified_pointer_type(value C, value AddressSpace) {
+  CAMLparam2(C, AddressSpace);
+  LLVMTypeRef Type =
+      LLVMPointerTypeInContext(Context_val(C), Int_val(AddressSpace));
+  CAMLreturn(to_val(Type));
 }
 
 /* lltype -> int -> lltype */
-LLVMTypeRef llvm_vector_type(LLVMTypeRef ElementTy, value Count) {
-  return LLVMVectorType(ElementTy, Int_val(Count));
+value llvm_vector_type(value ElementTy, value Count) {
+  CAMLparam2(ElementTy, Count);
+  CAMLreturn(to_val(LLVMVectorType(Type_val(ElementTy), Int_val(Count))));
+}
+
+/* lltype -> lltype */
+value llvm_get_element_type(value Ty) {
+  CAMLparam1(Ty);
+  CAMLreturn(to_val(LLVMGetElementType(Type_val(Ty))));
 }
 
 /* lltype -> int */
-value llvm_array_length(LLVMTypeRef ArrayTy) {
-  return Val_int(LLVMGetArrayLength2(ArrayTy));
+value llvm_array_length(value ArrayTy) {
+  CAMLparam1(ArrayTy);
+  CAMLreturn(Val_int(LLVMGetArrayLength2(Type_val(ArrayTy))));
 }
 
 /* lltype -> int */
-value llvm_address_space(LLVMTypeRef PtrTy) {
-  return Val_int(LLVMGetPointerAddressSpace(PtrTy));
+value llvm_address_space(value PtrTy) {
+  CAMLparam1(PtrTy);
+  CAMLreturn(Val_int(LLVMGetPointerAddressSpace(Type_val(PtrTy))));
 }
 
 /* lltype -> int */
-value llvm_vector_size(LLVMTypeRef VectorTy) {
-  return Val_int(LLVMGetVectorSize(VectorTy));
+value llvm_vector_size(value VectorTy) {
+  CAMLparam1(VectorTy);
+  CAMLreturn(Val_int(LLVMGetVectorSize(Type_val(VectorTy))));
 }
 
 /*--... Operations on other types ..........................................--*/
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_void_type(LLVMContextRef Context) {
-  return LLVMVoidTypeInContext(Context);
+value llvm_void_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMVoidTypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_label_type(LLVMContextRef Context) {
-  return LLVMLabelTypeInContext(Context);
+value llvm_label_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMLabelTypeInContext(Context_val(Context))));
 }
 
 /* llcontext -> lltype */
-LLVMTypeRef llvm_x86_mmx_type(LLVMContextRef Context) {
-  return LLVMX86MMXTypeInContext(Context);
+value llvm_x86_mmx_type(value Context) {
+  CAMLparam1(Context);
+  CAMLreturn(to_val(LLVMX86MMXTypeInContext(Context_val(Context))));
 }
 
-value llvm_type_by_name(LLVMModuleRef M, value Name) {
-  return ptr_to_option(LLVMGetTypeByName(M, String_val(Name)));
+/* llmodule -> string -> lltype option */
+value llvm_type_by_name(value M, value Name) {
+  CAMLparam2(M, Name);
+  CAMLreturn(ptr_to_option(LLVMGetTypeByName(Module_val(M), String_val(Name))));
 }
 
 /*===-- VALUES ------------------------------------------------------------===*/
 
 /* llvalue -> lltype */
-LLVMTypeRef llvm_type_of(LLVMValueRef Val) { return LLVMTypeOf(Val); }
+value llvm_type_of(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(to_val(LLVMTypeOf(Value_val(Val))));
+}
 
 /* keep in sync with ValueKind.t */
 enum ValueKind {
   NullValue = 0,
   Argument,
   BasicBlock,
   InlineAsm,
   MDNode,
enum ValueKind {
   GlobalIFunc,
   GlobalVariable,
   UndefValue,
   PoisonValue,
   Instruction
 };
 
 /* llvalue -> ValueKind.t */
-#define DEFINE_CASE(Val, Kind) \
-    do {if (LLVMIsA##Kind(Val)) return Val_int(Kind);} while(0)
-
-value llvm_classify_value(LLVMValueRef Val) {
-  if (!Val)
-    return Val_int(NullValue);
+#define DEFINE_CASE(Val, Kind)                                                 \
+  do {                                                                         \
+    if (LLVMIsA##Kind(Val))                                                    \
+      CAMLreturn(Val_int(Kind));                                               \
+  } while (0)
+
+value llvm_classify_value(value V) {
+  CAMLparam1(V);
+  CAMLlocal1(Result);
+  LLVMValueRef Val = Value_val(V);
+  if (!Val) {
+    CAMLreturn(Val_int(NullValue));
+  }
   if (LLVMIsAConstant(Val)) {
     DEFINE_CASE(Val, BlockAddress);
     DEFINE_CASE(Val, ConstantAggregateZero);
     DEFINE_CASE(Val, ConstantArray);
     DEFINE_CASE(Val, ConstantDataArray);
     DEFINE_CASE(Val, ConstantDataVector);
     DEFINE_CASE(Val, ConstantExpr);
     DEFINE_CASE(Val, ConstantFP);
     DEFINE_CASE(Val, ConstantInt);
     DEFINE_CASE(Val, ConstantPointerNull);
     DEFINE_CASE(Val, ConstantStruct);
     DEFINE_CASE(Val, ConstantVector);
   }
   if (LLVMIsAInstruction(Val)) {
-    value result = caml_alloc_small(1, 0);
-    Field(result, 0) = Val_int(LLVMGetInstructionOpcode(Val));
-    return result;
+    Result = caml_alloc_small(1, 0);
+    Field(Result, 0) = Val_int(LLVMGetInstructionOpcode(Val));
+    CAMLreturn(Result);
   }
   if (LLVMIsAGlobalValue(Val)) {
     DEFINE_CASE(Val, Function);
     DEFINE_CASE(Val, GlobalAlias);
     DEFINE_CASE(Val, GlobalIFunc);
     DEFINE_CASE(Val, GlobalVariable);
   }
   DEFINE_CASE(Val, Argument);
   DEFINE_CASE(Val, BasicBlock);
   DEFINE_CASE(Val, InlineAsm);
   DEFINE_CASE(Val, MDNode);
   DEFINE_CASE(Val, MDString);
   DEFINE_CASE(Val, UndefValue);
   DEFINE_CASE(Val, PoisonValue);
-  failwith("Unknown Value class");
+  caml_failwith("Unknown Value class");
 }
 
 /* llvalue -> string */
-value llvm_value_name(LLVMValueRef Val) {
-  return caml_copy_string(LLVMGetValueName(Val));
+value llvm_value_name(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(caml_copy_string(LLVMGetValueName(Value_val(Val))));
 }
 
 /* string -> llvalue -> unit */
-value llvm_set_value_name(value Name, LLVMValueRef Val) {
-  LLVMSetValueName(Val, String_val(Name));
-  return Val_unit;
+value llvm_set_value_name(value Name, value Val) {
+  CAMLparam2(Name, Val);
+  LLVMSetValueName(Value_val(Val), String_val(Name));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> unit */
-value llvm_dump_value(LLVMValueRef Val) {
-  LLVMDumpValue(Val);
-  return Val_unit;
+value llvm_dump_value(value Val) {
+  CAMLparam1(Val);
+  LLVMDumpValue(Value_val(Val));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> string */
-value llvm_string_of_llvalue(LLVMValueRef M) {
-  char *ValueCStr = LLVMPrintValueToString(M);
-  value ValueStr = caml_copy_string(ValueCStr);
+value llvm_string_of_llvalue(value M) {
+  CAMLparam1(M);
+  CAMLlocal1(ValueStr);
+  char *ValueCStr = LLVMPrintValueToString(Value_val(M));
+  ValueStr = caml_copy_string(ValueCStr);
   LLVMDisposeMessage(ValueCStr);
 
-  return ValueStr;
+  CAMLreturn(ValueStr);
 }
 
 /* llvalue -> llvalue -> unit */
-value llvm_replace_all_uses_with(LLVMValueRef OldVal, LLVMValueRef NewVal) {
-  LLVMReplaceAllUsesWith(OldVal, NewVal);
-  return Val_unit;
+value llvm_replace_all_uses_with(value OldVal, value NewVal) {
+  CAMLparam2(OldVal, NewVal);
+  LLVMReplaceAllUsesWith(Value_val(OldVal), Value_val(NewVal));
+  CAMLreturn(Val_unit);
 }
 
 /*--... Operations on users ................................................--*/
 
 /* llvalue -> int -> llvalue */
-LLVMValueRef llvm_operand(LLVMValueRef V, value I) {
-  return LLVMGetOperand(V, Int_val(I));
+value llvm_operand(value V, value I) {
+  CAMLparam2(V, I);
+  CAMLreturn(to_val(LLVMGetOperand(Value_val(V), Int_val(I))));
 }
 
 /* llvalue -> int -> lluse */
-LLVMUseRef llvm_operand_use(LLVMValueRef V, value I) {
-  return LLVMGetOperandUse(V, Int_val(I));
+value llvm_operand_use(value V, value I) {
+  CAMLparam2(V, I);
+  CAMLreturn(to_val(LLVMGetOperandUse(Value_val(V), Int_val(I))));
 }
 
 /* llvalue -> int -> llvalue -> unit */
-value llvm_set_operand(LLVMValueRef U, value I, LLVMValueRef V) {
-  LLVMSetOperand(U, Int_val(I), V);
-  return Val_unit;
+value llvm_set_operand(value U, value I, value V) {
+  CAMLparam3(U, I, V);
+  LLVMSetOperand(Value_val(U), Int_val(I), Value_val(V));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> int */
-value llvm_num_operands(LLVMValueRef V) {
-  return Val_int(LLVMGetNumOperands(V));
+value llvm_num_operands(value V) {
+  CAMLparam1(V);
+  CAMLreturn(Val_int(LLVMGetNumOperands(Value_val(V))));
 }
 
 /* llvalue -> int array */
-value llvm_indices(LLVMValueRef Instr) {
-  unsigned n = LLVMGetNumIndices(Instr);
-  const unsigned *Indices = LLVMGetIndices(Instr);
-  value indices = caml_alloc_tuple_uninit(n);
-  for (unsigned i = 0; i < n; i++) {
-    Op_val(indices)[i] = Val_int(Indices[i]);
+value llvm_indices(value Instr) {
+  CAMLparam1(Instr);
+  CAMLlocal1(Array);
+  unsigned Length = LLVMGetNumIndices(Value_val(Instr));
+  const unsigned *Indices = LLVMGetIndices(Value_val(Instr));
+  Array = caml_alloc_tuple(Length);
+  for (unsigned I = 0; I < Length; I++) {
+    Store_field(Array, I, Val_int(Indices[I]));
   }
-  return indices;
+  CAMLreturn(Array);
 }
 
 /*--... Operations on constants of (mostly) any type .......................--*/
 
 /* llvalue -> bool */
-value llvm_is_constant(LLVMValueRef Val) {
-  return Val_bool(LLVMIsConstant(Val));
+value llvm_is_constant(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(Val_bool(LLVMIsConstant(Value_val(Val))));
+}
+
+/* lltype -> llvalue */
+value llvm_const_null(value Ty) {
+  CAMLparam1(Ty);
+  LLVMValueRef Value = LLVMConstNull(Type_val(Ty));
+  CAMLreturn(to_val(Value));
+}
+
+/* lltype -> llvalue */
+value llvm_const_all_ones(value Ty) {
+  CAMLparam1(Ty);
+  LLVMValueRef Value = LLVMConstAllOnes(Type_val(Ty));
+  CAMLreturn(to_val(Value));
+}
+
+/* lltype -> llvalue */
+value llvm_const_pointer_null(value Ty) {
+  CAMLparam1(Ty);
+  LLVMValueRef Value = LLVMConstPointerNull(Type_val(Ty));
+  CAMLreturn(to_val(Value));
+}
+
+/* lltype -> llvalue */
+value llvm_get_undef(value Ty) {
+  CAMLparam1(Ty);
+  LLVMValueRef Value = LLVMGetUndef(Type_val(Ty));
+  CAMLreturn(to_val(Value));
+}
+
+/* lltype -> llvalue */
+value llvm_get_poison(value Ty) {
+  CAMLparam1(Ty);
+  LLVMValueRef Value = LLVMGetPoison(Type_val(Ty));
+  CAMLreturn(to_val(Value));
 }
 
 /* llvalue -> bool */
-value llvm_is_null(LLVMValueRef Val) { return Val_bool(LLVMIsNull(Val)); }
+value llvm_is_null(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(Val_bool(LLVMIsNull(Value_val(Val))));
+}
 
 /* llvalue -> bool */
-value llvm_is_undef(LLVMValueRef Val) { return Val_bool(LLVMIsUndef(Val)); }
+value llvm_is_undef(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(Val_bool(LLVMIsUndef(Value_val(Val))));
+}
 
 /* llvalue -> bool */
-value llvm_is_poison(LLVMValueRef Val) { return Val_bool(LLVMIsPoison(Val)); }
+value llvm_is_poison(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(Val_bool(LLVMIsPoison(Value_val(Val))));
+}
 
 /* llvalue -> Opcode.t */
-value llvm_constexpr_get_opcode(LLVMValueRef Val) {
-  return LLVMIsAConstantExpr(Val) ? Val_int(LLVMGetConstOpcode(Val))
-                                  : Val_int(0);
+value llvm_constexpr_get_opcode(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(LLVMIsAConstantExpr(Value_val(Val))
+                 ? Val_int(LLVMGetConstOpcode(Value_val(Val)))
+                 : Val_int(0));
 }
 
 /*--... Operations on instructions .........................................--*/
 
 /* llvalue -> bool */
-value llvm_has_metadata(LLVMValueRef Val) {
-  return Val_bool(LLVMHasMetadata(Val));
+value llvm_has_metadata(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(Val_bool(LLVMHasMetadata(Value_val(Val))));
 }
 
 /* llvalue -> int -> llvalue option */
-value llvm_metadata(LLVMValueRef Val, value MDKindID) {
-  return ptr_to_option(LLVMGetMetadata(Val, Int_val(MDKindID)));
+value llvm_metadata(value Val, value MDKindID) {
+  CAMLparam2(Val, MDKindID);
+  CAMLreturn(ptr_to_option(LLVMGetMetadata(Value_val(Val), Int_val(MDKindID))));
 }
 
 /* llvalue -> int -> llvalue -> unit */
-value llvm_set_metadata(LLVMValueRef Val, value MDKindID, LLVMValueRef MD) {
-  LLVMSetMetadata(Val, Int_val(MDKindID), MD);
-  return Val_unit;
+value llvm_set_metadata(value Val, value MDKindID, value MD) {
+  CAMLparam3(Val, MDKindID, MD);
+  LLVMSetMetadata(Value_val(Val), Int_val(MDKindID), Value_val(MD));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> int -> unit */
-value llvm_clear_metadata(LLVMValueRef Val, value MDKindID) {
-  LLVMSetMetadata(Val, Int_val(MDKindID), NULL);
-  return Val_unit;
+value llvm_clear_metadata(value Val, value MDKindID) {
+  CAMLparam2(Val, MDKindID);
+  LLVMSetMetadata(Value_val(Val), Int_val(MDKindID), NULL);
+  CAMLreturn(Val_unit);
 }
 
 /*--... Operations on metadata .............................................--*/
 
 /* llcontext -> string -> llvalue */
-LLVMValueRef llvm_mdstring(LLVMContextRef C, value S) {
-  return LLVMMDStringInContext(C, String_val(S), caml_string_length(S));
+value llvm_mdstring(value C, value S) {
+  CAMLparam2(C, S);
+  CAMLreturn(to_val(LLVMMDStringInContext(Context_val(C), String_val(S),
+                                          caml_string_length(S))));
 }
 
 /* llcontext -> llvalue array -> llvalue */
-LLVMValueRef llvm_mdnode(LLVMContextRef C, value ElementVals) {
-  return LLVMMDNodeInContext(C, (LLVMValueRef *)Op_val(ElementVals),
-                             Wosize_val(ElementVals));
+value llvm_mdnode(value C, value ElementVals) {
+  CAMLparam2(C, ElementVals);
+  unsigned Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  LLVMValueRef Value = LLVMMDNodeInContext(Context_val(C), Temp, Length);
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* llcontext -> llvalue */
-LLVMValueRef llvm_mdnull(LLVMContextRef C) { return NULL; }
+value llvm_mdnull(value C) {
+  CAMLparam1(C);
+  CAMLreturn(to_val(NULL));
+}
 
 /* llvalue -> string option */
-value llvm_get_mdstring(LLVMValueRef V) {
+value llvm_get_mdstring(value V) {
+  CAMLparam1(V);
   unsigned Len;
-  const char *CStr = LLVMGetMDString(V, &Len);
-  return cstr_to_string_option(CStr, Len);
+  const char *CStr = LLVMGetMDString(Value_val(V), &Len);
+  CAMLreturn(cstr_to_string_option(CStr, Len));
 }
 
-value llvm_get_mdnode_operands(LLVMValueRef V) {
-  unsigned int n = LLVMGetMDNodeNumOperands(V);
-  value Operands = caml_alloc_tuple_uninit(n);
-  LLVMGetMDNodeOperands(V, (LLVMValueRef *)Op_val(Operands));
-  return Operands;
+/* llvalue -> llvalue array */
+value llvm_get_mdnode_operands(value Value) {
+  CAMLparam1(Value);
+  CAMLlocal1(Operands);
+  LLVMValueRef V = Value_val(Value);
+  unsigned Length = LLVMGetMDNodeNumOperands(V);
+  Operands = caml_alloc_tuple(Length);
+  LLVMValueRef *Temp = malloc(sizeof(LLVMValueRef) * Length);
+  LLVMGetMDNodeOperands(V, Temp);
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(Operands, I, to_val(Temp[I]));
+  }
+  free(Temp);
+  CAMLreturn(Operands);
 }
 
 /* llmodule -> string -> llvalue array */
-value llvm_get_namedmd(LLVMModuleRef M, value Name) {
-  CAMLparam1(Name);
-  value Nodes = caml_alloc_tuple_uninit(
-      LLVMGetNamedMetadataNumOperands(M, String_val(Name)));
-  LLVMGetNamedMetadataOperands(M, String_val(Name),
-                               (LLVMValueRef *)Op_val(Nodes));
+value llvm_get_namedmd(value M, value Name) {
+  CAMLparam2(M, Name);
+  CAMLlocal1(Nodes);
+  unsigned Length =
+      LLVMGetNamedMetadataNumOperands(Module_val(M), String_val(Name));
+  Nodes = caml_alloc_tuple(Length);
+  LLVMValueRef *Temp = malloc(sizeof(LLVMValueRef) * Length);
+  LLVMGetNamedMetadataOperands(Module_val(M), String_val(Name), Temp);
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(Nodes, I, to_val(Temp[I]));
+  }
+  free(Temp);
   CAMLreturn(Nodes);
 }
 
 /* llmodule -> string -> llvalue -> unit */
-value llvm_append_namedmd(LLVMModuleRef M, value Name, LLVMValueRef Val) {
-  LLVMAddNamedMetadataOperand(M, String_val(Name), Val);
-  return Val_unit;
+value llvm_append_namedmd(value M, value Name, value Val) {
+  CAMLparam3(M, Name, Val);
+  LLVMAddNamedMetadataOperand(Module_val(M), String_val(Name), Value_val(Val));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> llmetadata */
-LLVMMetadataRef llvm_value_as_metadata(LLVMValueRef Val) {
-  return LLVMValueAsMetadata(Val);
+value llvm_value_as_metadata(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(to_val(LLVMValueAsMetadata(Value_val(Val))));
 }
 
 /* llcontext -> llmetadata -> llvalue */
-LLVMValueRef llvm_metadata_as_value(LLVMContextRef C, LLVMMetadataRef MD) {
-  return LLVMMetadataAsValue(C, MD);
+value llvm_metadata_as_value(value C, value MD) {
+  CAMLparam2(C, MD);
+  CAMLreturn(to_val(LLVMMetadataAsValue(Context_val(C), Metadata_val(MD))));
 }
 
 /*--... Operations on scalar constants .....................................--*/
 
 /* lltype -> int -> llvalue */
-LLVMValueRef llvm_const_int(LLVMTypeRef IntTy, value N) {
-  return LLVMConstInt(IntTy, (long long)Long_val(N), 1);
+value llvm_const_int(value IntTy, value N) {
+  CAMLparam2(IntTy, N);
+  CAMLreturn(to_val(LLVMConstInt(Type_val(IntTy), (long long)Long_val(N), 1)));
 }
 
 /* lltype -> Int64.t -> bool -> llvalue */
-LLVMValueRef llvm_const_of_int64(LLVMTypeRef IntTy, value N, value SExt) {
-  return LLVMConstInt(IntTy, Int64_val(N), Bool_val(SExt));
+value llvm_const_of_int64(value IntTy, value N, value SExt) {
+  CAMLparam3(IntTy, N, SExt);
+  CAMLreturn(
+      to_val(LLVMConstInt(Type_val(IntTy), Int64_val(N), Bool_val(SExt))));
 }
 
-/* llvalue -> Int64.t */
-value llvm_int64_of_const(LLVMValueRef Const) {
+/* llvalue -> Int64.t option */
+value llvm_int64_of_const(value C) {
+  CAMLparam1(C);
+  LLVMValueRef Const = Value_val(C);
   if (!(LLVMIsAConstantInt(Const)) ||
-      !(LLVMGetIntTypeWidth(LLVMTypeOf(Const)) <= 64))
-    return Val_none;
-  return caml_alloc_some(caml_copy_int64(LLVMConstIntGetSExtValue(Const)));
+      !(LLVMGetIntTypeWidth(LLVMTypeOf(Const)) <= 64)) {
+    CAMLreturn(Val_none);
+  }
+  CAMLreturn(caml_alloc_some(caml_copy_int64(LLVMConstIntGetSExtValue(Const))));
 }
 
 /* lltype -> string -> int -> llvalue */
-LLVMValueRef llvm_const_int_of_string(LLVMTypeRef IntTy, value S, value Radix) {
-  return LLVMConstIntOfStringAndSize(IntTy, String_val(S),
-                                     caml_string_length(S), Int_val(Radix));
+value llvm_const_int_of_string(value IntTy, value S, value Radix) {
+  CAMLparam3(IntTy, S, Radix);
+  CAMLreturn(to_val(LLVMConstIntOfStringAndSize(
+      Type_val(IntTy), String_val(S), caml_string_length(S), Int_val(Radix))));
 }
 
 /* lltype -> float -> llvalue */
-LLVMValueRef llvm_const_float(LLVMTypeRef RealTy, value N) {
-  return LLVMConstReal(RealTy, Double_val(N));
+value llvm_const_float(value RealTy, value N) {
+  CAMLparam2(RealTy, N);
+  CAMLreturn(to_val(LLVMConstReal(Type_val(RealTy), Double_val(N))));
 }
 
-/* llvalue -> float */
-value llvm_float_of_const(LLVMValueRef Const) {
+/* llvalue -> float option */
+value llvm_float_of_const(value C) {
+  CAMLparam1(C);
+  LLVMValueRef Const = Value_val(C);
   LLVMBool LosesInfo;
   double Result;
-  if (!LLVMIsAConstantFP(Const))
-    return Val_none;
+  if (!LLVMIsAConstantFP(Const)) {
+    CAMLreturn(Val_none);
+  }
   Result = LLVMConstRealGetDouble(Const, &LosesInfo);
-  if (LosesInfo)
-    return Val_none;
-  return caml_alloc_some(caml_copy_double(Result));
+  if (LosesInfo) {
+    CAMLreturn(Val_none);
+  }
+  CAMLreturn(caml_alloc_some(caml_copy_double(Result)));
 }
 
 /* lltype -> string -> llvalue */
-LLVMValueRef llvm_const_float_of_string(LLVMTypeRef RealTy, value S) {
-  return LLVMConstRealOfStringAndSize(RealTy, String_val(S),
-                                      caml_string_length(S));
+value llvm_const_float_of_string(value RealTy, value S) {
+  CAMLparam2(RealTy, S);
+  CAMLreturn(to_val(LLVMConstRealOfStringAndSize(
+      Type_val(RealTy), String_val(S), caml_string_length(S))));
 }
 
 /*--... Operations on composite constants ..................................--*/
 
 /* llcontext -> string -> llvalue */
-LLVMValueRef llvm_const_string(LLVMContextRef Context, value Str,
-                               value NullTerminate) {
-  return LLVMConstStringInContext(Context, String_val(Str), string_length(Str),
-                                  1);
+value llvm_const_string(value Context, value Str) {
+  CAMLparam2(Context, Str);
+  CAMLreturn(to_val(LLVMConstStringInContext(
+      Context_val(Context), String_val(Str), caml_string_length(Str), 1)));
 }
 
 /* llcontext -> string -> llvalue */
-LLVMValueRef llvm_const_stringz(LLVMContextRef Context, value Str,
-                                value NullTerminate) {
-  return LLVMConstStringInContext(Context, String_val(Str), string_length(Str),
-                                  0);
+value llvm_const_stringz(value Context, value Str) {
+  CAMLparam2(Context, Str);
+  CAMLreturn(to_val(LLVMConstStringInContext(
+      Context_val(Context), String_val(Str), caml_string_length(Str), 0)));
 }
 
 /* lltype -> llvalue array -> llvalue */
-LLVMValueRef llvm_const_array(LLVMTypeRef ElementTy, value ElementVals) {
-  return LLVMConstArray(ElementTy, (LLVMValueRef *)Op_val(ElementVals),
-                        Wosize_val(ElementVals));
+value llvm_const_array(value ElementTy, value ElementVals) {
+  CAMLparam2(ElementTy, ElementVals);
+  unsigned Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  LLVMValueRef Value = LLVMConstArray(Type_val(ElementTy), Temp, Length);
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* llcontext -> llvalue array -> llvalue */
-LLVMValueRef llvm_const_struct(LLVMContextRef C, value ElementVals) {
-  return LLVMConstStructInContext(C, (LLVMValueRef *)Op_val(ElementVals),
-                                  Wosize_val(ElementVals), 0);
+value llvm_const_struct(value C, value ElementVals) {
+  CAMLparam2(C, ElementVals);
+  unsigned Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  LLVMValueRef Value =
+      LLVMConstStructInContext(Context_val(C), Temp, Length, 0);
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* lltype -> llvalue array -> llvalue */
-LLVMValueRef llvm_const_named_struct(LLVMTypeRef Ty, value ElementVals) {
-  return LLVMConstNamedStruct(Ty, (LLVMValueRef *)Op_val(ElementVals),
-                              Wosize_val(ElementVals));
+value llvm_const_named_struct(value Ty, value ElementVals) {
+  CAMLparam2(Ty, ElementVals);
+  unsigned Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  LLVMValueRef Value =
+      LLVMConstNamedStruct(Type_val(Ty), (LLVMValueRef *)Temp, Length);
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* llcontext -> llvalue array -> llvalue */
-LLVMValueRef llvm_const_packed_struct(LLVMContextRef C, value ElementVals) {
-  return LLVMConstStructInContext(C, (LLVMValueRef *)Op_val(ElementVals),
-                                  Wosize_val(ElementVals), 1);
+value llvm_const_packed_struct(value C, value ElementVals) {
+  CAMLparam2(C, ElementVals);
+  unsigned Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  LLVMValueRef Value =
+      LLVMConstStructInContext(Context_val(C), Temp, Length, 1);
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* llvalue array -> llvalue */
-LLVMValueRef llvm_const_vector(value ElementVals) {
-  return LLVMConstVector((LLVMValueRef *)Op_val(ElementVals),
-                         Wosize_val(ElementVals));
+value llvm_const_vector(value ElementVals) {
+  CAMLparam1(ElementVals);
+  unsigned Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  LLVMValueRef Value = LLVMConstVector(Temp, Length);
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* llvalue -> string option */
-value llvm_string_of_const(LLVMValueRef Const) {
+value llvm_string_of_const(value C) {
+  CAMLparam1(C);
   size_t Len;
   const char *CStr;
-  if (!LLVMIsAConstantDataSequential(Const) || !LLVMIsConstantString(Const))
-    return Val_none;
+  LLVMValueRef Const = Value_val(C);
+  if (!LLVMIsAConstantDataSequential(Const) || !LLVMIsConstantString(Const)) {
+    CAMLreturn(Val_none);
+  }
   CStr = LLVMGetAsString(Const, &Len);
-  return cstr_to_string_option(CStr, Len);
+  CAMLreturn(cstr_to_string_option(CStr, Len));
 }
 
 /* llvalue -> int -> llvalue option */
-value llvm_aggregate_element(LLVMValueRef Const, value N) {
-  return ptr_to_option(LLVMGetAggregateElement(Const, Int_val(N)));
+value llvm_aggregate_element(value Const, value N) {
+  CAMLparam2(Const, N);
+  CAMLreturn(
+      ptr_to_option(LLVMGetAggregateElement(Value_val(Const), Int_val(N))));
 }
 
 /*--... Constant expressions ...............................................--*/
 
+/* lltype -> llvalue */
+value llvm_align_of(value Type) {
+  CAMLparam1(Type);
+  LLVMValueRef Value = LLVMAlignOf(Type_val(Type));
+  CAMLreturn(to_val(Value));
+}
+
+/* lltype -> llvalue */
+value llvm_size_of(value Type) {
+  CAMLparam1(Type);
+  LLVMValueRef Value = LLVMSizeOf(Type_val(Type));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue */
+value llvm_const_neg(value Value) {
+  CAMLparam1(Value);
+  LLVMValueRef NegValue = LLVMConstNeg(Value_val(Value));
+  CAMLreturn(to_val(NegValue));
+}
+
+/* llvalue -> llvalue */
+value llvm_const_nsw_neg(value Value) {
+  CAMLparam1(Value);
+  LLVMValueRef NegValue = LLVMConstNSWNeg(Value_val(Value));
+  CAMLreturn(to_val(NegValue));
+}
+
+/* llvalue -> llvalue */
+value llvm_const_nuw_neg(value Value) {
+  CAMLparam1(Value);
+  LLVMValueRef NegValue = LLVMConstNUWNeg(Value_val(Value));
+  CAMLreturn(to_val(NegValue));
+}
+
+/* llvalue -> llvalue */
+value llvm_const_not(value Value) {
+  CAMLparam1(Value);
+  LLVMValueRef NotValue = LLVMConstNot(Value_val(Value));
+  CAMLreturn(to_val(NotValue));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_add(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstAdd(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_nsw_add(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstNSWAdd(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_nuw_add(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstNUWAdd(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_sub(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstSub(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_nsw_sub(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstNSWSub(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_nuw_sub(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstNUWSub(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_mul(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstMul(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_nsw_mul(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstNSWMul(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_nuw_mul(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstNUWMul(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_and(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstAnd(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_or(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstOr(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_xor(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstXor(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
 /* Icmp.t -> llvalue -> llvalue -> llvalue */
-LLVMValueRef llvm_const_icmp(value Pred, LLVMValueRef LHSConstant,
-                             LLVMValueRef RHSConstant) {
-  return LLVMConstICmp(Int_val(Pred) + LLVMIntEQ, LHSConstant, RHSConstant);
+value llvm_const_icmp(value Pred, value LHSConstant, value RHSConstant) {
+  CAMLparam3(Pred, LHSConstant, RHSConstant);
+  CAMLreturn(
+      to_val(LLVMConstICmp(Int_val(Pred) + LLVMIntEQ, Value_val(LHSConstant),
+                           Value_val(RHSConstant))));
 }
 
 /* Fcmp.t -> llvalue -> llvalue -> llvalue */
-LLVMValueRef llvm_const_fcmp(value Pred, LLVMValueRef LHSConstant,
-                             LLVMValueRef RHSConstant) {
-  return LLVMConstFCmp(Int_val(Pred), LHSConstant, RHSConstant);
+value llvm_const_fcmp(value Pred, value LHSConstant, value RHSConstant) {
+  CAMLparam3(Pred, LHSConstant, RHSConstant);
+  CAMLreturn(to_val(LLVMConstFCmp(Int_val(Pred), Value_val(LHSConstant),
+                                  Value_val(RHSConstant))));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_shl(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstShl(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_lshr(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstLShr(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_ashr(value LHS, value RHS) {
+  CAMLparam2(LHS, RHS);
+  LLVMValueRef Value = LLVMConstAShr(Value_val(LHS), Value_val(RHS));
+  CAMLreturn(to_val(Value));
+}
+
+/* lltype -> llvalue -> llvalue array -> llvalue */
+value llvm_const_gep(value Ty, value ConstantVal, value Indices) {
+  CAMLparam3(Ty, ConstantVal, Indices);
+  unsigned Length = Wosize_val(Indices);
+  LLVMValueRef *Temp = alloc_temp(Indices);
+  LLVMValueRef Value =
+      LLVMConstGEP2(Type_val(Ty), Value_val(ConstantVal), Temp, Length);
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* lltype -> llvalue -> llvalue array -> llvalue */
-LLVMValueRef llvm_const_gep(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
-                            value Indices) {
-  return LLVMConstGEP2(Ty, ConstantVal, (LLVMValueRef *)Op_val(Indices),
-                       Wosize_val(Indices));
+value llvm_const_in_bounds_gep(value Ty, value ConstantVal, value Indices) {
+  CAMLparam3(Ty, ConstantVal, Indices);
+  unsigned Length = Wosize_val(Indices);
+  LLVMValueRef *Temp = alloc_temp(Indices);
+  LLVMValueRef Value =
+      LLVMConstInBoundsGEP2(Type_val(Ty), Value_val(ConstantVal), Temp, Length);
+  free(Temp);
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_trunc(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstTrunc(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_sext(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstSExt(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_zext(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstZExt(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_fptrunc(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstFPTrunc(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_fpext(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstFPExt(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_uitofp(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstUIToFP(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_sitofp(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstSIToFP(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
 }
 
-/* llvalue -> llvalue array -> llvalue */
-LLVMValueRef llvm_const_in_bounds_gep(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
-                                      value Indices) {
-  return LLVMConstInBoundsGEP2(Ty, ConstantVal, (LLVMValueRef *)Op_val(Indices),
-                               Wosize_val(Indices));
+/* llvalue -> lltype -> llvalue */
+value llvm_const_fptoui(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstFPToUI(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_fptosi(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstFPToSI(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_ptrtoint(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstPtrToInt(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_inttoptr(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstIntToPtr(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_bitcast(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstBitCast(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_zext_or_bitcast(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstZExtOrBitCast(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_sext_or_bitcast(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstSExtOrBitCast(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_trunc_or_bitcast(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstTruncOrBitCast(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_pointercast(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstPointerCast(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
 }
 
 /* llvalue -> lltype -> is_signed:bool -> llvalue */
-LLVMValueRef llvm_const_intcast(LLVMValueRef CV, LLVMTypeRef T,
-                                value IsSigned) {
-  return LLVMConstIntCast(CV, T, Bool_val(IsSigned));
+value llvm_const_intcast(value CV, value T, value IsSigned) {
+  CAMLparam3(CV, T, IsSigned);
+  CAMLreturn(
+      to_val(LLVMConstIntCast(Value_val(CV), Type_val(T), Bool_val(IsSigned))));
+}
+
+/* llvalue -> lltype -> llvalue */
+value llvm_const_fpcast(value CV, value T) {
+  CAMLparam2(CV, T);
+  LLVMValueRef Value = LLVMConstFPCast(Value_val(CV), Type_val(T));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue -> llvalue */
+value llvm_const_select(value Cond, value IfTrue, value IfFalse) {
+  CAMLparam3(Cond, IfTrue, IfFalse);
+  LLVMValueRef Value =
+      LLVMConstSelect(Value_val(Cond), Value_val(IfTrue), Value_val(IfFalse));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue */
+value llvm_const_extractelement(value V, value I) {
+  CAMLparam2(V, I);
+  LLVMValueRef Value = LLVMConstExtractElement(Value_val(V), Value_val(I));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue -> llvalue */
+value llvm_const_insertelement(value V, value E, value I) {
+  CAMLparam3(V, E, I);
+  LLVMValueRef Value =
+      LLVMConstInsertElement(Value_val(V), Value_val(E), Value_val(I));
+  CAMLreturn(to_val(Value));
+}
+
+/* llvalue -> llvalue -> llvalue -> llvalue */
+value llvm_const_shufflevector(value VA, value VB, value Mask) {
+  CAMLparam3(VA, VB, Mask);
+  LLVMValueRef Value =
+      LLVMConstShuffleVector(Value_val(VA), Value_val(VB), Value_val(Mask));
+  CAMLreturn(to_val(Value));
 }
 
 /* lltype -> string -> string -> bool -> bool -> llvalue */
-LLVMValueRef llvm_const_inline_asm(LLVMTypeRef Ty, value Asm, value Constraints,
-                                   value HasSideEffects, value IsAlignStack) {
-  return LLVMConstInlineAsm(Ty, String_val(Asm), String_val(Constraints),
-                            Bool_val(HasSideEffects), Bool_val(IsAlignStack));
+value llvm_const_inline_asm(value Ty, value Asm, value Constraints,
+  CAMLparam5(Ty, Asm, Constraints, HasSideEffects, IsAlignStack);
+  CAMLreturn(to_val(
+      LLVMConstInlineAsm(Type_val(Ty), String_val(Asm), String_val(Constraints),
+                         Bool_val(HasSideEffects), Bool_val(IsAlignStack))));
+}
+
+/* llvalue -> llbasicblock -> llvalue */
+value llvm_blockaddress(value V, value B) {
+  CAMLparam2(V, B);
+  LLVMValueRef Value = LLVMBlockAddress(Value_val(V), BasicBlock_val(B));
+  CAMLreturn(to_val(Value));
 }
 
 /*--... Operations on global variables, functions, and aliases (globals) ...--*/
 
+/* llvalue -> llmodule */
+value llvm_global_parent(value Value) {
+  CAMLparam1(Value);
+  LLVMModuleRef Module = LLVMGetGlobalParent(Value_val(Value));
+  CAMLreturn(to_val(Module));
+}
+
 /* llvalue -> bool */
-value llvm_is_declaration(LLVMValueRef Global) {
-  return Val_bool(LLVMIsDeclaration(Global));
+value llvm_is_declaration(value Global) {
+  CAMLparam1(Global);
+  CAMLreturn(Val_bool(LLVMIsDeclaration(Value_val(Global))));
 }
 
 /* llvalue -> Linkage.t */
-value llvm_linkage(LLVMValueRef Global) {
-  return Val_int(LLVMGetLinkage(Global));
+value llvm_linkage(value Global) {
+  CAMLparam1(Global);
+  CAMLreturn(Val_int(LLVMGetLinkage(Value_val(Global))));
 }
 
 /* Linkage.t -> llvalue -> unit */
-value llvm_set_linkage(value Linkage, LLVMValueRef Global) {
-  LLVMSetLinkage(Global, Int_val(Linkage));
-  return Val_unit;
+value llvm_set_linkage(value Linkage, value Global) {
+  CAMLparam2(Linkage, Global);
+  LLVMSetLinkage(Value_val(Global), Int_val(Linkage));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> bool */
-value llvm_unnamed_addr(LLVMValueRef Global) {
-  return Val_bool(LLVMHasUnnamedAddr(Global));
+value llvm_unnamed_addr(value Global) {
+  CAMLparam1(Global);
+  CAMLreturn(Val_bool(LLVMHasUnnamedAddr(Value_val(Global))));
 }
 
 /* bool -> llvalue -> unit */
-value llvm_set_unnamed_addr(value UseUnnamedAddr, LLVMValueRef Global) {
-  LLVMSetUnnamedAddr(Global, Bool_val(UseUnnamedAddr));
-  return Val_unit;
+value llvm_set_unnamed_addr(value UseUnnamedAddr, value Global) {
+  CAMLparam2(UseUnnamedAddr, Global);
+  LLVMSetUnnamedAddr(Value_val(Global), Bool_val(UseUnnamedAddr));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> string */
-value llvm_section(LLVMValueRef Global) {
-  return caml_copy_string(LLVMGetSection(Global));
+value llvm_section(value Global) {
+  CAMLparam1(Global);
+  CAMLreturn(caml_copy_string(LLVMGetSection(Value_val(Global))));
 }
 
 /* string -> llvalue -> unit */
-value llvm_set_section(value Section, LLVMValueRef Global) {
-  LLVMSetSection(Global, String_val(Section));
-  return Val_unit;
+value llvm_set_section(value Section, value Global) {
+  CAMLparam2(Section, Global);
+  LLVMSetSection(Value_val(Global), String_val(Section));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> Visibility.t */
-value llvm_visibility(LLVMValueRef Global) {
-  return Val_int(LLVMGetVisibility(Global));
+value llvm_visibility(value Global) {
+  CAMLparam1(Global);
+  CAMLreturn(Val_int(LLVMGetVisibility(Value_val(Global))));
 }
 
 /* Visibility.t -> llvalue -> unit */
-value llvm_set_visibility(value Viz, LLVMValueRef Global) {
-  LLVMSetVisibility(Global, Int_val(Viz));
-  return Val_unit;
+value llvm_set_visibility(value Viz, value Global) {
+  CAMLparam2(Viz, Global);
+  LLVMSetVisibility(Value_val(Global), Int_val(Viz));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> DLLStorageClass.t */
-value llvm_dll_storage_class(LLVMValueRef Global) {
-  return Val_int(LLVMGetDLLStorageClass(Global));
+value llvm_dll_storage_class(value Global) {
+  CAMLparam1(Global);
+  CAMLreturn(Val_int(LLVMGetDLLStorageClass(Value_val(Global))));
 }
 
 /* DLLStorageClass.t -> llvalue -> unit */
-value llvm_set_dll_storage_class(value Viz, LLVMValueRef Global) {
-  LLVMSetDLLStorageClass(Global, Int_val(Viz));
-  return Val_unit;
+value llvm_set_dll_storage_class(value Viz, value Global) {
+  CAMLparam2(Viz, Global);
+  LLVMSetDLLStorageClass(Value_val(Global), Int_val(Viz));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> int */
-value llvm_alignment(LLVMValueRef Global) {
-  return Val_int(LLVMGetAlignment(Global));
+value llvm_alignment(value Global) {
+  CAMLparam1(Global);
+  CAMLreturn(Val_int(LLVMGetAlignment(Value_val(Global))));
 }
 
 /* int -> llvalue -> unit */
-value llvm_set_alignment(value Bytes, LLVMValueRef Global) {
-  LLVMSetAlignment(Global, Int_val(Bytes));
-  return Val_unit;
+value llvm_set_alignment(value Bytes, value Global) {
+  CAMLparam2(Bytes, Global);
+  LLVMSetAlignment(Value_val(Global), Int_val(Bytes));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> (llmdkind * llmetadata) array */
-value llvm_global_copy_all_metadata(LLVMValueRef Global) {
-  CAMLparam0();
+value llvm_global_copy_all_metadata(value Global) {
+  CAMLparam1(Global);
   CAMLlocal1(Array);
   size_t NumEntries;
   LLVMValueMetadataEntry *Entries =
-      LLVMGlobalCopyAllMetadata(Global, &NumEntries);
+      LLVMGlobalCopyAllMetadata(Value_val(Global), &NumEntries);
   Array = caml_alloc_tuple(NumEntries);
-  for (int i = 0; i < NumEntries; i++) {
+  for (unsigned I = 0; I < NumEntries; ++I) {
+    value Metadata = to_val(LLVMValueMetadataEntriesGetMetadata(Entries, I));
     value Pair = caml_alloc_small(2, 0);
-    Field(Pair, 0) = Val_int(LLVMValueMetadataEntriesGetKind(Entries, i));
-    Field(Pair, 1) = (value)LLVMValueMetadataEntriesGetMetadata(Entries, i);
-    Store_field(Array, i, Pair);
+    Field(Pair, 0) = Val_int(LLVMValueMetadataEntriesGetKind(Entries, I));
+    Field(Pair, 1) = Metadata;
+    Store_field(Array, I, Pair);
   }
   LLVMDisposeValueMetadataEntries(Entries);
   CAMLreturn(Array);
 }
 
 /*--... Operations on uses .................................................--*/
 
 /* llvalue -> lluse option */
-value llvm_use_begin(LLVMValueRef Val) {
-  return ptr_to_option(LLVMGetFirstUse(Val));
+value llvm_use_begin(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(ptr_to_option(LLVMGetFirstUse(Value_val(Val))));
 }
 
 /* lluse -> lluse option */
-value llvm_use_succ(LLVMUseRef U) { return ptr_to_option(LLVMGetNextUse(U)); }
+value llvm_use_succ(value U) {
+  CAMLparam1(U);
+  CAMLreturn(ptr_to_option(LLVMGetNextUse(Use_val(U))));
+}
 
 /* lluse -> llvalue */
-LLVMValueRef llvm_user(LLVMUseRef UR) { return LLVMGetUser(UR); }
+value llvm_user(value UR) {
+  CAMLparam1(UR);
+  CAMLreturn(to_val(LLVMGetUser(Use_val(UR))));
+}
 
 /* lluse -> llvalue */
-LLVMValueRef llvm_used_value(LLVMUseRef UR) { return LLVMGetUsedValue(UR); }
+value llvm_used_value(value UR) {
+  CAMLparam1(UR);
+  CAMLreturn(to_val(LLVMGetUsedValue(Use_val(UR))));
+}
 
 /*--... Operations on global variables .....................................--*/
 
-DEFINE_ITERATORS(global, Global, LLVMModuleRef, LLVMValueRef,
+DEFINE_ITERATORS(global, Global, Module_val, LLVMValueRef, Value_val,
                  LLVMGetGlobalParent)
 
 /* lltype -> string -> llmodule -> llvalue */
-LLVMValueRef llvm_declare_global(LLVMTypeRef Ty, value Name, LLVMModuleRef M) {
+value llvm_declare_global(value Ty, value Name, value M) {
+  CAMLparam3(Ty, Name, M);
   LLVMValueRef GlobalVar;
-  if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
-    if (LLVMGlobalGetValueType(GlobalVar) != Ty)
-      return LLVMConstBitCast(GlobalVar, LLVMPointerType(Ty, 0));
-    return GlobalVar;
+  if ((GlobalVar = LLVMGetNamedGlobal(Module_val(M), String_val(Name)))) {
+    if (LLVMGlobalGetValueType(GlobalVar) != Type_val(Ty)) {
+      CAMLreturn(to_val(
+          LLVMConstBitCast(GlobalVar, LLVMPointerType(Type_val(Ty), 0))));
     }
-  return LLVMAddGlobal(M, Ty, String_val(Name));
+    CAMLreturn(to_val(GlobalVar));
+  }
+  CAMLreturn(
+      to_val(LLVMAddGlobal(Module_val(M), Type_val(Ty), String_val(Name))));
 }
 
 /* lltype -> string -> int -> llmodule -> llvalue */
-LLVMValueRef llvm_declare_qualified_global(LLVMTypeRef Ty, value Name,
-                                           value AddressSpace,
-                                           LLVMModuleRef M) {
+value llvm_declare_qualified_global(value Ty, value Name, value AddressSpace,
+                                    value M) {
+  CAMLparam4(Ty, Name, AddressSpace, M);
   LLVMValueRef GlobalVar;
-  if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
-    if (LLVMGlobalGetValueType(GlobalVar) != Ty)
-      return LLVMConstBitCast(GlobalVar,
-                              LLVMPointerType(Ty, Int_val(AddressSpace)));
-    return GlobalVar;
+  if ((GlobalVar = LLVMGetNamedGlobal(Module_val(M), String_val(Name)))) {
+    if (LLVMGlobalGetValueType(GlobalVar) != Type_val(Ty)) {
+      CAMLreturn(to_val(LLVMConstBitCast(
+          GlobalVar, LLVMPointerType(Type_val(Ty), Int_val(AddressSpace)))));
     }
-  return LLVMAddGlobalInAddressSpace(M, Ty, String_val(Name),
-                                     Int_val(AddressSpace));
+    CAMLreturn(to_val(GlobalVar));
+  }
+  CAMLreturn(to_val(LLVMAddGlobalInAddressSpace(
+      Module_val(M), Type_val(Ty), String_val(Name), Int_val(AddressSpace))));
 }
 
 /* string -> llmodule -> llvalue option */
-value llvm_lookup_global(value Name, LLVMModuleRef M) {
-  return ptr_to_option(LLVMGetNamedGlobal(M, String_val(Name)));
+value llvm_lookup_global(value Name, value M) {
+  CAMLparam2(Name, M);
+  CAMLreturn(
+      ptr_to_option(LLVMGetNamedGlobal(Module_val(M), String_val(Name))));
 }
 
 /* string -> llvalue -> llmodule -> llvalue */
-LLVMValueRef llvm_define_global(value Name, LLVMValueRef Initializer,
-                                LLVMModuleRef M) {
-  LLVMValueRef GlobalVar =
-      LLVMAddGlobal(M, LLVMTypeOf(Initializer), String_val(Name));
-  LLVMSetInitializer(GlobalVar, Initializer);
-  return GlobalVar;
+value llvm_define_global(value Name, value Initializer, value M) {
+  CAMLparam3(Name, Initializer, M);
+  LLVMValueRef GlobalVar = LLVMAddGlobal(
+      Module_val(M), LLVMTypeOf(Value_val(Initializer)), String_val(Name));
+  LLVMSetInitializer(GlobalVar, Value_val(Initializer));
+  CAMLreturn(to_val(GlobalVar));
 }
 
 /* string -> llvalue -> int -> llmodule -> llvalue */
-LLVMValueRef llvm_define_qualified_global(value Name, LLVMValueRef Initializer,
-                                          value AddressSpace, LLVMModuleRef M) {
+value llvm_define_qualified_global(value Name, value Initializer,
+                                   value AddressSpace, value M) {
+  CAMLparam4(Name, Initializer, AddressSpace, M);
   LLVMValueRef GlobalVar = LLVMAddGlobalInAddressSpace(
-      M, LLVMTypeOf(Initializer), String_val(Name), Int_val(AddressSpace));
-  LLVMSetInitializer(GlobalVar, Initializer);
-  return GlobalVar;
+      Module_val(M), LLVMTypeOf(Value_val(Initializer)), String_val(Name),
+      Int_val(AddressSpace));
+  LLVMSetInitializer(GlobalVar, Value_val(Initializer));
+  CAMLreturn(to_val(GlobalVar));
 }
 
 /* llvalue -> unit */
-value llvm_delete_global(LLVMValueRef GlobalVar) {
-  LLVMDeleteGlobal(GlobalVar);
-  return Val_unit;
+value llvm_delete_global(value GlobalVar) {
+  CAMLparam1(GlobalVar);
+  LLVMDeleteGlobal(Value_val(GlobalVar));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> llvalue option */
-value llvm_global_initializer(LLVMValueRef GlobalVar) {
-  return ptr_to_option(LLVMGetInitializer(GlobalVar));
+value llvm_global_initializer(value GlobalVar) {
+  CAMLparam1(GlobalVar);
+  CAMLreturn(ptr_to_option(LLVMGetInitializer(Value_val(GlobalVar))));
 }
 
 /* llvalue -> llvalue -> unit */
-value llvm_set_initializer(LLVMValueRef ConstantVal, LLVMValueRef GlobalVar) {
-  LLVMSetInitializer(GlobalVar, ConstantVal);
-  return Val_unit;
+value llvm_set_initializer(value ConstantVal, value GlobalVar) {
+  CAMLparam2(ConstantVal, GlobalVar);
+  LLVMSetInitializer(Value_val(GlobalVar), Value_val(ConstantVal));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> unit */
-value llvm_remove_initializer(LLVMValueRef GlobalVar) {
-  LLVMSetInitializer(GlobalVar, NULL);
-  return Val_unit;
+value llvm_remove_initializer(value GlobalVar) {
+  CAMLparam1(GlobalVar);
+  LLVMSetInitializer(Value_val(GlobalVar), NULL);
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> bool */
-value llvm_is_thread_local(LLVMValueRef GlobalVar) {
-  return Val_bool(LLVMIsThreadLocal(GlobalVar));
+value llvm_is_thread_local(value GlobalVar) {
+  CAMLparam1(GlobalVar);
+  CAMLreturn(Val_bool(LLVMIsThreadLocal(Value_val(GlobalVar))));
 }
 
 /* bool -> llvalue -> unit */
-value llvm_set_thread_local(value IsThreadLocal, LLVMValueRef GlobalVar) {
-  LLVMSetThreadLocal(GlobalVar, Bool_val(IsThreadLocal));
-  return Val_unit;
+value llvm_set_thread_local(value IsThreadLocal, value GlobalVar) {
+  CAMLparam2(IsThreadLocal, GlobalVar);
+  LLVMSetThreadLocal(Value_val(GlobalVar), Bool_val(IsThreadLocal));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> ThreadLocalMode.t */
-value llvm_thread_local_mode(LLVMValueRef GlobalVar) {
-  return Val_int(LLVMGetThreadLocalMode(GlobalVar));
+value llvm_thread_local_mode(value GlobalVar) {
+  CAMLparam1(GlobalVar);
+  CAMLreturn(Val_int(LLVMGetThreadLocalMode(Value_val(GlobalVar))));
 }
 
 /* ThreadLocalMode.t -> llvalue -> unit */
-value llvm_set_thread_local_mode(value ThreadLocalMode,
-                                 LLVMValueRef GlobalVar) {
-  LLVMSetThreadLocalMode(GlobalVar, Int_val(ThreadLocalMode));
-  return Val_unit;
+value llvm_set_thread_local_mode(value ThreadLocalMode, value GlobalVar) {
+  CAMLparam2(ThreadLocalMode, GlobalVar);
+  LLVMSetThreadLocalMode(Value_val(GlobalVar), Int_val(ThreadLocalMode));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> bool */
-value llvm_is_externally_initialized(LLVMValueRef GlobalVar) {
-  return Val_bool(LLVMIsExternallyInitialized(GlobalVar));
+value llvm_is_externally_initialized(value GlobalVar) {
+  CAMLparam1(GlobalVar);
+  CAMLreturn(Val_bool(LLVMIsExternallyInitialized(Value_val(GlobalVar))));
 }
 
 /* bool -> llvalue -> unit */
 value llvm_set_externally_initialized(value IsExternallyInitialized,
-                                      LLVMValueRef GlobalVar) {
-  LLVMSetExternallyInitialized(GlobalVar, Bool_val(IsExternallyInitialized));
-  return Val_unit;
+                                      value GlobalVar) {
+  CAMLparam2(IsExternallyInitialized, GlobalVar);
+  LLVMSetExternallyInitialized(Value_val(GlobalVar),
+                               Bool_val(IsExternallyInitialized));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> bool */
-value llvm_is_global_constant(LLVMValueRef GlobalVar) {
-  return Val_bool(LLVMIsGlobalConstant(GlobalVar));
+value llvm_is_global_constant(value GlobalVar) {
+  CAMLparam1(GlobalVar);
+  CAMLreturn(Val_bool(LLVMIsGlobalConstant(Value_val(GlobalVar))));
 }
 
 /* bool -> llvalue -> unit */
-value llvm_set_global_constant(value Flag, LLVMValueRef GlobalVar) {
-  LLVMSetGlobalConstant(GlobalVar, Bool_val(Flag));
-  return Val_unit;
+value llvm_set_global_constant(value Flag, value GlobalVar) {
+  CAMLparam2(Flag, GlobalVar);
+  LLVMSetGlobalConstant(Value_val(GlobalVar), Bool_val(Flag));
+  CAMLreturn(Val_unit);
 }
 
 /*--... Operations on aliases ..............................................--*/
 
-LLVMValueRef llvm_add_alias(LLVMModuleRef M, LLVMTypeRef ValueTy,
-                            value AddrSpace, LLVMValueRef Aliasee, value Name) {
-  return LLVMAddAlias2(M, ValueTy, Int_val(AddrSpace), Aliasee,
-                       String_val(Name));
+/* llmodule -> lltype -> int -> llvalue -> string -> llvalue */
+value llvm_add_alias(value M, value ValueTy, value AddrSpace, value Aliasee,
+                     value Name) {
+  CAMLparam5(M, ValueTy, AddrSpace, Aliasee, Name);
+  CAMLreturn(
+      to_val(LLVMAddAlias2(Module_val(M), Type_val(ValueTy), Int_val(AddrSpace),
+                           Value_val(Aliasee), String_val(Name))));
 }
 
 /*--... Operations on functions ............................................--*/
 
-DEFINE_ITERATORS(function, Function, LLVMModuleRef, LLVMValueRef,
+DEFINE_ITERATORS(function, Function, Module_val, LLVMValueRef, Value_val,
                  LLVMGetGlobalParent)
 
 /* string -> lltype -> llmodule -> llvalue */
-LLVMValueRef llvm_declare_function(value Name, LLVMTypeRef Ty,
-                                   LLVMModuleRef M) {
+value llvm_declare_function(value Name, value Ty, value M) {
+  CAMLparam3(Name, Ty, M);
   LLVMValueRef Fn;
-  if ((Fn = LLVMGetNamedFunction(M, String_val(Name)))) {
-    if (LLVMGlobalGetValueType(Fn) != Ty)
-      return LLVMConstBitCast(Fn, LLVMPointerType(Ty, 0));
-    return Fn;
+  if ((Fn = LLVMGetNamedFunction(Module_val(M), String_val(Name)))) {
+    if (LLVMGlobalGetValueType(Fn) != Type_val(Ty)) {
+      CAMLreturn(
+          to_val(LLVMConstBitCast(Fn, LLVMPointerType(Type_val(Ty), 0))));
+    }
+    CAMLreturn(to_val(Fn));
   }
-  return LLVMAddFunction(M, String_val(Name), Ty);
+  CAMLreturn(
+      to_val(LLVMAddFunction(Module_val(M), String_val(Name), Type_val(Ty))));
 }
 
 /* string -> llmodule -> llvalue option */
-value llvm_lookup_function(value Name, LLVMModuleRef M) {
-  return ptr_to_option(LLVMGetNamedFunction(M, String_val(Name)));
+value llvm_lookup_function(value Name, value M) {
+  CAMLparam2(Name, M);
+  CAMLreturn(
+      ptr_to_option(LLVMGetNamedFunction(Module_val(M), String_val(Name))));
 }
 
 /* string -> lltype -> llmodule -> llvalue */
-LLVMValueRef llvm_define_function(value Name, LLVMTypeRef Ty, LLVMModuleRef M) {
-  LLVMValueRef Fn = LLVMAddFunction(M, String_val(Name), Ty);
-  LLVMAppendBasicBlockInContext(LLVMGetTypeContext(Ty), Fn, "entry");
-  return Fn;
+value llvm_define_function(value Name, value Ty, value M) {
+  CAMLparam3(Name, Ty, M);
+  LLVMValueRef Fn =
+      LLVMAddFunction(Module_val(M), String_val(Name), Type_val(Ty));
+  LLVMAppendBasicBlockInContext(LLVMGetTypeContext(Type_val(Ty)), Fn, "entry");
+  CAMLreturn(to_val(Fn));
 }
 
 /* llvalue -> unit */
-value llvm_delete_function(LLVMValueRef Fn) {
-  LLVMDeleteFunction(Fn);
-  return Val_unit;
+value llvm_delete_function(value Fn) {
+  CAMLparam1(Fn);
+  LLVMDeleteFunction(Value_val(Fn));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> bool */
-value llvm_is_intrinsic(LLVMValueRef Fn) {
-  return Val_bool(LLVMGetIntrinsicID(Fn));
+value llvm_is_intrinsic(value Fn) {
+  CAMLparam1(Fn);
+  CAMLreturn(Val_bool(LLVMGetIntrinsicID(Value_val(Fn))));
 }
 
 /* llvalue -> int */
-value llvm_function_call_conv(LLVMValueRef Fn) {
-  return Val_int(LLVMGetFunctionCallConv(Fn));
+value llvm_function_call_conv(value Fn) {
+  CAMLparam1(Fn);
+  CAMLreturn(Val_int(LLVMGetFunctionCallConv(Value_val(Fn))));
 }
 
 /* int -> llvalue -> unit */
-value llvm_set_function_call_conv(value Id, LLVMValueRef Fn) {
-  LLVMSetFunctionCallConv(Fn, Int_val(Id));
-  return Val_unit;
+value llvm_set_function_call_conv(value Id, value Fn) {
+  CAMLparam1(Fn);
+  LLVMSetFunctionCallConv(Value_val(Fn), Int_val(Id));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> string option */
-value llvm_gc(LLVMValueRef Fn) {
-  const char *GC = LLVMGetGC(Fn);
-  if (!GC)
-    return Val_none;
-  return caml_alloc_some(caml_copy_string(GC));
+value llvm_gc(value Fn) {
+  CAMLparam1(Fn);
+  const char *GC = LLVMGetGC(Value_val(Fn));
+  if (!GC) {
+    CAMLreturn(Val_none);
+  }
+  CAMLreturn(caml_alloc_some(caml_copy_string(GC)));
 }
 
 /* string option -> llvalue -> unit */
-value llvm_set_gc(value GC, LLVMValueRef Fn) {
-  LLVMSetGC(Fn, GC == Val_none ? 0 : String_val(Field(GC, 0)));
-  return Val_unit;
+value llvm_set_gc(value GC, value Fn) {
+  CAMLparam2(GC, Fn);
+  LLVMSetGC(Value_val(Fn), GC == Val_none ? 0 : String_val(Field(GC, 0)));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> llattribute -> int -> unit */
-value llvm_add_function_attr(LLVMValueRef F, LLVMAttributeRef A, value Index) {
-  LLVMAddAttributeAtIndex(F, Int_val(Index), A);
-  return Val_unit;
+value llvm_add_function_attr(value F, value A, value Index) {
+  CAMLparam3(F, A, Index);
+  LLVMAddAttributeAtIndex(Value_val(F), Int_val(Index), Attribute_val(A));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> int -> llattribute array */
-value llvm_function_attrs(LLVMValueRef F, value Index) {
-  unsigned Length = LLVMGetAttributeCountAtIndex(F, Int_val(Index));
-  value Array = caml_alloc_tuple_uninit(Length);
-  LLVMGetAttributesAtIndex(F, Int_val(Index),
-                           (LLVMAttributeRef *)Op_val(Array));
-  return Array;
+value llvm_function_attrs(value F, value Index) {
+  CAMLparam2(F, Index);
+  CAMLlocal1(Array);
+  unsigned Length = LLVMGetAttributeCountAtIndex(Value_val(F), Int_val(Index));
+  Array = caml_alloc_tuple(Length);
+  LLVMAttributeRef *Temp = malloc(sizeof(LLVMAttributeRef) * Length);
+  LLVMGetAttributesAtIndex(Value_val(F), Int_val(Index), Temp);
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(Array, I, to_val(Temp[I]));
+  }
+  free(Temp);
+  CAMLreturn(Array);
 }
 
 /* llvalue -> llattrkind -> int -> unit */
-value llvm_remove_enum_function_attr(LLVMValueRef F, value Kind, value Index) {
-  LLVMRemoveEnumAttributeAtIndex(F, Int_val(Index), Int_val(Kind));
-  return Val_unit;
+value llvm_remove_enum_function_attr(value F, value Kind, value Index) {
+  CAMLparam3(F, Kind, Index);
+  LLVMRemoveEnumAttributeAtIndex(Value_val(F), Int_val(Index), Int_val(Kind));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> string -> int -> unit */
-value llvm_remove_string_function_attr(LLVMValueRef F, value Kind,
-                                       value Index) {
-  LLVMRemoveStringAttributeAtIndex(F, Int_val(Index), String_val(Kind),
-                                   caml_string_length(Kind));
-  return Val_unit;
+value llvm_remove_string_function_attr(value F, value Kind, value Index) {
+  CAMLparam3(F, Kind, Index);
+  LLVMRemoveStringAttributeAtIndex(Value_val(F), Int_val(Index),
+                                   String_val(Kind), caml_string_length(Kind));
+  CAMLreturn(Val_unit);
 }
 
 /*--... Operations on parameters ...........................................--*/
 
-DEFINE_ITERATORS(param, Param, LLVMValueRef, LLVMValueRef, LLVMGetParamParent)
+DEFINE_ITERATORS(param, Param, Value_val, LLVMValueRef, Value_val,
+                 LLVMGetParamParent)
 
 /* llvalue -> int -> llvalue */
-LLVMValueRef llvm_param(LLVMValueRef Fn, value Index) {
-  return LLVMGetParam(Fn, Int_val(Index));
+value llvm_param(value Fn, value Index) {
+  CAMLparam2(Fn, Index);
+  CAMLreturn(to_val(LLVMGetParam(Value_val(Fn), Int_val(Index))));
+}
+
+/* llvalue -> llvalue array */
+value llvm_params(value Fn) {
+  CAMLparam1(Fn);
+  CAMLlocal1(Params);
+  unsigned Length = LLVMCountParams(Value_val(Fn));
+  LLVMValueRef *Temp = malloc(sizeof(LLVMValueRef) * Length);
+  Params = caml_alloc_tuple(Length);
+  LLVMGetParams(Value_val(Fn), Temp);
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(Params, I, to_val(Temp[I]));
+  }
+  free(Temp);
+  CAMLreturn(Params);
 }
 
 /* llvalue -> llvalue */
-value llvm_params(LLVMValueRef Fn) {
-  value Params = caml_alloc_tuple_uninit(LLVMCountParams(Fn));
-  LLVMGetParams(Fn, (LLVMValueRef *)Op_val(Params));
-  return Params;
+value llvm_param_parent(value Value) {
+  CAMLparam1(Value);
+  LLVMValueRef Parent = LLVMGetParamParent(Value_val(Value));
+  CAMLreturn(to_val(Parent));
 }
 
 /*--... Operations on basic blocks .........................................--*/
 
-DEFINE_ITERATORS(block, BasicBlock, LLVMValueRef, LLVMBasicBlockRef,
-                 LLVMGetBasicBlockParent)
+/* llbasicblock -> llvalue */
+value llvm_value_of_block(value BB) {
+  CAMLparam1(BB);
+  CAMLreturn(to_val(LLVMBasicBlockAsValue(BasicBlock_val(BB))));
+}
+
+/* llvalue -> bool */
+value llvm_value_is_block(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(Val_bool(LLVMValueIsBasicBlock(Value_val(Val))));
+}
 
-/* llbasicblock -> llvalue option */
-value llvm_block_terminator(LLVMBasicBlockRef Block) {
-  return ptr_to_option(LLVMGetBasicBlockTerminator(Block));
+/* llbasicblock -> llvalue */
+value llvm_block_of_value(value Val) {
+  CAMLparam1(Val);
+  CAMLreturn(to_val(LLVMValueAsBasicBlock(Value_val(Val))));
+}
+
+/* llbasicblock -> llvalue */
+value llvm_block_parent(value BB) {
+  CAMLparam1(BB);
+  CAMLreturn(to_val(LLVMGetBasicBlockParent(BasicBlock_val(BB))));
 }
 
 /* llvalue -> llbasicblock array */
-value llvm_basic_blocks(LLVMValueRef Fn) {
-  value MLArray = caml_alloc_tuple_uninit(LLVMCountBasicBlocks(Fn));
-  LLVMGetBasicBlocks(Fn, (LLVMBasicBlockRef *)Op_val(MLArray));
-  return MLArray;
+value llvm_basic_blocks(value Fn) {
+  CAMLparam1(Fn);
+  CAMLlocal1(MLArray);
+  unsigned Length = LLVMCountBasicBlocks(Value_val(Fn));
+  LLVMBasicBlockRef *Temp = malloc(sizeof(LLVMBasicBlockRef) * Length);
+  MLArray = caml_alloc_tuple(Length);
+  LLVMGetBasicBlocks(Value_val(Fn), Temp);
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(MLArray, I, to_val(Temp[I]));
+  }
+  free(Temp);
+  CAMLreturn(MLArray);
+}
+
+/* llvalue -> llbasicblock */
+value llvm_entry_block(value Val) {
+  CAMLparam1(Val);
+  LLVMBasicBlockRef BB = LLVMGetEntryBasicBlock(Value_val(Val));
+  CAMLreturn(to_val(BB));
+}
+
+DEFINE_ITERATORS(block, BasicBlock, Value_val, LLVMBasicBlockRef,
+                 BasicBlock_val, LLVMGetBasicBlockParent)
+
+/* llbasicblock -> llvalue option */
+value llvm_block_terminator(value Block) {
+  CAMLparam1(Block);
+  CAMLreturn(ptr_to_option(LLVMGetBasicBlockTerminator(BasicBlock_val(Block))));
 }
 
 /* llbasicblock -> unit */
-value llvm_delete_block(LLVMBasicBlockRef BB) {
-  LLVMDeleteBasicBlock(BB);
-  return Val_unit;
+value llvm_delete_block(value BB) {
+  CAMLparam1(BB);
+  LLVMDeleteBasicBlock(BasicBlock_val(BB));
+  CAMLreturn(Val_unit);
 }
 
 /* llbasicblock -> unit */
-value llvm_remove_block(LLVMBasicBlockRef BB) {
-  LLVMRemoveBasicBlockFromParent(BB);
-  return Val_unit;
+value llvm_remove_block(value BB) {
+  CAMLparam1(BB);
+  LLVMRemoveBasicBlockFromParent(BasicBlock_val(BB));
+  CAMLreturn(Val_unit);
 }
 
 /* llbasicblock -> llbasicblock -> unit */
-value llvm_move_block_before(LLVMBasicBlockRef Pos, LLVMBasicBlockRef BB) {
-  LLVMMoveBasicBlockBefore(BB, Pos);
-  return Val_unit;
+value llvm_move_block_before(value Pos, value BB) {
+  CAMLparam2(Pos, BB);
+  LLVMMoveBasicBlockBefore(BasicBlock_val(BB), BasicBlock_val(Pos));
+  CAMLreturn(Val_unit);
 }
 
 /* llbasicblock -> llbasicblock -> unit */
-value llvm_move_block_after(LLVMBasicBlockRef Pos, LLVMBasicBlockRef BB) {
-  LLVMMoveBasicBlockAfter(BB, Pos);
-  return Val_unit;
+value llvm_move_block_after(value Pos, value BB) {
+  CAMLparam2(Pos, BB);
+  LLVMMoveBasicBlockAfter(BasicBlock_val(BB), BasicBlock_val(Pos));
+  CAMLreturn(Val_unit);
 }
 
 /* string -> llvalue -> llbasicblock */
-LLVMBasicBlockRef llvm_append_block(LLVMContextRef Context, value Name,
-                                    LLVMValueRef Fn) {
-  return LLVMAppendBasicBlockInContext(Context, Fn, String_val(Name));
-}
-
-/* string -> llbasicblock -> llbasicblock */
-LLVMBasicBlockRef llvm_insert_block(LLVMContextRef Context, value Name,
-                                    LLVMBasicBlockRef BB) {
-  return LLVMInsertBasicBlockInContext(Context, BB, String_val(Name));
+value llvm_append_block(value Context, value Name, value Fn) {
+  CAMLparam3(Context, Name, Fn);
+  CAMLreturn(to_val(LLVMAppendBasicBlockInContext(
+      Context_val(Context), Value_val(Fn), String_val(Name))));
 }
 
-/* llvalue -> bool */
-value llvm_value_is_block(LLVMValueRef Val) {
-  return Val_bool(LLVMValueIsBasicBlock(Val));
+/* llcontext -> string -> llbasicblock -> llbasicblock */
+value llvm_insert_block(value Context, value Name, value BB) {
+  CAMLparam3(Context, Name, BB);
+  CAMLreturn(to_val(LLVMInsertBasicBlockInContext(
+      Context_val(Context), BasicBlock_val(BB), String_val(Name))));
 }
 
 /*--... Operations on instructions .........................................--*/
 
-DEFINE_ITERATORS(instr, Instruction, LLVMBasicBlockRef, LLVMValueRef,
+/* llvalue -> llbasicblock */
+value llvm_instr_parent(value Inst) {
+  CAMLparam1(Inst);
+  LLVMBasicBlockRef BB = LLVMGetInstructionParent(Value_val(Inst));
+  CAMLreturn(to_val(BB));
+}
+
+DEFINE_ITERATORS(instr, Instruction, BasicBlock_val, LLVMValueRef, Value_val,
                  LLVMGetInstructionParent)
 
 /* llvalue -> Opcode.t */
-value llvm_instr_get_opcode(LLVMValueRef Inst) {
+value llvm_instr_get_opcode(value Inst) {
+  CAMLparam1(Inst);
   LLVMOpcode o;
-  if (!LLVMIsAInstruction(Inst))
-    failwith("Not an instruction");
-  o = LLVMGetInstructionOpcode(Inst);
+  if (!LLVMIsAInstruction(Value_val(Inst)))
+    caml_failwith("Not an instruction");
+  o = LLVMGetInstructionOpcode(Value_val(Inst));
   assert(o <= LLVMFreeze);
-  return Val_int(o);
+  CAMLreturn(Val_int(o));
 }
 
 /* llvalue -> ICmp.t option */
-value llvm_instr_icmp_predicate(LLVMValueRef Val) {
-  int x = LLVMGetICmpPredicate(Val);
-  if (!x)
-    return Val_none;
-  return caml_alloc_some(Val_int(x - LLVMIntEQ));
+value llvm_instr_icmp_predicate(value Val) {
+  CAMLparam1(Val);
+  int x = LLVMGetICmpPredicate(Value_val(Val));
+  if (!x) {
+    CAMLreturn(Val_none);
+  }
+  CAMLreturn(caml_alloc_some(Val_int(x - LLVMIntEQ)));
 }
 
 /* llvalue -> FCmp.t option */
-value llvm_instr_fcmp_predicate(LLVMValueRef Val) {
-  int x = LLVMGetFCmpPredicate(Val);
-  if (!x)
-    return Val_none;
-  return caml_alloc_some(Val_int(x - LLVMRealPredicateFalse));
+value llvm_instr_fcmp_predicate(value Val) {
+  CAMLparam1(Val);
+  int x = LLVMGetFCmpPredicate(Value_val(Val));
+  if (!x) {
+    CAMLreturn(Val_none);
+  }
+  CAMLreturn(caml_alloc_some(Val_int(x - LLVMRealPredicateFalse)));
 }
 
 /* llvalue -> llvalue */
-LLVMValueRef llvm_instr_clone(LLVMValueRef Inst) {
-  if (!LLVMIsAInstruction(Inst))
-    failwith("Not an instruction");
-  return LLVMInstructionClone(Inst);
+value llvm_instr_clone(value Inst) {
+  CAMLparam1(Inst);
+  if (!LLVMIsAInstruction(Value_val(Inst)))
+    caml_failwith("Not an instruction");
+  CAMLreturn(to_val(LLVMInstructionClone(Value_val(Inst))));
 }
 
 /*--... Operations on call sites ...........................................--*/
 
 /* llvalue -> int */
-value llvm_instruction_call_conv(LLVMValueRef Inst) {
-  return Val_int(LLVMGetInstructionCallConv(Inst));
+value llvm_instruction_call_conv(value Inst) {
+  CAMLparam1(Inst);
+  CAMLreturn(Val_int(LLVMGetInstructionCallConv(Value_val(Inst))));
 }
 
 /* int -> llvalue -> unit */
-value llvm_set_instruction_call_conv(value CC, LLVMValueRef Inst) {
-  LLVMSetInstructionCallConv(Inst, Int_val(CC));
-  return Val_unit;
+value llvm_set_instruction_call_conv(value CC, value Inst) {
+  CAMLparam2(CC, Inst);
+  LLVMSetInstructionCallConv(Value_val(Inst), Int_val(CC));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> llattribute -> int -> unit */
-value llvm_add_call_site_attr(LLVMValueRef F, LLVMAttributeRef A, value Index) {
-  LLVMAddCallSiteAttribute(F, Int_val(Index), A);
-  return Val_unit;
+value llvm_add_call_site_attr(value F, value A, value Index) {
+  CAMLparam3(F, A, Index);
+  LLVMAddCallSiteAttribute(Value_val(F), Int_val(Index), Attribute_val(A));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> int -> llattribute array */
-value llvm_call_site_attrs(LLVMValueRef F, value Index) {
-  unsigned Count = LLVMGetCallSiteAttributeCount(F, Int_val(Index));
-  value Array = caml_alloc_tuple_uninit(Count);
-  LLVMGetCallSiteAttributes(F, Int_val(Index),
-                            (LLVMAttributeRef *)Op_val(Array));
-  return Array;
+value llvm_call_site_attrs(value F, value Index) {
+  CAMLparam2(F, Index);
+  CAMLlocal2(Temp, Array);
+  unsigned Length = LLVMGetCallSiteAttributeCount(Value_val(F), Int_val(Index));
+  Temp = caml_alloc(1, Abstract_tag);
+  Array = caml_alloc_tuple(Length);
+  LLVMGetCallSiteAttributes(Value_val(F), Int_val(Index),
+                            (LLVMAttributeRef *)Op_val(Temp));
+  for (unsigned I = 0; I < Length; ++I) {
+    Store_field(Array, I, to_val((LLVMAttributeRef)Field(Temp, I)));
+  }
+  CAMLreturn(Array);
 }
 
 /* llvalue -> llattrkind -> int -> unit */
-value llvm_remove_enum_call_site_attr(LLVMValueRef F, value Kind, value Index) {
-  LLVMRemoveCallSiteEnumAttribute(F, Int_val(Index), Int_val(Kind));
-  return Val_unit;
+value llvm_remove_enum_call_site_attr(value F, value Kind, value Index) {
+  CAMLparam3(F, Kind, Index);
+  LLVMRemoveCallSiteEnumAttribute(Value_val(F), Int_val(Index), Int_val(Kind));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> string -> int -> unit */
-value llvm_remove_string_call_site_attr(LLVMValueRef F, value Kind,
-                                        value Index) {
-  LLVMRemoveCallSiteStringAttribute(F, Int_val(Index), String_val(Kind),
-                                    caml_string_length(Kind));
-  return Val_unit;
+value llvm_remove_string_call_site_attr(value F, value Kind, value Index) {
+  CAMLparam3(F, Kind, Index);
+  LLVMRemoveCallSiteStringAttribute(Value_val(F), Int_val(Index),
+                                    String_val(Kind), caml_string_length(Kind));
+  CAMLreturn(Val_unit);
 }
 
 /*--... Operations on call instructions (only) .............................--*/
 
 /* llvalue -> int */
-value llvm_num_arg_operands(LLVMValueRef V) {
-  return Val_int(LLVMGetNumArgOperands(V));
+value llvm_num_arg_operands(value V) {
+  CAMLparam1(V);
+  CAMLreturn(Val_int(LLVMGetNumArgOperands(Value_val(V))));
 }
 
 /* llvalue -> bool */
-value llvm_is_tail_call(LLVMValueRef CallInst) {
-  return Val_bool(LLVMIsTailCall(CallInst));
+value llvm_is_tail_call(value CallInst) {
+  CAMLparam1(CallInst);
+  CAMLreturn(Val_bool(LLVMIsTailCall(Value_val(CallInst))));
 }
 
 /* bool -> llvalue -> unit */
-value llvm_set_tail_call(value IsTailCall, LLVMValueRef CallInst) {
-  LLVMSetTailCall(CallInst, Bool_val(IsTailCall));
-  return Val_unit;
+value llvm_set_tail_call(value IsTailCall, value CallInst) {
+  CAMLparam2(IsTailCall, CallInst);
+  LLVMSetTailCall(Value_val(CallInst), Bool_val(IsTailCall));
+  CAMLreturn(Val_unit);
+}
+
+/* llvalue -> llbasicblock */
+value llvm_get_normal_dest(value Val) {
+  CAMLparam1(Val);
+  LLVMBasicBlockRef BB = LLVMGetNormalDest(Value_val(Val));
+  CAMLreturn(to_val(BB));
+}
+
+/* llvalue -> llbasicblock */
+value llvm_get_unwind_dest(value Val) {
+  CAMLparam1(Val);
+  LLVMBasicBlockRef BB = LLVMGetUnwindDest(Value_val(Val));
+  CAMLreturn(to_val(BB));
 }
 
 /*--... Operations on load/store instructions (only)........................--*/
 
 /* llvalue -> bool */
-value llvm_is_volatile(LLVMValueRef MemoryInst) {
-  return Val_bool(LLVMGetVolatile(MemoryInst));
+value llvm_is_volatile(value MemoryInst) {
+  CAMLparam1(MemoryInst);
+  CAMLreturn(Val_bool(LLVMGetVolatile(Value_val(MemoryInst))));
 }
 
 /* bool -> llvalue -> unit */
-value llvm_set_volatile(value IsVolatile, LLVMValueRef MemoryInst) {
-  LLVMSetVolatile(MemoryInst, Bool_val(IsVolatile));
-  return Val_unit;
+value llvm_set_volatile(value IsVolatile, value MemoryInst) {
+  CAMLparam1(MemoryInst);
+  LLVMSetVolatile(Value_val(MemoryInst), Bool_val(IsVolatile));
+  CAMLreturn(Val_unit);
 }
 
 /*--.. Operations on terminators ...........................................--*/
 
 /* llvalue -> int -> llbasicblock */
-LLVMBasicBlockRef llvm_successor(LLVMValueRef V, value I) {
-  return LLVMGetSuccessor(V, Int_val(I));
+value llvm_successor(value V, value I) {
+  CAMLparam2(V, I);
+  CAMLreturn(to_val(LLVMGetSuccessor(Value_val(V), Int_val(I))));
 }
 
 /* llvalue -> int -> llvalue -> unit */
-value llvm_set_successor(LLVMValueRef U, value I, LLVMBasicBlockRef B) {
-  LLVMSetSuccessor(U, Int_val(I), B);
-  return Val_unit;
+value llvm_set_successor(value U, value I, value B) {
+  CAMLparam3(U, I, B);
+  LLVMSetSuccessor(Value_val(U), Int_val(I), BasicBlock_val(B));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> int */
-value llvm_num_successors(LLVMValueRef V) {
-  return Val_int(LLVMGetNumSuccessors(V));
+value llvm_num_successors(value V) {
+  CAMLparam1(V);
+  CAMLreturn(Val_int(LLVMGetNumSuccessors(Value_val(V))));
 }
 
 /*--.. Operations on branch ................................................--*/
 
 /* llvalue -> llvalue */
-LLVMValueRef llvm_condition(LLVMValueRef V) { return LLVMGetCondition(V); }
+value llvm_condition(value V) {
+  CAMLparam1(V);
+  CAMLreturn(to_val(LLVMGetCondition(Value_val(V))));
+}
 
 /* llvalue -> llvalue -> unit */
-value llvm_set_condition(LLVMValueRef B, LLVMValueRef C) {
-  LLVMSetCondition(B, C);
-  return Val_unit;
+value llvm_set_condition(value B, value C) {
+  CAMLparam2(B, C);
+  LLVMSetCondition(Value_val(B), Value_val(C));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> bool */
-value llvm_is_conditional(LLVMValueRef V) {
-  return Val_bool(LLVMIsConditional(V));
+value llvm_is_conditional(value V) {
+  CAMLparam1(V);
+  CAMLreturn(Val_bool(LLVMIsConditional(Value_val(V))));
 }
 
 /*--... Operations on phi nodes ............................................--*/
 
 /* (llvalue * llbasicblock) -> llvalue -> unit */
-value llvm_add_incoming(value Incoming, LLVMValueRef PhiNode) {
-  LLVMAddIncoming(PhiNode, (LLVMValueRef *)&Field(Incoming, 0),
-                  (LLVMBasicBlockRef *)&Field(Incoming, 1), 1);
-  return Val_unit;
+value llvm_add_incoming(value Incoming, value PhiNode) {
+  CAMLparam2(Incoming, PhiNode);
+  LLVMValueRef V = Value_val(Field(Incoming, 0));
+  LLVMBasicBlockRef BB = BasicBlock_val(Field(Incoming, 1));
+  LLVMAddIncoming(Value_val(PhiNode), &V, &BB, 1);
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> (llvalue * llbasicblock) list */
-value llvm_incoming(LLVMValueRef PhiNode) {
-  unsigned I;
-  CAMLparam0();
-  CAMLlocal2(Hd, Tl);
+value llvm_incoming(value Phi) {
+  CAMLparam1(Phi);
+  CAMLlocal5(Hd, Tl, V, BB, List);
+  LLVMValueRef PhiNode = Value_val(Phi);
 
   /* Build a tuple list of them. */
   Tl = Val_int(0);
-  for (I = LLVMCountIncoming(PhiNode); I != 0;) {
+  for (unsigned I = LLVMCountIncoming(PhiNode); I != 0;) {
+    V = to_val(LLVMGetIncomingValue(PhiNode, --I));
+    BB = to_val(LLVMGetIncomingBlock(PhiNode, I));
     Hd = caml_alloc_small(2, 0);
-    Field(Hd, 0) = (value)LLVMGetIncomingValue(PhiNode, --I);
-    Field(Hd, 1) = (value)LLVMGetIncomingBlock(PhiNode, I);
+    Field(Hd, 0) = V;
+    Field(Hd, 1) = BB;
 
-    value Tmp = caml_alloc_small(2, 0);
-    Field(Tmp, 0) = Hd;
-    Field(Tmp, 1) = Tl;
-    Tl = Tmp;
+    List = caml_alloc_small(2, 0);
+    Field(List, 0) = Hd;
+    Field(List, 1) = Tl;
+    Tl = List;
   }
 
   CAMLreturn(Tl);
 }
 
 /* llvalue -> unit */
-value llvm_delete_instruction(LLVMValueRef Instruction) {
-  LLVMInstructionEraseFromParent(Instruction);
-  return Val_unit;
+value llvm_delete_instruction(value Instruction) {
+  CAMLparam1(Instruction);
+  LLVMInstructionEraseFromParent(Value_val(Instruction));
+  CAMLreturn(Val_unit);
 }
 
 /*===-- Instruction builders ----------------------------------------------===*/
 
 #define Builder_val(v) (*(LLVMBuilderRef *)(Data_custom_val(v)))
 
 static void llvm_finalize_builder(value B) {
   LLVMDisposeBuilder(Builder_val(B));
 }
 
 static struct custom_operations builder_ops = {
     (char *)"Llvm.llbuilder",  llvm_finalize_builder,
     custom_compare_default,    custom_hash_default,
     custom_serialize_default,  custom_deserialize_default,
     custom_compare_ext_default};
 
 static value alloc_builder(LLVMBuilderRef B) {
-  value V = alloc_custom(&builder_ops, sizeof(LLVMBuilderRef), 0, 1);
+  value V = caml_alloc_custom(&builder_ops, sizeof(LLVMBuilderRef), 0, 1);
   Builder_val(V) = B;
   return V;
 }
 
 /* llcontext -> llbuilder */
-value llvm_builder(LLVMContextRef C) {
-  return alloc_builder(LLVMCreateBuilderInContext(C));
+value llvm_builder(value C) {
+  CAMLparam1(C);
+  CAMLreturn(alloc_builder(LLVMCreateBuilderInContext(Context_val(C))));
 }
 
 /* (llbasicblock, llvalue) llpos -> llbuilder -> unit */
 value llvm_position_builder(value Pos, value B) {
+  CAMLparam2(Pos, B);
   if (Tag_val(Pos) == 0) {
-    LLVMBasicBlockRef BB = (LLVMBasicBlockRef)Op_val(Field(Pos, 0));
+    LLVMBasicBlockRef BB = BasicBlock_val(Field(Pos, 0));
     LLVMPositionBuilderAtEnd(Builder_val(B), BB);
   } else {
-    LLVMValueRef I = (LLVMValueRef)Op_val(Field(Pos, 0));
+    LLVMValueRef I = Value_val(Field(Pos, 0));
     LLVMPositionBuilderBefore(Builder_val(B), I);
   }
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* llbuilder -> llbasicblock */
-LLVMBasicBlockRef llvm_insertion_block(value B) {
+value llvm_insertion_block(value B) {
+  CAMLparam1(B);
   LLVMBasicBlockRef InsertBlock = LLVMGetInsertBlock(Builder_val(B));
   if (!InsertBlock)
     caml_raise_not_found();
-  return InsertBlock;
+  CAMLreturn(to_val(InsertBlock));
 }
 
 /* llvalue -> string -> llbuilder -> unit */
-value llvm_insert_into_builder(LLVMValueRef I, value Name, value B) {
-  LLVMInsertIntoBuilderWithName(Builder_val(B), I, String_val(Name));
-  return Val_unit;
+value llvm_insert_into_builder(value I, value Name, value B) {
+  CAMLparam3(I, Name, B);
+  LLVMInsertIntoBuilderWithName(Builder_val(B), Value_val(I), String_val(Name));
+  CAMLreturn(Val_unit);
 }
 
 /*--... Metadata ...........................................................--*/
 
 /* llbuilder -> llvalue -> unit */
-value llvm_set_current_debug_location(value B, LLVMValueRef V) {
-  LLVMSetCurrentDebugLocation(Builder_val(B), V);
-  return Val_unit;
+value llvm_set_current_debug_location(value B, value V) {
+  CAMLparam2(B, V);
+  LLVMSetCurrentDebugLocation(Builder_val(B), Value_val(V));
+  CAMLreturn(Val_unit);
 }
 
 /* llbuilder -> unit */
 value llvm_clear_current_debug_location(value B) {
+  CAMLparam1(B);
   LLVMSetCurrentDebugLocation(Builder_val(B), NULL);
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* llbuilder -> llvalue option */
 value llvm_current_debug_location(value B) {
-  return ptr_to_option(LLVMGetCurrentDebugLocation(Builder_val(B)));
+  CAMLparam1(B);
+  CAMLreturn(ptr_to_option(LLVMGetCurrentDebugLocation(Builder_val(B))));
 }
 
 /* llbuilder -> llvalue -> unit */
-value llvm_set_inst_debug_location(value B, LLVMValueRef V) {
-  LLVMSetInstDebugLocation(Builder_val(B), V);
-  return Val_unit;
+value llvm_set_inst_debug_location(value B, value V) {
+  CAMLparam2(B, V);
+  LLVMSetInstDebugLocation(Builder_val(B), Value_val(V));
+  CAMLreturn(Val_unit);
 }
 
 /*--... Terminators ........................................................--*/
 
 /* llbuilder -> llvalue */
-LLVMValueRef llvm_build_ret_void(value B) {
-  return LLVMBuildRetVoid(Builder_val(B));
+value llvm_build_ret_void(value B) {
+  CAMLparam1(B);
+  CAMLreturn(to_val(LLVMBuildRetVoid(Builder_val(B))));
 }
 
 /* llvalue -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_ret(LLVMValueRef Val, value B) {
-  return LLVMBuildRet(Builder_val(B), Val);
+value llvm_build_ret(value Val, value B) {
+  CAMLparam2(Val, B);
+  CAMLreturn(to_val(LLVMBuildRet(Builder_val(B), Value_val(Val))));
 }
 
 /* llvalue array -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_aggregate_ret(value RetVals, value B) {
-  return LLVMBuildAggregateRet(Builder_val(B), (LLVMValueRef *)Op_val(RetVals),
-                               Wosize_val(RetVals));
+value llvm_build_aggregate_ret(value RetVals, value B) {
+  CAMLparam2(RetVals, B);
+  unsigned Length = Wosize_val(RetVals);
+  LLVMValueRef *Temp = alloc_temp(RetVals);
+  LLVMValueRef Value = LLVMBuildAggregateRet(Builder_val(B), Temp, Length);
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* llbasicblock -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_br(LLVMBasicBlockRef BB, value B) {
-  return LLVMBuildBr(Builder_val(B), BB);
+value llvm_build_br(value BB, value B) {
+  CAMLparam2(BB, B);
+  CAMLreturn(to_val(LLVMBuildBr(Builder_val(B), BasicBlock_val(BB))));
 }
 
 /* llvalue -> llbasicblock -> llbasicblock -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_cond_br(LLVMValueRef If, LLVMBasicBlockRef Then,
-                                LLVMBasicBlockRef Else, value B) {
-  return LLVMBuildCondBr(Builder_val(B), If, Then, Else);
+value llvm_build_cond_br(value If, value Then, value Else, value B) {
+  CAMLparam4(If, Then, Else, B);
+  CAMLreturn(
+      to_val(LLVMBuildCondBr(Builder_val(B), Value_val(If),
+                             BasicBlock_val(Then), BasicBlock_val(Else))));
 }
 
 /* llvalue -> llbasicblock -> int -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_switch(LLVMValueRef Of, LLVMBasicBlockRef Else,
-                               value EstimatedCount, value B) {
-  return LLVMBuildSwitch(Builder_val(B), Of, Else, Int_val(EstimatedCount));
+value llvm_build_switch(value Of, value Else, value EstimatedCount, value B) {
+  CAMLparam4(Of, Else, EstimatedCount, B);
+  CAMLreturn(
+      to_val(LLVMBuildSwitch(Builder_val(B), Value_val(Of),
+                             BasicBlock_val(Else), Int_val(EstimatedCount))));
 }
 
 /* lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_malloc(LLVMTypeRef Ty, value Name, value B) {
-  return LLVMBuildMalloc(Builder_val(B), Ty, String_val(Name));
+value llvm_build_malloc(value Ty, value Name, value B) {
+  CAMLparam3(Ty, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildMalloc(Builder_val(B), Type_val(Ty), String_val(Name))));
 }
 
 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_array_malloc(LLVMTypeRef Ty, LLVMValueRef Val,
-                                     value Name, value B) {
-  return LLVMBuildArrayMalloc(Builder_val(B), Ty, Val, String_val(Name));
+value llvm_build_array_malloc(value Ty, value Val, value Name, value B) {
+  CAMLparam4(Ty, Val, Name, B);
+  CAMLreturn(to_val(LLVMBuildArrayMalloc(Builder_val(B), Type_val(Ty),
+                                         Value_val(Val), String_val(Name))));
 }
 
 /* llvalue -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_free(LLVMValueRef P, value B) {
-  return LLVMBuildFree(Builder_val(B), P);
+value llvm_build_free(value P, value B) {
+  CAMLparam2(P, B);
+  CAMLreturn(to_val(LLVMBuildFree(Builder_val(B), Value_val(P))));
 }
 
 /* llvalue -> llvalue -> llbasicblock -> unit */
-value llvm_add_case(LLVMValueRef Switch, LLVMValueRef OnVal,
-                    LLVMBasicBlockRef Dest) {
-  LLVMAddCase(Switch, OnVal, Dest);
-  return Val_unit;
-}
-
-/* llvalue -> llbasicblock -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_indirect_br(LLVMValueRef Addr, value EstimatedDests,
-                                    value B) {
-  return LLVMBuildIndirectBr(Builder_val(B), Addr, EstimatedDests);
-}
-
-/* llvalue -> llvalue -> llbasicblock -> unit */
-value llvm_add_destination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) {
-  LLVMAddDestination(IndirectBr, Dest);
-  return Val_unit;
+value llvm_add_case(value Switch, value OnVal, value Dest) {
+  CAMLparam3(Switch, OnVal, Dest);
+  LLVMAddCase(Value_val(Switch), Value_val(OnVal), BasicBlock_val(Dest));
+  CAMLreturn(Val_unit);
+}
+
+/* llvalue -> llbasicblock */
+value llvm_switch_default_dest(value Val) {
+  CAMLparam1(Val);
+  LLVMBasicBlockRef BB = LLVMGetSwitchDefaultDest(Value_val(Val));
+  CAMLreturn(to_val(BB));
+}
+
+/* llvalue -> int -> llbuilder -> llvalue */
+value llvm_build_indirect_br(value Addr, value EstimatedDests, value B) {
+  CAMLparam3(Addr, EstimatedDests, B);
+  CAMLreturn(to_val(LLVMBuildIndirectBr(Builder_val(B), Value_val(Addr),
+                                        Int_val(EstimatedDests))));
+}
+
+/* llvalue -> llbasicblock -> unit */
+value llvm_add_destination(value IndirectBr, value Dest) {
+  CAMLparam2(IndirectBr, Dest);
+  LLVMAddDestination(Value_val(IndirectBr), BasicBlock_val(Dest));
+  CAMLreturn(Val_unit);
 }
 
 /* lltype -> llvalue -> llvalue array -> llbasicblock -> llbasicblock ->
    string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_invoke_nat(LLVMTypeRef FnTy, LLVMValueRef Fn,
-                                   value Args, LLVMBasicBlockRef Then,
-                                   LLVMBasicBlockRef Catch, value Name,
-                                   value B) {
-  return LLVMBuildInvoke2(Builder_val(B), FnTy, Fn,
-                          (LLVMValueRef *)Op_val(Args), Wosize_val(Args),
-                          Then, Catch, String_val(Name));
+value llvm_build_invoke_nat(value FnTy, value Fn, value Args, value Then,
+                            value Catch, value Name, value B) {
+  CAMLparam5(FnTy, Fn, Args, Then, Catch);
+  CAMLxparam2(Name, B);
+  unsigned Length = Wosize_val(Args);
+  LLVMValueRef *Temp = alloc_temp(Args);
+  LLVMValueRef Value = LLVMBuildInvoke2(
+      Builder_val(B), Type_val(FnTy), Value_val(Fn), Temp, Length,
+      BasicBlock_val(Then), BasicBlock_val(Catch), String_val(Name));
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* lltype -> llvalue -> llvalue array -> llbasicblock -> llbasicblock ->
    string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_invoke_bc(value Args[], int NumArgs) {
-  return llvm_build_invoke_nat((LLVMTypeRef)Args[0], (LLVMValueRef)Args[1],
-                               Args[2], (LLVMBasicBlockRef)Args[3],
-                               (LLVMBasicBlockRef)Args[4], Args[5], Args[6]);
+value llvm_build_invoke_bc(value Args[], int NumArgs) {
+  return llvm_build_invoke_nat(Args[0], Args[1], Args[2], Args[3], Args[4],
+                               Args[5], Args[6]);
 }
 
 /* lltype -> llvalue -> int -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_landingpad(LLVMTypeRef Ty, LLVMValueRef PersFn,
-                                   value NumClauses, value Name, value B) {
-  return LLVMBuildLandingPad(Builder_val(B), Ty, PersFn, Int_val(NumClauses),
-                             String_val(Name));
+value llvm_build_landingpad(value Ty, value PersFn, value NumClauses,
+                            value Name, value B) {
+  CAMLparam5(Ty, PersFn, NumClauses, Name, B);
+  CAMLreturn(to_val(LLVMBuildLandingPad(Builder_val(B), Type_val(Ty),
+                                        Value_val(PersFn), Int_val(NumClauses),
+                                        String_val(Name))));
 }
 
 /* llvalue -> llvalue -> unit */
-value llvm_add_clause(LLVMValueRef LandingPadInst, LLVMValueRef ClauseVal) {
-  LLVMAddClause(LandingPadInst, ClauseVal);
-  return Val_unit;
+value llvm_add_clause(value LandingPadInst, value ClauseVal) {
+  CAMLparam2(LandingPadInst, ClauseVal);
+  LLVMAddClause(Value_val(LandingPadInst), Value_val(ClauseVal));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> bool */
-value llvm_is_cleanup(LLVMValueRef LandingPadInst) {
-  return Val_bool(LLVMIsCleanup(LandingPadInst));
+value llvm_is_cleanup(value LandingPadInst) {
+  CAMLparam1(LandingPadInst);
+  CAMLreturn(Val_bool(LLVMIsCleanup(Value_val(LandingPadInst))));
 }
 
 /* llvalue -> bool -> unit */
-value llvm_set_cleanup(LLVMValueRef LandingPadInst, value flag) {
-  LLVMSetCleanup(LandingPadInst, Bool_val(flag));
-  return Val_unit;
+value llvm_set_cleanup(value LandingPadInst, value flag) {
+  CAMLparam2(LandingPadInst, flag);
+  LLVMSetCleanup(Value_val(LandingPadInst), Bool_val(flag));
+  CAMLreturn(Val_unit);
 }
 
 /* llvalue -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_resume(LLVMValueRef Exn, value B) {
-  return LLVMBuildResume(Builder_val(B), Exn);
+value llvm_build_resume(value Exn, value B) {
+  CAMLparam2(Exn, B);
+  CAMLreturn(to_val(LLVMBuildResume(Builder_val(B), Value_val(Exn))));
 }
 
 /* llbuilder -> llvalue */
-LLVMValueRef llvm_build_unreachable(value B) {
-  return LLVMBuildUnreachable(Builder_val(B));
+value llvm_build_unreachable(value B) {
+  CAMLparam1(B);
+  CAMLreturn(to_val(LLVMBuildUnreachable(Builder_val(B))));
 }
 
 /*--... Arithmetic .........................................................--*/
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_add(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                            value B) {
-  return LLVMBuildAdd(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_add(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildAdd(Builder_val(B), Value_val(LHS), Value_val(RHS),
+                                 String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_nsw_add(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                                value B) {
-  return LLVMBuildNSWAdd(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_nsw_add(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildNSWAdd(Builder_val(B), Value_val(LHS),
+                                    Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_nuw_add(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                                value B) {
-  return LLVMBuildNUWAdd(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_nuw_add(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildNUWAdd(Builder_val(B), Value_val(LHS),
+                                    Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fadd(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildFAdd(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_fadd(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildFAdd(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_sub(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                            value B) {
-  return LLVMBuildSub(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_sub(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildSub(Builder_val(B), Value_val(LHS), Value_val(RHS),
+                                 String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_nsw_sub(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                                value B) {
-  return LLVMBuildNSWSub(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_nsw_sub(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildNSWSub(Builder_val(B), Value_val(LHS),
+                                    Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_nuw_sub(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                                value B) {
-  return LLVMBuildNUWSub(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_nuw_sub(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildNUWSub(Builder_val(B), Value_val(LHS),
+                                    Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fsub(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildFSub(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_fsub(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildFSub(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_mul(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                            value B) {
-  return LLVMBuildMul(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_mul(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildMul(Builder_val(B), Value_val(LHS), Value_val(RHS),
+                                 String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_nsw_mul(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                                value B) {
-  return LLVMBuildNSWMul(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_nsw_mul(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildNSWMul(Builder_val(B), Value_val(LHS),
+                                    Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_nuw_mul(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                                value B) {
-  return LLVMBuildNUWMul(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_nuw_mul(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildNUWMul(Builder_val(B), Value_val(LHS),
+                                    Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fmul(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildFMul(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_fmul(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildFMul(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_udiv(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildUDiv(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_udiv(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildUDiv(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_sdiv(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildSDiv(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_sdiv(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildSDiv(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_exact_sdiv(LLVMValueRef LHS, LLVMValueRef RHS,
-                                   value Name, value B) {
-  return LLVMBuildExactSDiv(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_exact_sdiv(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildExactSDiv(Builder_val(B), Value_val(LHS),
+                                       Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fdiv(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildFDiv(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_fdiv(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildFDiv(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_urem(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildURem(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_urem(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildURem(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_srem(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildSRem(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_srem(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildSRem(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_frem(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildFRem(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_frem(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildFRem(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_shl(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                            value B) {
-  return LLVMBuildShl(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_shl(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildShl(Builder_val(B), Value_val(LHS), Value_val(RHS),
+                                 String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_lshr(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildLShr(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_lshr(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildLShr(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_ashr(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                             value B) {
-  return LLVMBuildAShr(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_ashr(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildAShr(Builder_val(B), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_and(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                            value B) {
-  return LLVMBuildAnd(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_and(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildAnd(Builder_val(B), Value_val(LHS), Value_val(RHS),
+                                 String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_or(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                           value B) {
-  return LLVMBuildOr(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_or(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildOr(Builder_val(B), Value_val(LHS), Value_val(RHS),
+                                String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_xor(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                            value B) {
-  return LLVMBuildXor(Builder_val(B), LHS, RHS, String_val(Name));
+value llvm_build_xor(value LHS, value RHS, value Name, value B) {
+  CAMLparam4(LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildXor(Builder_val(B), Value_val(LHS), Value_val(RHS),
+                                 String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_neg(LLVMValueRef X, value Name, value B) {
-  return LLVMBuildNeg(Builder_val(B), X, String_val(Name));
+value llvm_build_neg(value X, value Name, value B) {
+  CAMLparam3(X, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildNeg(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_nsw_neg(LLVMValueRef X, value Name, value B) {
-  return LLVMBuildNSWNeg(Builder_val(B), X, String_val(Name));
+value llvm_build_nsw_neg(value X, value Name, value B) {
+  CAMLparam3(X, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildNSWNeg(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_nuw_neg(LLVMValueRef X, value Name, value B) {
-  return LLVMBuildNUWNeg(Builder_val(B), X, String_val(Name));
+value llvm_build_nuw_neg(value X, value Name, value B) {
+  CAMLparam3(X, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildNUWNeg(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fneg(LLVMValueRef X, value Name, value B) {
-  return LLVMBuildFNeg(Builder_val(B), X, String_val(Name));
+value llvm_build_fneg(value X, value Name, value B) {
+  CAMLparam3(X, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildFNeg(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_not(LLVMValueRef X, value Name, value B) {
-  return LLVMBuildNot(Builder_val(B), X, String_val(Name));
+value llvm_build_not(value X, value Name, value B) {
+  CAMLparam3(X, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildNot(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /*--... Memory .............................................................--*/
 
 /* lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_alloca(LLVMTypeRef Ty, value Name, value B) {
-  return LLVMBuildAlloca(Builder_val(B), Ty, String_val(Name));
+value llvm_build_alloca(value Ty, value Name, value B) {
+  CAMLparam3(Ty, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildAlloca(Builder_val(B), Type_val(Ty), String_val(Name))));
 }
 
 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_array_alloca(LLVMTypeRef Ty, LLVMValueRef Size,
-                                     value Name, value B) {
-  return LLVMBuildArrayAlloca(Builder_val(B), Ty, Size, String_val(Name));
+value llvm_build_array_alloca(value Ty, value Size, value Name, value B) {
+  CAMLparam4(Ty, Size, Name, B);
+  CAMLreturn(to_val(LLVMBuildArrayAlloca(Builder_val(B), Type_val(Ty),
+                                         Value_val(Size), String_val(Name))));
 }
 
 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_load(LLVMTypeRef Ty, LLVMValueRef Pointer, value Name,
-                             value B) {
-  return LLVMBuildLoad2(Builder_val(B), Ty, Pointer, String_val(Name));
+value llvm_build_load(value Ty, value Pointer, value Name, value B) {
+  CAMLparam4(Ty, Pointer, Name, B);
+  CAMLreturn(to_val(LLVMBuildLoad2(Builder_val(B), Type_val(Ty),
+                                   Value_val(Pointer), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_store(LLVMValueRef Value, LLVMValueRef Pointer,
-                              value B) {
-  return LLVMBuildStore(Builder_val(B), Value, Pointer);
+value llvm_build_store(value Value, value Pointer, value B) {
+  CAMLparam3(Value, Pointer, B);
+  CAMLreturn(to_val(
+      LLVMBuildStore(Builder_val(B), Value_val(Value), Value_val(Pointer))));
 }
 
 /* AtomicRMWBinOp.t -> llvalue -> llvalue -> AtomicOrdering.t ->
-   bool -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_atomicrmw_native(value BinOp, LLVMValueRef Ptr,
-                                         LLVMValueRef Val, value Ord, value ST,
-                                         value Name, value B) {
+   bool -> string -> llbuilder -> llvalue */
+value llvm_build_atomicrmw_native(value BinOp, value Ptr, value Val, value Ord,
+                                  value ST, value Name, value B) {
+  CAMLparam5(BinOp, Ptr, Val, Ord, ST);
+  CAMLxparam2(Name, B);
   LLVMValueRef Instr;
-  Instr = LLVMBuildAtomicRMW(Builder_val(B), Int_val(BinOp), Ptr, Val,
-                             Int_val(Ord), Bool_val(ST));
+  Instr = LLVMBuildAtomicRMW(Builder_val(B), Int_val(BinOp), Value_val(Ptr),
+                             Value_val(Val), Int_val(Ord), Bool_val(ST));
   LLVMSetValueName(Instr, String_val(Name));
-  return Instr;
+  CAMLreturn(to_val(Instr));
 }
 
-LLVMValueRef llvm_build_atomicrmw_bytecode(value *argv, int argn) {
-  return llvm_build_atomicrmw_native(argv[0], (LLVMValueRef)argv[1],
-                                     (LLVMValueRef)argv[2], argv[3], argv[4],
-                                     argv[5], argv[6]);
+value llvm_build_atomicrmw_bytecode(value *argv, int argn) {
+  return llvm_build_atomicrmw_native(argv[0], argv[1], argv[2], argv[3],
+                                     argv[4], argv[5], argv[6]);
 }
 
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_gep(LLVMTypeRef Ty, LLVMValueRef Pointer, value Indices,
-                            value Name, value B) {
-  return LLVMBuildGEP2(Builder_val(B), Ty, Pointer,
-                       (LLVMValueRef *)Op_val(Indices), Wosize_val(Indices),
-                       String_val(Name));
+value llvm_build_gep(value Ty, value Pointer, value Indices, value Name,
+                     value B) {
+  CAMLparam5(Ty, Pointer, Indices, Name, B);
+  unsigned Length = Wosize_val(Indices);
+  LLVMValueRef *Temp = alloc_temp(Indices);
+  LLVMValueRef Value =
+      LLVMBuildGEP2(Builder_val(B), Type_val(Ty), Value_val(Pointer), Temp,
+                    Length, String_val(Name));
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_in_bounds_gep(LLVMTypeRef Ty, LLVMValueRef Pointer,
-                                      value Indices, value Name, value B) {
-  return LLVMBuildInBoundsGEP2(Builder_val(B), Ty, Pointer,
-                               (LLVMValueRef *)Op_val(Indices),
-                               Wosize_val(Indices), String_val(Name));
+value llvm_build_in_bounds_gep(value Ty, value Pointer, value Indices,
+                               value Name, value B) {
+  CAMLparam5(Ty, Pointer, Indices, Name, B);
+  unsigned Length = Wosize_val(Indices);
+  LLVMValueRef *Temp = alloc_temp(Indices);
+  LLVMValueRef Value =
+      LLVMBuildInBoundsGEP2(Builder_val(B), Type_val(Ty), Value_val(Pointer),
+                            Temp, Length, String_val(Name));
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* lltype -> llvalue -> int -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_struct_gep(LLVMTypeRef Ty, LLVMValueRef Pointer,
-                                   value Index, value Name, value B) {
-  return LLVMBuildStructGEP2(Builder_val(B), Ty, Pointer, Int_val(Index),
-                             String_val(Name));
+value llvm_build_struct_gep(value Ty, value Pointer, value Index, value Name,
+                            value B) {
+  CAMLparam5(Ty, Pointer, Index, Name, B);
+  CAMLreturn(to_val(LLVMBuildStructGEP2(Builder_val(B), Type_val(Ty),
+                                        Value_val(Pointer), Int_val(Index),
+                                        String_val(Name))));
 }
 
 /* string -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_global_string(value Str, value Name, value B) {
-  return LLVMBuildGlobalString(Builder_val(B), String_val(Str),
-                               String_val(Name));
+value llvm_build_global_string(value Str, value Name, value B) {
+  CAMLparam3(Str, Name, B);
+  CAMLreturn(to_val(LLVMBuildGlobalString(Builder_val(B), String_val(Str),
+                                          String_val(Name))));
 }
 
 /* string -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_global_stringptr(value Str, value Name, value B) {
-  return LLVMBuildGlobalStringPtr(Builder_val(B), String_val(Str),
-                                  String_val(Name));
+value llvm_build_global_stringptr(value Str, value Name, value B) {
+  CAMLparam3(Str, Name, B);
+  CAMLreturn(to_val(LLVMBuildGlobalStringPtr(Builder_val(B), String_val(Str),
+                                             String_val(Name))));
 }
 
 /*--... Casts ..............................................................--*/
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_trunc(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                              value B) {
-  return LLVMBuildTrunc(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_trunc(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildTrunc(Builder_val(B), Value_val(X), Type_val(Ty),
+                                   String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_zext(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                             value B) {
-  return LLVMBuildZExt(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_zext(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildZExt(Builder_val(B), Value_val(X), Type_val(Ty),
+                                  String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_sext(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                             value B) {
-  return LLVMBuildSExt(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_sext(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildSExt(Builder_val(B), Value_val(X), Type_val(Ty),
+                                  String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fptoui(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                               value B) {
-  return LLVMBuildFPToUI(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_fptoui(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildFPToUI(Builder_val(B), Value_val(X), Type_val(Ty),
+                                    String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fptosi(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                               value B) {
-  return LLVMBuildFPToSI(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_fptosi(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildFPToSI(Builder_val(B), Value_val(X), Type_val(Ty),
+                                    String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_uitofp(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                               value B) {
-  return LLVMBuildUIToFP(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_uitofp(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildUIToFP(Builder_val(B), Value_val(X), Type_val(Ty),
+                                    String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_sitofp(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                               value B) {
-  return LLVMBuildSIToFP(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_sitofp(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildSIToFP(Builder_val(B), Value_val(X), Type_val(Ty),
+                                    String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fptrunc(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                                value B) {
-  return LLVMBuildFPTrunc(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_fptrunc(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildFPTrunc(Builder_val(B), Value_val(X), Type_val(Ty),
+                                     String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fpext(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                              value B) {
-  return LLVMBuildFPExt(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_fpext(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildFPExt(Builder_val(B), Value_val(X), Type_val(Ty),
+                                   String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_prttoint(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                                 value B) {
-  return LLVMBuildPtrToInt(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_prttoint(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildPtrToInt(Builder_val(B), Value_val(X),
+                                      Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_inttoptr(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                                 value B) {
-  return LLVMBuildIntToPtr(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_inttoptr(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildIntToPtr(Builder_val(B), Value_val(X),
+                                      Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_bitcast(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                                value B) {
-  return LLVMBuildBitCast(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_bitcast(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildBitCast(Builder_val(B), Value_val(X), Type_val(Ty),
+                                     String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_zext_or_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
-                                        value Name, value B) {
-  return LLVMBuildZExtOrBitCast(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_zext_or_bitcast(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildZExtOrBitCast(Builder_val(B), Value_val(X),
+                                           Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_sext_or_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
-                                        value Name, value B) {
-  return LLVMBuildSExtOrBitCast(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_sext_or_bitcast(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildSExtOrBitCast(Builder_val(B), Value_val(X),
+                                           Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_trunc_or_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
-                                         value Name, value B) {
-  return LLVMBuildTruncOrBitCast(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_trunc_or_bitcast(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildTruncOrBitCast(Builder_val(B), Value_val(X),
+                                            Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_pointercast(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                                    value B) {
-  return LLVMBuildPointerCast(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_pointercast(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildPointerCast(Builder_val(B), Value_val(X),
+                                         Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_intcast(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                                value B) {
-  return LLVMBuildIntCast(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_intcast(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildIntCast(Builder_val(B), Value_val(X), Type_val(Ty),
+                                     String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fpcast(LLVMValueRef X, LLVMTypeRef Ty, value Name,
-                               value B) {
-  return LLVMBuildFPCast(Builder_val(B), X, Ty, String_val(Name));
+value llvm_build_fpcast(value X, value Ty, value Name, value B) {
+  CAMLparam4(X, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildFPCast(Builder_val(B), Value_val(X), Type_val(Ty),
+                                    String_val(Name))));
 }
 
 /*--... Comparisons ........................................................--*/
 
 /* Icmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_icmp(value Pred, LLVMValueRef LHS, LLVMValueRef RHS,
-                             value Name, value B) {
-  return LLVMBuildICmp(Builder_val(B), Int_val(Pred) + LLVMIntEQ, LHS, RHS,
-                       String_val(Name));
+value llvm_build_icmp(value Pred, value LHS, value RHS, value Name, value B) {
+  CAMLparam5(Pred, LHS, RHS, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildICmp(Builder_val(B), Int_val(Pred) + LLVMIntEQ,
+                           Value_val(LHS), Value_val(RHS), String_val(Name))));
 }
 
 /* Fcmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_fcmp(value Pred, LLVMValueRef LHS, LLVMValueRef RHS,
-                             value Name, value B) {
-  return LLVMBuildFCmp(Builder_val(B), Int_val(Pred), LHS, RHS,
-                       String_val(Name));
+value llvm_build_fcmp(value Pred, value LHS, value RHS, value Name, value B) {
+  CAMLparam5(Pred, LHS, RHS, Name, B);
+  CAMLreturn(to_val(LLVMBuildFCmp(Builder_val(B), Int_val(Pred), Value_val(LHS),
+                                  Value_val(RHS), String_val(Name))));
 }
 
 /*--... Miscellaneous instructions .........................................--*/
 
 /* (llvalue * llbasicblock) list -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_phi(value Incoming, value Name, value B) {
-  value Hd, Tl;
-  LLVMValueRef FirstValue, PhiNode;
+value llvm_build_phi(value Incoming, value Name, value B) {
+  CAMLparam3(Incoming, Name, B);
+  CAMLlocal2(Hd, Tl);
 
   assert(Incoming != Val_int(0) && "Empty list passed to Llvm.build_phi!");
 
   Hd = Field(Incoming, 0);
-  FirstValue = (LLVMValueRef)Field(Hd, 0);
-  PhiNode =
+  LLVMValueRef FirstValue = Value_val(Field(Hd, 0));
+  LLVMValueRef PhiNode =
       LLVMBuildPhi(Builder_val(B), LLVMTypeOf(FirstValue), String_val(Name));
 
   for (Tl = Incoming; Tl != Val_int(0); Tl = Field(Tl, 1)) {
     value Hd = Field(Tl, 0);
-    LLVMAddIncoming(PhiNode, (LLVMValueRef *)&Field(Hd, 0),
-                    (LLVMBasicBlockRef *)&Field(Hd, 1), 1);
+    LLVMValueRef V = Value_val(Field(Hd, 0));
+    LLVMBasicBlockRef BB = BasicBlock_val(Field(Hd, 1));
+    LLVMAddIncoming(PhiNode, &V, &BB, 1);
   }
 
-  return PhiNode;
+  CAMLreturn(to_val(PhiNode));
 }
 
 /* lltype -> string -> llbuilder -> value */
-LLVMValueRef llvm_build_empty_phi(LLVMTypeRef Type, value Name, value B) {
-  return LLVMBuildPhi(Builder_val(B), Type, String_val(Name));
+value llvm_build_empty_phi(value Type, value Name, value B) {
+  CAMLparam3(Type, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildPhi(Builder_val(B), Type_val(Type), String_val(Name))));
 }
 
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_call(LLVMTypeRef FnTy, LLVMValueRef Fn, value Params,
-                             value Name, value B) {
-  return LLVMBuildCall2(Builder_val(B), FnTy, Fn,
-                        (LLVMValueRef *)Op_val(Params), Wosize_val(Params),
-                        String_val(Name));
+value llvm_build_call(value FnTy, value Fn, value Params, value Name, value B) {
+  CAMLparam5(FnTy, Fn, Params, Name, B);
+  unsigned Length = Wosize_val(Params);
+  LLVMValueRef *Temp = alloc_temp(Params);
+  LLVMValueRef Value =
+      LLVMBuildCall2(Builder_val(B), Type_val(FnTy), Value_val(Fn), Temp,
+                     Length, String_val(Name));
+  free(Temp);
+  CAMLreturn(to_val(Value));
 }
 
 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_select(LLVMValueRef If, LLVMValueRef Then,
-                               LLVMValueRef Else, value Name, value B) {
-  return LLVMBuildSelect(Builder_val(B), If, Then, Else, String_val(Name));
+value llvm_build_select(value If, value Then, value Else, value Name, value B) {
+  CAMLparam5(If, Then, Else, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildSelect(Builder_val(B), Value_val(If), Value_val(Then),
+                             Value_val(Else), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_va_arg(LLVMValueRef List, LLVMTypeRef Ty, value Name,
-                               value B) {
-  return LLVMBuildVAArg(Builder_val(B), List, Ty, String_val(Name));
+value llvm_build_va_arg(value List, value Ty, value Name, value B) {
+  CAMLparam4(List, Ty, Name, B);
+  CAMLreturn(to_val(LLVMBuildVAArg(Builder_val(B), Value_val(List),
+                                   Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_extractelement(LLVMValueRef Vec, LLVMValueRef Idx,
-                                       value Name, value B) {
-  return LLVMBuildExtractElement(Builder_val(B), Vec, Idx, String_val(Name));
+value llvm_build_extractelement(value Vec, value Idx, value Name, value B) {
+  CAMLparam4(Vec, Idx, Name, B);
+  CAMLreturn(to_val(LLVMBuildExtractElement(Builder_val(B), Value_val(Vec),
+                                            Value_val(Idx), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_insertelement(LLVMValueRef Vec, LLVMValueRef Element,
-                                      LLVMValueRef Idx, value Name, value B) {
-  return LLVMBuildInsertElement(Builder_val(B), Vec, Element, Idx,
-                                String_val(Name));
+value llvm_build_insertelement(value Vec, value Element, value Idx, value Name,
+                               value B) {
+  CAMLparam5(Vec, Element, Idx, Name, B);
+  CAMLreturn(to_val(LLVMBuildInsertElement(Builder_val(B), Value_val(Vec),
+                                           Value_val(Element), Value_val(Idx),
+                                           String_val(Name))));
 }
 
 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_shufflevector(LLVMValueRef V1, LLVMValueRef V2,
-                                      LLVMValueRef Mask, value Name, value B) {
-  return LLVMBuildShuffleVector(Builder_val(B), V1, V2, Mask, String_val(Name));
+value llvm_build_shufflevector(value V1, value V2, value Mask, value Name,
+                               value B) {
+  CAMLparam5(V1, V2, Mask, Name, B);
+  CAMLreturn(to_val(LLVMBuildShuffleVector(Builder_val(B), Value_val(V1),
+                                           Value_val(V2), Value_val(Mask),
+                                           String_val(Name))));
 }
 
 /* llvalue -> int -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_extractvalue(LLVMValueRef Aggregate, value Idx,
-                                     value Name, value B) {
-  return LLVMBuildExtractValue(Builder_val(B), Aggregate, Int_val(Idx),
-                               String_val(Name));
+value llvm_build_extractvalue(value Aggregate, value Idx, value Name, value B) {
+  CAMLparam4(Aggregate, Idx, Name, B);
+  CAMLreturn(to_val(LLVMBuildExtractValue(Builder_val(B), Value_val(Aggregate),
+                                          Int_val(Idx), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> int -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_insertvalue(LLVMValueRef Aggregate, LLVMValueRef Val,
-                                    value Idx, value Name, value B) {
-  return LLVMBuildInsertValue(Builder_val(B), Aggregate, Val, Int_val(Idx),
-                              String_val(Name));
+value llvm_build_insertvalue(value Aggregate, value Val, value Idx, value Name,
+                             value B) {
+  CAMLparam5(Aggregate, Val, Idx, Name, B);
+  CAMLreturn(to_val(LLVMBuildInsertValue(Builder_val(B), Value_val(Aggregate),
+                                         Value_val(Val), Int_val(Idx),
+                                         String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_is_null(LLVMValueRef Val, value Name, value B) {
-  return LLVMBuildIsNull(Builder_val(B), Val, String_val(Name));
+value llvm_build_is_null(value Val, value Name, value B) {
+  CAMLparam3(Val, Name, B);
+  CAMLreturn(to_val(
+      LLVMBuildIsNull(Builder_val(B), Value_val(Val), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_is_not_null(LLVMValueRef Val, value Name, value B) {
-  return LLVMBuildIsNotNull(Builder_val(B), Val, String_val(Name));
+value llvm_build_is_not_null(value Val, value Name, value B) {
+  CAMLparam3(Val, Name, B);
+  CAMLreturn(to_val(
+      LLVMBuildIsNotNull(Builder_val(B), Value_val(Val), String_val(Name))));
 }
 
-/* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_ptrdiff(LLVMTypeRef ElemTy, LLVMValueRef LHS,
-                                LLVMValueRef RHS, value Name, value B) {
-  return LLVMBuildPtrDiff2(Builder_val(B), ElemTy, LHS, RHS, String_val(Name));
+/* lltype -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
+value llvm_build_ptrdiff(value ElemTy, value LHS, value RHS, value Name,
+                         value B) {
+  CAMLparam5(ElemTy, LHS, RHS, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildPtrDiff2(Builder_val(B), Type_val(ElemTy), Value_val(LHS),
+                               Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_freeze(LLVMValueRef X, value Name, value B) {
-  return LLVMBuildFreeze(Builder_val(B), X, String_val(Name));
+value llvm_build_freeze(value X, value Name, value B) {
+  CAMLparam3(X, Name, B);
+  CAMLreturn(
+      to_val(LLVMBuildFreeze(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /*===-- Memory buffers ----------------------------------------------------===*/
 
 /* string -> llmemorybuffer
    raises IoError msg on error */
-LLVMMemoryBufferRef llvm_memorybuffer_of_file(value Path) {
+value llvm_memorybuffer_of_file(value Path) {
+  CAMLparam1(Path);
   char *Message;
   LLVMMemoryBufferRef MemBuf;
 
   if (LLVMCreateMemoryBufferWithContentsOfFile(String_val(Path), &MemBuf,
                                                &Message))
     llvm_raise(*caml_named_value("Llvm.IoError"), Message);
-
-  return MemBuf;
+  CAMLreturn(to_val(MemBuf));
 }
 
 /* unit -> llmemorybuffer
    raises IoError msg on error */
-LLVMMemoryBufferRef llvm_memorybuffer_of_stdin(value Unit) {
+value llvm_memorybuffer_of_stdin(value Unit) {
+  CAMLparam1(Unit);
   char *Message;
   LLVMMemoryBufferRef MemBuf;
 
   if (LLVMCreateMemoryBufferWithSTDIN(&MemBuf, &Message))
     llvm_raise(*caml_named_value("Llvm.IoError"), Message);
-
-  return MemBuf;
+  CAMLreturn(to_val(MemBuf));
 }
 
 /* ?name:string -> string -> llmemorybuffer */
-LLVMMemoryBufferRef llvm_memorybuffer_of_string(value Name, value String) {
+value llvm_memorybuffer_of_string(value Name, value String) {
+  CAMLparam2(Name, String);
   LLVMMemoryBufferRef MemBuf;
   const char *NameCStr;
 
   if (Name == Val_int(0))
     NameCStr = "";
   else
     NameCStr = String_val(Field(Name, 0));
 
   MemBuf = LLVMCreateMemoryBufferWithMemoryRangeCopy(
       String_val(String), caml_string_length(String), NameCStr);
-
-  return MemBuf;
+  CAMLreturn(to_val(MemBuf));
 }
 
 /* llmemorybuffer -> string */
-value llvm_memorybuffer_as_string(LLVMMemoryBufferRef MemBuf) {
+value llvm_memorybuffer_as_string(value MB) {
+  CAMLparam1(MB);
+  LLVMMemoryBufferRef MemBuf = MemoryBuffer_val(MB);
   size_t BufferSize = LLVMGetBufferSize(MemBuf);
   const char *BufferStart = LLVMGetBufferStart(MemBuf);
-  return cstr_to_string(BufferStart, BufferSize);
+  CAMLreturn(cstr_to_string(BufferStart, BufferSize));
 }
 
 /* llmemorybuffer -> unit */
-value llvm_memorybuffer_dispose(LLVMMemoryBufferRef MemBuf) {
-  LLVMDisposeMemoryBuffer(MemBuf);
-  return Val_unit;
+value llvm_memorybuffer_dispose(value MemBuf) {
+  CAMLparam1(MemBuf);
+  LLVMDisposeMemoryBuffer(MemoryBuffer_val(MemBuf));
+  CAMLreturn(Val_unit);
 }
 
 /*===-- Pass Managers -----------------------------------------------------===*/
 
 /* unit -> [ `Module ] PassManager.t */
-LLVMPassManagerRef llvm_passmanager_create(value Unit) {
-  return LLVMCreatePassManager();
+value llvm_passmanager_create(value Unit) {
+  CAMLparam1(Unit);
+  CAMLreturn(to_val(LLVMCreatePassManager()));
+}
+
+/* llmodule -> [ `Function ] PassManager.t */
+value llvm_passmanager_create_function(value Module) {
+  CAMLparam1(Module);
+  CAMLreturn(
+      to_val(LLVMCreateFunctionPassManagerForModule(Module_val(Module))));
 }
 
 /* llmodule -> [ `Function ] PassManager.t -> bool */
-value llvm_passmanager_run_module(LLVMModuleRef M, LLVMPassManagerRef PM) {
-  return Val_bool(LLVMRunPassManager(PM, M));
+value llvm_passmanager_run_module(value M, value PM) {
+  CAMLparam2(M, PM);
+  CAMLreturn(Val_bool(LLVMRunPassManager(PassManager_val(PM), Module_val(M))));
 }
 
 /* [ `Function ] PassManager.t -> bool */
-value llvm_passmanager_initialize(LLVMPassManagerRef FPM) {
-  return Val_bool(LLVMInitializeFunctionPassManager(FPM));
+value llvm_passmanager_initialize(value FPM) {
+  CAMLparam1(FPM);
+  CAMLreturn(Val_bool(LLVMInitializeFunctionPassManager(PassManager_val(FPM))));
 }
 
 /* llvalue -> [ `Function ] PassManager.t -> bool */
-value llvm_passmanager_run_function(LLVMValueRef F, LLVMPassManagerRef FPM) {
-  return Val_bool(LLVMRunFunctionPassManager(FPM, F));
+value llvm_passmanager_run_function(value F, value FPM) {
+  CAMLparam2(F, FPM);
+  CAMLreturn(
+      Val_bool(LLVMRunFunctionPassManager(PassManager_val(FPM), Value_val(F))));
 }
 
 /* [ `Function ] PassManager.t -> bool */
-value llvm_passmanager_finalize(LLVMPassManagerRef FPM) {
-  return Val_bool(LLVMFinalizeFunctionPassManager(FPM));
+value llvm_passmanager_finalize(value FPM) {
+  CAMLparam1(FPM);
+  CAMLreturn(Val_bool(LLVMFinalizeFunctionPassManager(PassManager_val(FPM))));
 }
 
 /* PassManager.any PassManager.t -> unit */
-value llvm_passmanager_dispose(LLVMPassManagerRef PM) {
-  LLVMDisposePassManager(PM);
-  return Val_unit;
+value llvm_passmanager_dispose(value PM) {
+  CAMLparam1(PM);
+  LLVMDisposePassManager(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }

llvm/bindings/ocaml/target/target_ocaml.c

 /*===-- target_ocaml.c - LLVM OCaml Glue ------------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c/Core.h"
 #include "llvm-c/Target.h"
 #include "llvm-c/TargetMachine.h"
 #include "caml/alloc.h"
 #include "caml/fail.h"
 #include "caml/memory.h"
static struct custom_operations llvm_data_layout_ops = {
     custom_compare_default,
     custom_hash_default,
     custom_serialize_default,
     custom_deserialize_default,
     custom_compare_ext_default};
 
 value llvm_alloc_data_layout(LLVMTargetDataRef DataLayout) {
   value V =
-      alloc_custom(&llvm_data_layout_ops, sizeof(LLVMTargetDataRef), 0, 1);
+      caml_alloc_custom(&llvm_data_layout_ops, sizeof(LLVMTargetDataRef), 0, 1);
   DataLayout_val(V) = DataLayout;
   return V;
 }
 
 /* string -> DataLayout.t */
 value llvm_datalayout_of_string(value StringRep) {
-  return llvm_alloc_data_layout(LLVMCreateTargetData(String_val(StringRep)));
+  CAMLparam1(StringRep);
+  CAMLreturn(
+      llvm_alloc_data_layout(LLVMCreateTargetData(String_val(StringRep))));
 }
 
 /* DataLayout.t -> string */
 value llvm_datalayout_as_string(value TD) {
+  CAMLparam1(TD);
+  CAMLlocal1(Copy);
   char *StringRep = LLVMCopyStringRepOfTargetData(DataLayout_val(TD));
-  value Copy = copy_string(StringRep);
+  Copy = caml_copy_string(StringRep);
   LLVMDisposeMessage(StringRep);
-  return Copy;
+  CAMLreturn(Copy);
 }
 
 /* DataLayout.t -> Endian.t */
 value llvm_datalayout_byte_order(value DL) {
-  return Val_int(LLVMByteOrder(DataLayout_val(DL)));
+  CAMLparam1(DL);
+  CAMLreturn(Val_int(LLVMByteOrder(DataLayout_val(DL))));
 }
 
 /* DataLayout.t -> int */
 value llvm_datalayout_pointer_size(value DL) {
-  return Val_int(LLVMPointerSize(DataLayout_val(DL)));
+  CAMLparam1(DL);
+  CAMLreturn(Val_int(LLVMPointerSize(DataLayout_val(DL))));
 }
 
 /* Llvm.llcontext -> DataLayout.t -> Llvm.lltype */
-LLVMTypeRef llvm_datalayout_intptr_type(LLVMContextRef C, value DL) {
-  return LLVMIntPtrTypeInContext(C, DataLayout_val(DL));
+value llvm_datalayout_intptr_type(value C, value DL) {
+  CAMLparam2(C, DL);
+  LLVMTypeRef Type =
+      LLVMIntPtrTypeInContext(Context_val(C), DataLayout_val(DL));
+  CAMLreturn(to_val(Type));
 }
 
 /* int -> DataLayout.t -> int */
 value llvm_datalayout_qualified_pointer_size(value AS, value DL) {
-  return Val_int(LLVMPointerSizeForAS(DataLayout_val(DL), Int_val(AS)));
+  CAMLparam2(AS, DL);
+  CAMLreturn(Val_int(LLVMPointerSizeForAS(DataLayout_val(DL), Int_val(AS))));
 }
 
 /* Llvm.llcontext -> int -> DataLayout.t -> Llvm.lltype */
-LLVMTypeRef llvm_datalayout_qualified_intptr_type(LLVMContextRef C, value AS,
-                                                  value DL) {
-  return LLVMIntPtrTypeForASInContext(C, DataLayout_val(DL), Int_val(AS));
+value llvm_datalayout_qualified_intptr_type(value C, value AS, value DL) {
+  CAMLparam3(C, AS, DL);
+  LLVMTypeRef Type = LLVMIntPtrTypeForASInContext(
+      Context_val(C), DataLayout_val(DL), Int_val(AS));
+  CAMLreturn(to_val(Type));
 }
 
 /* Llvm.lltype -> DataLayout.t -> Int64.t */
-value llvm_datalayout_size_in_bits(LLVMTypeRef Ty, value DL) {
-  return caml_copy_int64(LLVMSizeOfTypeInBits(DataLayout_val(DL), Ty));
+value llvm_datalayout_size_in_bits(value Ty, value DL) {
+  CAMLparam2(Ty, DL);
+  CAMLreturn(
+      caml_copy_int64(LLVMSizeOfTypeInBits(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> Int64.t */
-value llvm_datalayout_store_size(LLVMTypeRef Ty, value DL) {
-  return caml_copy_int64(LLVMStoreSizeOfType(DataLayout_val(DL), Ty));
+value llvm_datalayout_store_size(value Ty, value DL) {
+  CAMLparam2(Ty, DL);
+  CAMLreturn(
+      caml_copy_int64(LLVMStoreSizeOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> Int64.t */
-value llvm_datalayout_abi_size(LLVMTypeRef Ty, value DL) {
-  return caml_copy_int64(LLVMABISizeOfType(DataLayout_val(DL), Ty));
+value llvm_datalayout_abi_size(value Ty, value DL) {
+  CAMLparam2(Ty, DL);
+  CAMLreturn(
+      caml_copy_int64(LLVMABISizeOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> int */
-value llvm_datalayout_abi_align(LLVMTypeRef Ty, value DL) {
-  return Val_int(LLVMABIAlignmentOfType(DataLayout_val(DL), Ty));
+value llvm_datalayout_abi_align(value Ty, value DL) {
+  CAMLparam2(Ty, DL);
+  CAMLreturn(Val_int(LLVMABIAlignmentOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> int */
-value llvm_datalayout_stack_align(LLVMTypeRef Ty, value DL) {
-  return Val_int(LLVMCallFrameAlignmentOfType(DataLayout_val(DL), Ty));
+value llvm_datalayout_stack_align(value Ty, value DL) {
+  CAMLparam2(Ty, DL);
+  CAMLreturn(
+      Val_int(LLVMCallFrameAlignmentOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> int */
-value llvm_datalayout_preferred_align(LLVMTypeRef Ty, value DL) {
-  return Val_int(LLVMPreferredAlignmentOfType(DataLayout_val(DL), Ty));
+value llvm_datalayout_preferred_align(value Ty, value DL) {
+  CAMLparam2(Ty, DL);
+  CAMLreturn(
+      Val_int(LLVMPreferredAlignmentOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.llvalue -> DataLayout.t -> int */
-value llvm_datalayout_preferred_align_of_global(LLVMValueRef GlobalVar,
-                                                value DL) {
-  return Val_int(LLVMPreferredAlignmentOfGlobal(DataLayout_val(DL), GlobalVar));
+value llvm_datalayout_preferred_align_of_global(value GlobalVar, value DL) {
+  CAMLparam2(GlobalVar, DL);
+  CAMLreturn(Val_int(LLVMPreferredAlignmentOfGlobal(DataLayout_val(DL),
+                                                    Value_val(GlobalVar))));
 }
 
 /* Llvm.lltype -> Int64.t -> DataLayout.t -> int */
-value llvm_datalayout_element_at_offset(LLVMTypeRef Ty, value Offset,
-                                        value DL) {
-  return Val_int(
-      LLVMElementAtOffset(DataLayout_val(DL), Ty, Int64_val(Offset)));
+value llvm_datalayout_element_at_offset(value Ty, value Offset, value DL) {
+  CAMLparam3(Ty, Offset, DL);
+  CAMLreturn(Val_int(LLVMElementAtOffset(DataLayout_val(DL), Type_val(Ty),
+                                         Int64_val(Offset))));
 }
 
 /* Llvm.lltype -> int -> DataLayout.t -> Int64.t */
-value llvm_datalayout_offset_of_element(LLVMTypeRef Ty, value Index, value DL) {
-  return caml_copy_int64(
-      LLVMOffsetOfElement(DataLayout_val(DL), Ty, Int_val(Index)));
+value llvm_datalayout_offset_of_element(value Ty, value Index, value DL) {
+  CAMLparam3(Ty, Index, DL);
+  CAMLreturn(caml_copy_int64(
+      LLVMOffsetOfElement(DataLayout_val(DL), Type_val(Ty), Int_val(Index))));
 }
 
 /*===---- Target ----------------------------------------------------------===*/
 
+#define Target_val(v) ((LLVMTargetRef)from_val(v))
+
 /* unit -> string */
 value llvm_target_default_triple(value Unit) {
+  CAMLparam1(Unit);
+  CAMLlocal1(TripleStr);
   char *TripleCStr = LLVMGetDefaultTargetTriple();
-  value TripleStr = caml_copy_string(TripleCStr);
+  TripleStr = caml_copy_string(TripleCStr);
   LLVMDisposeMessage(TripleCStr);
-
-  return TripleStr;
+  CAMLreturn(TripleStr);
 }
 
 /* unit -> Target.t option */
 value llvm_target_first(value Unit) {
-  return ptr_to_option(LLVMGetFirstTarget());
+  CAMLparam1(Unit);
+  CAMLreturn(ptr_to_option(LLVMGetFirstTarget()));
 }
 
 /* Target.t -> Target.t option */
-value llvm_target_succ(LLVMTargetRef Target) {
-  return ptr_to_option(LLVMGetNextTarget(Target));
+value llvm_target_succ(value Target) {
+  CAMLparam1(Target);
+  CAMLreturn(ptr_to_option(LLVMGetNextTarget(Target_val(Target))));
 }
 
 /* string -> Target.t option */
 value llvm_target_by_name(value Name) {
-  return ptr_to_option(LLVMGetTargetFromName(String_val(Name)));
+  CAMLparam1(Name);
+  CAMLreturn(ptr_to_option(LLVMGetTargetFromName(String_val(Name))));
 }
 
 /* string -> Target.t */
-LLVMTargetRef llvm_target_by_triple(value Triple) {
+value llvm_target_by_triple(value Triple) {
+  CAMLparam1(Triple);
   LLVMTargetRef T;
   char *Error;
 
   if (LLVMGetTargetFromTriple(String_val(Triple), &T, &Error))
     llvm_raise(*caml_named_value("Llvm_target.Error"), Error);
 
-  return T;
+  CAMLreturn(to_val(T));
 }
 
 /* Target.t -> string */
-value llvm_target_name(LLVMTargetRef Target) {
-  return caml_copy_string(LLVMGetTargetName(Target));
+value llvm_target_name(value Target) {
+  CAMLparam1(Target);
+  CAMLreturn(caml_copy_string(LLVMGetTargetName(Target_val(Target))));
 }
 
 /* Target.t -> string */
-value llvm_target_description(LLVMTargetRef Target) {
-  return caml_copy_string(LLVMGetTargetDescription(Target));
+value llvm_target_description(value Target) {
+  CAMLparam1(Target);
+  CAMLreturn(caml_copy_string(LLVMGetTargetDescription(Target_val(Target))));
 }
 
 /* Target.t -> bool */
-value llvm_target_has_jit(LLVMTargetRef Target) {
-  return Val_bool(LLVMTargetHasJIT(Target));
+value llvm_target_has_jit(value Target) {
+  CAMLparam1(Target);
+  CAMLreturn(Val_bool(LLVMTargetHasJIT(Target_val(Target))));
 }
 
 /* Target.t -> bool */
-value llvm_target_has_target_machine(LLVMTargetRef Target) {
-  return Val_bool(LLVMTargetHasTargetMachine(Target));
+value llvm_target_has_target_machine(value Target) {
+  CAMLparam1(Target);
+  CAMLreturn(Val_bool(LLVMTargetHasTargetMachine(Target_val(Target))));
 }
 
 /* Target.t -> bool */
-value llvm_target_has_asm_backend(LLVMTargetRef Target) {
-  return Val_bool(LLVMTargetHasAsmBackend(Target));
+value llvm_target_has_asm_backend(value Target) {
+  CAMLparam1(Target);
+  CAMLreturn(Val_bool(LLVMTargetHasAsmBackend(Target_val(Target))));
 }
 
 /*===---- Target Machine --------------------------------------------------===*/
 
 #define TargetMachine_val(v) (*(LLVMTargetMachineRef *)(Data_custom_val(v)))
 
 static void llvm_finalize_target_machine(value Machine) {
   LLVMDisposeTargetMachine(TargetMachine_val(Machine));
 }
 
 static struct custom_operations llvm_target_machine_ops = {
     (char *)"Llvm_target.TargetMachine.t",
     llvm_finalize_target_machine,
     custom_compare_default,
     custom_hash_default,
     custom_serialize_default,
     custom_deserialize_default,
     custom_compare_ext_default};
 
 static value llvm_alloc_targetmachine(LLVMTargetMachineRef Machine) {
-  value V = alloc_custom(&llvm_target_machine_ops, sizeof(LLVMTargetMachineRef),
-                         0, 1);
+  value V = caml_alloc_custom(&llvm_target_machine_ops,
+                              sizeof(LLVMTargetMachineRef), 0, 1);
   TargetMachine_val(V) = Machine;
   return V;
 }
 
 /* triple:string -> ?cpu:string -> ?features:string
    ?level:CodeGenOptLevel.t -> ?reloc_mode:RelocMode.t
    ?code_model:CodeModel.t -> Target.t -> TargetMachine.t */
 value llvm_create_targetmachine_native(value Triple, value CPU, value Features,
                                        value OptLevel, value RelocMode,
-                                       value CodeModel, LLVMTargetRef Target) {
+                                       value CodeModel, value Target) {
+  CAMLparam5(Triple, CPU, Features, OptLevel, RelocMode);
+  CAMLxparam2(CodeModel, Target);
   LLVMTargetMachineRef Machine;
   const char *CPUStr = "", *FeaturesStr = "";
   LLVMCodeGenOptLevel OptLevelEnum = LLVMCodeGenLevelDefault;
   LLVMRelocMode RelocModeEnum = LLVMRelocDefault;
   LLVMCodeModel CodeModelEnum = LLVMCodeModelDefault;
 
   if (CPU != Val_int(0))
     CPUStr = String_val(Field(CPU, 0));
   if (Features != Val_int(0))
     FeaturesStr = String_val(Field(Features, 0));
   if (OptLevel != Val_int(0))
     OptLevelEnum = Int_val(Field(OptLevel, 0));
   if (RelocMode != Val_int(0))
     RelocModeEnum = Int_val(Field(RelocMode, 0));
   if (CodeModel != Val_int(0))
     CodeModelEnum = Int_val(Field(CodeModel, 0));
 
-  Machine =
-      LLVMCreateTargetMachine(Target, String_val(Triple), CPUStr, FeaturesStr,
-                              OptLevelEnum, RelocModeEnum, CodeModelEnum);
+  Machine = LLVMCreateTargetMachine(Target_val(Target), String_val(Triple),
+                                    CPUStr, FeaturesStr, OptLevelEnum,
+                                    RelocModeEnum, CodeModelEnum);
 
-  return llvm_alloc_targetmachine(Machine);
+  CAMLreturn(llvm_alloc_targetmachine(Machine));
 }
 
 value llvm_create_targetmachine_bytecode(value *argv, int argn) {
   return llvm_create_targetmachine_native(argv[0], argv[1], argv[2], argv[3],
-                                          argv[4], argv[5],
-                                          (LLVMTargetRef)argv[6]);
+                                          argv[4], argv[5], argv[6]);
 }
 
 /* TargetMachine.t -> Target.t */
-LLVMTargetRef llvm_targetmachine_target(value Machine) {
-  return LLVMGetTargetMachineTarget(TargetMachine_val(Machine));
+value llvm_targetmachine_target(value Machine) {
+  CAMLparam1(Machine);
+  CAMLreturn(to_val(LLVMGetTargetMachineTarget(TargetMachine_val(Machine))));
 }
 
 /* TargetMachine.t -> string */
 value llvm_targetmachine_triple(value Machine) {
-  return llvm_string_of_message(
-      LLVMGetTargetMachineTriple(TargetMachine_val(Machine)));
+  CAMLparam1(Machine);
+  CAMLreturn(llvm_string_of_message(
+      LLVMGetTargetMachineTriple(TargetMachine_val(Machine))));
 }
 
 /* TargetMachine.t -> string */
 value llvm_targetmachine_cpu(value Machine) {
-  return llvm_string_of_message(
-      LLVMGetTargetMachineCPU(TargetMachine_val(Machine)));
+  CAMLparam1(Machine);
+  CAMLreturn(llvm_string_of_message(
+      LLVMGetTargetMachineCPU(TargetMachine_val(Machine))));
 }
 
 /* TargetMachine.t -> string */
 value llvm_targetmachine_features(value Machine) {
-  return llvm_string_of_message(
-      LLVMGetTargetMachineFeatureString(TargetMachine_val(Machine)));
+  CAMLparam1(Machine);
+  CAMLreturn(llvm_string_of_message(
+      LLVMGetTargetMachineFeatureString(TargetMachine_val(Machine))));
 }
 
 /* TargetMachine.t -> DataLayout.t */
 value llvm_targetmachine_data_layout(value Machine) {
-  return llvm_alloc_data_layout(
-      LLVMCreateTargetDataLayout(TargetMachine_val(Machine)));
+  CAMLparam1(Machine);
+  CAMLreturn(llvm_alloc_data_layout(
+      LLVMCreateTargetDataLayout(TargetMachine_val(Machine))));
 }
 
 /* bool -> TargetMachine.t -> unit */
 value llvm_targetmachine_set_verbose_asm(value Verb, value Machine) {
+  CAMLparam2(Verb, Machine);
   LLVMSetTargetMachineAsmVerbosity(TargetMachine_val(Machine), Bool_val(Verb));
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* Llvm.llmodule -> CodeGenFileType.t -> string -> TargetMachine.t -> unit */
-value llvm_targetmachine_emit_to_file(LLVMModuleRef Module, value FileType,
+value llvm_targetmachine_emit_to_file(value Module, value FileType,
                                       value FileName, value Machine) {
+  CAMLparam4(Module, FileType, FileName, Machine);
   char *ErrorMessage;
 
-  if (LLVMTargetMachineEmitToFile(TargetMachine_val(Machine), Module,
-                                  (char *)String_val(FileName),
-                                  Int_val(FileType), &ErrorMessage)) {
+  if (LLVMTargetMachineEmitToFile(
+          TargetMachine_val(Machine), Module_val(Module),
+          (char *)String_val(FileName), Int_val(FileType), &ErrorMessage)) {
     llvm_raise(*caml_named_value("Llvm_target.Error"), ErrorMessage);
   }
 
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* Llvm.llmodule -> CodeGenFileType.t -> TargetMachine.t ->
    Llvm.llmemorybuffer */
-LLVMMemoryBufferRef
-llvm_targetmachine_emit_to_memory_buffer(LLVMModuleRef Module, value FileType,
+value llvm_targetmachine_emit_to_memory_buffer(value Module, value FileType,
                                                value Machine) {
+  CAMLparam3(Module, FileType, Machine);
   char *ErrorMessage;
   LLVMMemoryBufferRef Buffer;
 
-  if (LLVMTargetMachineEmitToMemoryBuffer(TargetMachine_val(Machine), Module,
-                                          Int_val(FileType), &ErrorMessage,
-                                          &Buffer)) {
+  if (LLVMTargetMachineEmitToMemoryBuffer(TargetMachine_val(Machine),
+                                          Module_val(Module), Int_val(FileType),
+                                          &ErrorMessage, &Buffer)) {
     llvm_raise(*caml_named_value("Llvm_target.Error"), ErrorMessage);
   }
 
-  return Buffer;
+  CAMLreturn(to_val(Buffer));
 }
 
 /* TargetMachine.t -> Llvm.PassManager.t -> unit */
-value llvm_targetmachine_add_analysis_passes(LLVMPassManagerRef PM,
-                                             value Machine) {
-  LLVMAddAnalysisPasses(TargetMachine_val(Machine), PM);
-  return Val_unit;
+value llvm_targetmachine_add_analysis_passes(value PM, value Machine) {
+  CAMLparam2(PM, Machine);
+  LLVMAddAnalysisPasses(TargetMachine_val(Machine), PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }

llvm/bindings/ocaml/transforms/ipo/CMakeLists.txt

 add_ocaml_library(llvm_ipo
   OCAML    llvm_ipo
   OCAMLDEP llvm
   C        ipo_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../../llvm"
   LLVM     ipo)

llvm/bindings/ocaml/transforms/ipo/ipo_ocaml.c

 /*===-- ipo_ocaml.c - LLVM OCaml Glue ---------------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include "llvm-c/Transforms/IPO.h"
-#include "caml/mlvalues.h"
+#include "caml/memory.h"
 #include "caml/misc.h"
+#include "caml/mlvalues.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/Transforms/IPO.h"
 
 /* [`Module] Llvm.PassManager.t -> unit */
-value llvm_add_constant_merge(LLVMPassManagerRef PM) {
-  LLVMAddConstantMergePass(PM);
-  return Val_unit;
+value llvm_add_constant_merge(value PM) {
+  CAMLparam1(PM);
+  LLVMAddConstantMergePass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-value llvm_add_dead_arg_elimination(LLVMPassManagerRef PM) {
-  LLVMAddDeadArgEliminationPass(PM);
-  return Val_unit;
+value llvm_add_dead_arg_elimination(value PM) {
+  CAMLparam1(PM);
+  LLVMAddDeadArgEliminationPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-value llvm_add_function_attrs(LLVMPassManagerRef PM) {
-  LLVMAddFunctionAttrsPass(PM);
-  return Val_unit;
+value llvm_add_function_attrs(value PM) {
+  CAMLparam1(PM);
+  LLVMAddFunctionAttrsPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-value llvm_add_always_inliner(LLVMPassManagerRef PM) {
-  LLVMAddAlwaysInlinerPass(PM);
-  return Val_unit;
+value llvm_add_always_inliner(value PM) {
+  CAMLparam1(PM);
+  LLVMAddAlwaysInlinerPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-value llvm_add_global_dce(LLVMPassManagerRef PM) {
-  LLVMAddGlobalDCEPass(PM);
-  return Val_unit;
+value llvm_add_global_dce(value PM) {
+  CAMLparam1(PM);
+  LLVMAddGlobalDCEPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }

llvm/bindings/ocaml/transforms/passmgr_builder/CMakeLists.txt

 add_ocaml_library(llvm_passmgr_builder
   OCAML    llvm_passmgr_builder
   OCAMLDEP llvm
   C        passmgr_builder_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../../llvm"
   LLVM     ipo)

llvm/bindings/ocaml/transforms/passmgr_builder/passmgr_builder_ocaml.c

 /*===-- passmgr_builder_ocaml.c - LLVM OCaml Glue ---------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include "llvm-c/Transforms/PassManagerBuilder.h"
-#include "caml/mlvalues.h"
 #include "caml/custom.h"
+#include "caml/memory.h"
 #include "caml/misc.h"
+#include "caml/mlvalues.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/Transforms/PassManagerBuilder.h"
 
 #define PMBuilder_val(v) (*(LLVMPassManagerBuilderRef *)(Data_custom_val(v)))
 
 static void llvm_finalize_pmbuilder(value PMB) {
   LLVMPassManagerBuilderDispose(PMBuilder_val(PMB));
 }
 
 static struct custom_operations pmbuilder_ops = {
     (char *)"Llvm_passmgr_builder.t", llvm_finalize_pmbuilder,
     custom_compare_default,           custom_hash_default,
     custom_serialize_default,         custom_deserialize_default,
     custom_compare_ext_default};
 
 static value alloc_pmbuilder(LLVMPassManagerBuilderRef Ref) {
-  value Val =
-      alloc_custom(&pmbuilder_ops, sizeof(LLVMPassManagerBuilderRef), 0, 1);
+  value Val = caml_alloc_custom(&pmbuilder_ops,
+                                sizeof(LLVMPassManagerBuilderRef), 0, 1);
   PMBuilder_val(Val) = Ref;
   return Val;
 }
 
 /* t -> unit */
 value llvm_pmbuilder_create(value Unit) {
-  return alloc_pmbuilder(LLVMPassManagerBuilderCreate());
+  CAMLparam1(Unit);
+  CAMLreturn(alloc_pmbuilder(LLVMPassManagerBuilderCreate()));
 }
 
 /* int -> t -> unit */
 value llvm_pmbuilder_set_opt_level(value OptLevel, value PMB) {
+  CAMLparam2(OptLevel, PMB);
   LLVMPassManagerBuilderSetOptLevel(PMBuilder_val(PMB), Int_val(OptLevel));
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* int -> t -> unit */
 value llvm_pmbuilder_set_size_level(value SizeLevel, value PMB) {
+  CAMLparam2(SizeLevel, PMB);
   LLVMPassManagerBuilderSetSizeLevel(PMBuilder_val(PMB), Int_val(SizeLevel));
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* int -> t -> unit */
 value llvm_pmbuilder_use_inliner_with_threshold(value Threshold, value PMB) {
+  CAMLparam2(Threshold, PMB);
   LLVMPassManagerBuilderSetOptLevel(PMBuilder_val(PMB), Int_val(Threshold));
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* bool -> t -> unit */
 value llvm_pmbuilder_set_disable_unit_at_a_time(value DisableUnitAtATime,
                                                 value PMB) {
+  CAMLparam2(DisableUnitAtATime, PMB);
   LLVMPassManagerBuilderSetDisableUnitAtATime(PMBuilder_val(PMB),
                                               Bool_val(DisableUnitAtATime));
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* bool -> t -> unit */
 value llvm_pmbuilder_set_disable_unroll_loops(value DisableUnroll, value PMB) {
+  CAMLparam2(DisableUnroll, PMB);
   LLVMPassManagerBuilderSetDisableUnrollLoops(PMBuilder_val(PMB),
                                               Bool_val(DisableUnroll));
-  return Val_unit;
+  CAMLreturn(Val_unit);
 }
 
 /* [ `Function ] Llvm.PassManager.t -> t -> unit */
-value llvm_pmbuilder_populate_function_pass_manager(LLVMPassManagerRef PM,
-                                                    value PMB) {
-  LLVMPassManagerBuilderPopulateFunctionPassManager(PMBuilder_val(PMB), PM);
-  return Val_unit;
+value llvm_pmbuilder_populate_function_pass_manager(value PM, value PMB) {
+  CAMLparam2(PM, PMB);
+  LLVMPassManagerBuilderPopulateFunctionPassManager(PMBuilder_val(PMB),
+                                                    PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [ `Module ] Llvm.PassManager.t -> t -> unit */
-value llvm_pmbuilder_populate_module_pass_manager(LLVMPassManagerRef PM,
-                                                  value PMB) {
-  LLVMPassManagerBuilderPopulateModulePassManager(PMBuilder_val(PMB), PM);
-  return Val_unit;
+value llvm_pmbuilder_populate_module_pass_manager(value PM, value PMB) {
+  CAMLparam2(PM, PMB);
+  LLVMPassManagerBuilderPopulateModulePassManager(PMBuilder_val(PMB),
+                                                  PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }

llvm/bindings/ocaml/transforms/scalar_opts/CMakeLists.txt

 add_ocaml_library(llvm_scalar_opts
   OCAML    llvm_scalar_opts
   OCAMLDEP llvm
   C        scalar_opts_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../../llvm"
   LLVM     Scalar)

llvm/bindings/ocaml/transforms/scalar_opts/scalar_opts_ocaml.c

 /*===-- scalar_opts_ocaml.c - LLVM OCaml Glue -------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
+#include "caml/memory.h"
+#include "caml/misc.h"
+#include "caml/mlvalues.h"
+#include "llvm_ocaml.h"
 #include "llvm-c/Transforms/Scalar.h"
 #include "llvm-c/Transforms/Utils.h"
-#include "caml/mlvalues.h"
-#include "caml/misc.h"
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_aggressive_dce(LLVMPassManagerRef PM) {
-  LLVMAddAggressiveDCEPass(PM);
-  return Val_unit;
+value llvm_add_aggressive_dce(value PM) {
+  CAMLparam1(PM);
+  LLVMAddAggressiveDCEPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
-value llvm_add_dce(LLVMPassManagerRef PM) {
-  LLVMAddDCEPass(PM);
-  return Val_unit;
+value llvm_add_dce(value PM) {
+  CAMLparam1(PM);
+  LLVMAddDCEPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_alignment_from_assumptions(LLVMPassManagerRef PM) {
-  LLVMAddAlignmentFromAssumptionsPass(PM);
-  return Val_unit;
+value llvm_add_alignment_from_assumptions(value PM) {
+  CAMLparam1(PM);
+  LLVMAddAlignmentFromAssumptionsPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_cfg_simplification(LLVMPassManagerRef PM) {
-  LLVMAddCFGSimplificationPass(PM);
-  return Val_unit;
+value llvm_add_cfg_simplification(value PM) {
+  CAMLparam1(PM);
+  LLVMAddCFGSimplificationPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_dead_store_elimination(LLVMPassManagerRef PM) {
-  LLVMAddDeadStoreEliminationPass(PM);
-  return Val_unit;
+value llvm_add_dead_store_elimination(value PM) {
+  CAMLparam1(PM);
+  LLVMAddDeadStoreEliminationPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_scalarizer(LLVMPassManagerRef PM) {
-  LLVMAddScalarizerPass(PM);
-  return Val_unit;
+value llvm_add_scalarizer(value PM) {
+  CAMLparam1(PM);
+  LLVMAddScalarizerPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_merged_load_store_motion(LLVMPassManagerRef PM) {
-  LLVMAddMergedLoadStoreMotionPass(PM);
-  return Val_unit;
+value llvm_add_merged_load_store_motion(value PM) {
+  CAMLparam1(PM);
+  LLVMAddMergedLoadStoreMotionPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_gvn(LLVMPassManagerRef PM) {
-  LLVMAddGVNPass(PM);
-  return Val_unit;
+value llvm_add_gvn(value PM) {
+  CAMLparam1(PM);
+  LLVMAddGVNPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_ind_var_simplify(LLVMPassManagerRef PM) {
-  LLVMAddIndVarSimplifyPass(PM);
-  return Val_unit;
+value llvm_add_ind_var_simplify(value PM) {
+  CAMLparam1(PM);
+  LLVMAddIndVarSimplifyPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_instruction_combining(LLVMPassManagerRef PM) {
-  LLVMAddInstructionCombiningPass(PM);
-  return Val_unit;
+value llvm_add_instruction_combining(value PM) {
+  CAMLparam1(PM);
+  LLVMAddInstructionCombiningPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_jump_threading(LLVMPassManagerRef PM) {
-  LLVMAddJumpThreadingPass(PM);
-  return Val_unit;
+value llvm_add_jump_threading(value PM) {
+  CAMLparam1(PM);
+  LLVMAddJumpThreadingPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_licm(LLVMPassManagerRef PM) {
-  LLVMAddLICMPass(PM);
-  return Val_unit;
+value llvm_add_licm(value PM) {
+  CAMLparam1(PM);
+  LLVMAddLICMPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_loop_idiom(LLVMPassManagerRef PM) {
-  LLVMAddLoopIdiomPass(PM);
+value llvm_add_loop_idiom(value PM) {
+  LLVMAddLoopIdiomPass(PassManager_val(PM));
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_loop_rotate(LLVMPassManagerRef PM) {
-  LLVMAddLoopRotatePass(PM);
-  return Val_unit;
+value llvm_add_loop_rotate(value PM) {
+  CAMLparam1(PM);
+  LLVMAddLoopRotatePass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_loop_unroll(LLVMPassManagerRef PM) {
-  LLVMAddLoopUnrollPass(PM);
-  return Val_unit;
+value llvm_add_loop_unroll(value PM) {
+  CAMLparam1(PM);
+  LLVMAddLoopUnrollPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_memcpy_opt(LLVMPassManagerRef PM) {
-  LLVMAddMemCpyOptPass(PM);
-  return Val_unit;
+value llvm_add_memcpy_opt(value PM) {
+  CAMLparam1(PM);
+  LLVMAddMemCpyOptPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_partially_inline_lib_calls(LLVMPassManagerRef PM) {
-  LLVMAddPartiallyInlineLibCallsPass(PM);
-  return Val_unit;
+value llvm_add_partially_inline_lib_calls(value PM) {
+  CAMLparam1(PM);
+  LLVMAddPartiallyInlineLibCallsPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_lower_atomic(LLVMPassManagerRef PM) {
-  LLVMAddLowerAtomicPass(PM);
-  return Val_unit;
+value llvm_add_lower_atomic(value PM) {
+  CAMLparam1(PM);
+  LLVMAddLowerAtomicPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_lower_switch(LLVMPassManagerRef PM) {
-  LLVMAddLowerSwitchPass(PM);
-  return Val_unit;
+value llvm_add_lower_switch(value PM) {
+  CAMLparam1(PM);
+  LLVMAddLowerSwitchPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_promote_memory_to_register(LLVMPassManagerRef PM) {
-  LLVMAddPromoteMemoryToRegisterPass(PM);
-  return Val_unit;
+value llvm_add_promote_memory_to_register(value PM) {
+  CAMLparam1(PM);
+  LLVMAddPromoteMemoryToRegisterPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_reassociation(LLVMPassManagerRef PM) {
-  LLVMAddReassociatePass(PM);
-  return Val_unit;
+value llvm_add_reassociation(value PM) {
+  CAMLparam1(PM);
+  LLVMAddReassociatePass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_sccp(LLVMPassManagerRef PM) {
-  LLVMAddSCCPPass(PM);
-  return Val_unit;
+value llvm_add_sccp(value PM) {
+  CAMLparam1(PM);
+  LLVMAddSCCPPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_scalar_repl_aggregates(LLVMPassManagerRef PM) {
-  LLVMAddScalarReplAggregatesPass(PM);
-  return Val_unit;
+value llvm_add_scalar_repl_aggregates(value PM) {
+  CAMLparam1(PM);
+  LLVMAddScalarReplAggregatesPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_scalar_repl_aggregates_ssa(LLVMPassManagerRef PM) {
-  LLVMAddScalarReplAggregatesPassSSA(PM);
-  return Val_unit;
+value llvm_add_scalar_repl_aggregates_ssa(value PM) {
+  CAMLparam1(PM);
+  LLVMAddScalarReplAggregatesPassSSA(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* int -> [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_scalar_repl_aggregates_with_threshold(value threshold,
-                                                     LLVMPassManagerRef PM) {
-  LLVMAddScalarReplAggregatesPassWithThreshold(PM, Int_val(threshold));
-  return Val_unit;
+                                                     value PM) {
+  CAMLparam2(threshold, PM);
+  LLVMAddScalarReplAggregatesPassWithThreshold(PassManager_val(PM),
+                                               Int_val(threshold));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_simplify_lib_calls(LLVMPassManagerRef PM) {
-  LLVMAddSimplifyLibCallsPass(PM);
-  return Val_unit;
+value llvm_add_simplify_lib_calls(value PM) {
+  CAMLparam1(PM);
+  LLVMAddSimplifyLibCallsPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_tail_call_elimination(LLVMPassManagerRef PM) {
-  LLVMAddTailCallEliminationPass(PM);
-  return Val_unit;
+value llvm_add_tail_call_elimination(value PM) {
+  CAMLparam1(PM);
+  LLVMAddTailCallEliminationPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_demote_memory_to_register(LLVMPassManagerRef PM) {
-  LLVMAddDemoteMemoryToRegisterPass(PM);
-  return Val_unit;
+value llvm_add_demote_memory_to_register(value PM) {
+  CAMLparam1(PM);
+  LLVMAddDemoteMemoryToRegisterPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_verifier(LLVMPassManagerRef PM) {
-  LLVMAddVerifierPass(PM);
-  return Val_unit;
+value llvm_add_verifier(value PM) {
+  CAMLparam1(PM);
+  LLVMAddVerifierPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_correlated_value_propagation(LLVMPassManagerRef PM) {
-  LLVMAddCorrelatedValuePropagationPass(PM);
-  return Val_unit;
+value llvm_add_correlated_value_propagation(value PM) {
+  CAMLparam1(PM);
+  LLVMAddCorrelatedValuePropagationPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_early_cse(LLVMPassManagerRef PM) {
-  LLVMAddEarlyCSEPass(PM);
-  return Val_unit;
+value llvm_add_early_cse(value PM) {
+  CAMLparam1(PM);
+  LLVMAddEarlyCSEPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_lower_expect_intrinsic(LLVMPassManagerRef PM) {
-  LLVMAddLowerExpectIntrinsicPass(PM);
-  return Val_unit;
+value llvm_add_lower_expect_intrinsic(value PM) {
+  CAMLparam1(PM);
+  LLVMAddLowerExpectIntrinsicPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_lower_constant_intrinsics(LLVMPassManagerRef PM) {
-  LLVMAddLowerConstantIntrinsicsPass(PM);
-  return Val_unit;
+value llvm_add_lower_constant_intrinsics(value PM) {
+  CAMLparam1(PM);
+  LLVMAddLowerConstantIntrinsicsPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_type_based_alias_analysis(LLVMPassManagerRef PM) {
-  LLVMAddTypeBasedAliasAnalysisPass(PM);
-  return Val_unit;
+value llvm_add_type_based_alias_analysis(value PM) {
+  CAMLparam1(PM);
+  LLVMAddTypeBasedAliasAnalysisPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_scoped_no_alias_aa(LLVMPassManagerRef PM) {
-  LLVMAddScopedNoAliasAAPass(PM);
-  return Val_unit;
+value llvm_add_scoped_no_alias_aa(value PM) {
+  CAMLparam1(PM);
+  LLVMAddScopedNoAliasAAPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_basic_alias_analysis(LLVMPassManagerRef PM) {
-  LLVMAddBasicAliasAnalysisPass(PM);
-  return Val_unit;
+value llvm_add_basic_alias_analysis(value PM) {
+  CAMLparam1(PM);
+  LLVMAddBasicAliasAnalysisPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_unify_function_exit_nodes(LLVMPassManagerRef PM) {
-  LLVMAddUnifyFunctionExitNodesPass(PM);
-  return Val_unit;
+value llvm_add_unify_function_exit_nodes(value PM) {
+  CAMLparam1(PM);
+  LLVMAddUnifyFunctionExitNodesPass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }

llvm/bindings/ocaml/transforms/utils/CMakeLists.txt

 add_ocaml_library(llvm_transform_utils
   OCAML    llvm_transform_utils
   OCAMLDEP llvm
   C        transform_utils_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../../llvm"
   LLVM     TransformUtils)

llvm/bindings/ocaml/transforms/utils/transform_utils_ocaml.c

 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
 |* Note that these functions intentionally take liberties with the CAMLparamX *|
 |* macros, since most of the parameters are not GC heap objects.              *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include "llvm-c/Core.h"
-#include "caml/mlvalues.h"
+#include "caml/memory.h"
 #include "caml/misc.h"
+#include "caml/mlvalues.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/Core.h"
 
 /*
  * Do not move directly into external. This function is here to pull in
  * -lLLVMTransformUtils, which would otherwise be not linked on static builds,
  * as ld can't see the reference from OCaml code.
  */
 
 /* llmodule -> llmodule */
-LLVMModuleRef llvm_clone_module(LLVMModuleRef M) { return LLVMCloneModule(M); }
+value llvm_clone_module(value M) {
+  CAMLparam1(M);
+  CAMLreturn(to_val(LLVMCloneModule(Module_val(M))));
+}

llvm/bindings/ocaml/transforms/vectorize/CMakeLists.txt

 add_ocaml_library(llvm_vectorize
   OCAML    llvm_vectorize
   OCAMLDEP llvm
   C        vectorize_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../../llvm"
   LLVM     Vectorize)

llvm/bindings/ocaml/transforms/vectorize/vectorize_ocaml.c

 /*===-- vectorize_ocaml.c - LLVM OCaml Glue ---------------------*- C++ -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
-|* Note that these functions intentionally take liberties with the CAMLparamX *|
-|* macros, since most of the parameters are not GC heap objects.              *|
-|*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
-#include "llvm-c/Transforms/Vectorize.h"
-#include "caml/mlvalues.h"
+#include "caml/memory.h"
 #include "caml/misc.h"
+#include "caml/mlvalues.h"
+#include "llvm_ocaml.h"
+#include "llvm-c/Transforms/Vectorize.h"
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_loop_vectorize(LLVMPassManagerRef PM) {
-  LLVMAddLoopVectorizePass(PM);
-  return Val_unit;
+value llvm_add_loop_vectorize(value PM) {
+  CAMLparam1(PM);
+  LLVMAddLoopVectorizePass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-value llvm_add_slp_vectorize(LLVMPassManagerRef PM) {
-  LLVMAddSLPVectorizePass(PM);
-  return Val_unit;
+value llvm_add_slp_vectorize(value PM) {
+  CAMLparam1(PM);
+  LLVMAddSLPVectorizePass(PassManager_val(PM));
+  CAMLreturn(Val_unit);
 }

llvm/test/Bindings/OCaml/core.ml

 let double_type = Llvm.double_type context
 let fp128_type = Llvm.fp128_type context
 
 (*===-- Fixture -----------------------------------------------------------===*)
 
 let filename = Sys.argv.(1)
 let m = create_module context filename
 
+(*===-- Modules  ----------------------------------------------------------===*)
+
+let test_modules () =
+  insist (module_context m = context)
+
 (*===-- Contained types  --------------------------------------------------===*)
 
 let test_contained_types () =
   let ar = struct_type context [| i32_type; i8_type |] in
   insist (i32_type = (Array.get (subtypes ar)) 0);
   insist (i8_type = (Array.get (subtypes ar)) 1)
 
 (*===-- Pointer types  ----------------------------------------------------===*)
let test_constants () =
   let four = const_int i32_type 4 in
 
   (* CHECK: const_array{{.*}}[i32 3, i32 4]
    *)
   group "array";
   let c = const_array i32_type [| three; four |] in
   ignore (define_global "const_array" c m);
   insist ((array_type i32_type 2) = (type_of c));
+  insist (element_type (type_of c) = i32_type);
   insist (Some three = (aggregate_element c 0));
   insist (Some four = (aggregate_element c 1));
   insist (None = (aggregate_element c 2));
 
   (* CHECK: const_vector{{.*}}<i16 1, i16 2{{.*}}>
    *)
   group "vector";
   let c = const_vector [| one; two; one; two;
                           one; two; one; two |] in
   ignore (define_global "const_vector" c m);
   insist ((vector_type i16_type 8) = (type_of c));
+  insist (element_type (type_of c) = i16_type);
 
   (* CHECK: const_structure{{.*.}}i16 1, i16 2, i32 3, i32 4
    *)
   group "structure";
   let c = const_struct context [| one; two; three; four |] in
   ignore (define_global "const_structure" c m);
   insist ((struct_type context [| i16_type; i16_type; i32_type; i32_type |])
         = (type_of c));
let test_writer () =
   insist (write_bitcode_file m filename);
 
   dispose_module m
 
 
 (*===-- Driver ------------------------------------------------------------===*)
 
 let _ =
+  suite "modules"          test_modules;
   suite "contained types"  test_contained_types;
   suite "pointer types"    test_pointer_types;
   suite "conversion"       test_conversion;
   suite "target"           test_target;
   suite "constants"        test_constants;
   suite "attributes"       test_attributes;
   suite "global values"    test_global_values;
   suite "global variables" test_global_variables;

llvm/test/Bindings/OCaml/debuginfo.ml

let vdi = Llvm_debuginfo.dibuild_insert_declare_before dibuilder ~storage:all
     ~var_info:auto_var ~expr:(Llvm_debuginfo.dibuild_expression dibuilder [||])
     ~location ~instr:entry_term
   in
   let () = Printf.printf "%s\n" (Llvm.string_of_llvalue vdi) in
   (* CHECK: call void @llvm.dbg.declare(metadata ptr %my_alloca, metadata {{![0-9]+}}, metadata !DIExpression()), !dbg {{\![0-9]+}}
   *)
   let arg0 = (Llvm.params f).(0) in
   let arg_var = Llvm_debuginfo.dibuild_create_parameter_variable dibuilder ~scope:fun_di
-    ~name:"my_arg" ~argno:0 ~file:file_di ~line:10 ~ty
+    ~name:"my_arg" ~argno:1 ~file:file_di ~line:10 ~ty
     ~always_preserve:false flags_zero
   in
   let argdi = Llvm_debuginfo.dibuild_insert_declare_before dibuilder ~storage:arg0
     ~var_info:arg_var ~expr:(Llvm_debuginfo.dibuild_expression dibuilder [||])
     ~location ~instr:entry_term
   in
   let () = Printf.printf "%s\n" (Llvm.string_of_llvalue argdi) in
   (* CHECK: call void @llvm.dbg.declare(metadata i32 %0, metadata {{![0-9]+}}, metadata !DIExpression()), !dbg {{\![0-9]+}}