diff --git a/llvm/bindings/ocaml/all_backends/all_backends_ocaml.c b/llvm/bindings/ocaml/all_backends/all_backends_ocaml.c
--- a/llvm/bindings/ocaml/all_backends/all_backends_ocaml.c
+++ b/llvm/bindings/ocaml/all_backends/all_backends_ocaml.c
@@ -10,6 +10,9 @@
 |* 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"
diff --git a/llvm/bindings/ocaml/analysis/analysis_ocaml.c b/llvm/bindings/ocaml/analysis/analysis_ocaml.c
--- a/llvm/bindings/ocaml/analysis/analysis_ocaml.c
+++ b/llvm/bindings/ocaml/analysis/analysis_ocaml.c
@@ -10,6 +10,9 @@
 |* 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"
@@ -21,7 +24,7 @@
 
 /* Llvm.llmodule -> string option */
 value llvm_verify_module(value M) {
-  CAMLparam1(M);
+  CAMLparam0();
   CAMLlocal2(String, Option);
 
   char *Message;
@@ -42,35 +45,30 @@
 
 /* Llvm.llvalue -> bool */
 value llvm_verify_function(value Fn) {
-  CAMLparam1(Fn);
-  CAMLreturn(
-      Val_bool(LLVMVerifyFunction(Value_val(Fn), LLVMReturnStatusAction) == 0));
+  return Val_bool(LLVMVerifyFunction(Value_val(Fn), LLVMReturnStatusAction) ==
+                  0);
 }
 
 /* Llvm.llmodule -> unit */
 value llvm_assert_valid_module(value M) {
-  CAMLparam1(M);
   LLVMVerifyModule(Module_val(M), LLVMAbortProcessAction, 0);
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* Llvm.llvalue -> unit */
 value llvm_assert_valid_function(value Fn) {
-  CAMLparam1(Fn);
   LLVMVerifyFunction(Value_val(Fn), LLVMAbortProcessAction);
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* Llvm.llvalue -> unit */
 value llvm_view_function_cfg(value Fn) {
-  CAMLparam1(Fn);
   LLVMViewFunctionCFG(Value_val(Fn));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* Llvm.llvalue -> unit */
 value llvm_view_function_cfg_only(value Fn) {
-  CAMLparam1(Fn);
   LLVMViewFunctionCFGOnly(Value_val(Fn));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/backends/backend_ocaml.c b/llvm/bindings/ocaml/backends/backend_ocaml.c
--- a/llvm/bindings/ocaml/backends/backend_ocaml.c
+++ b/llvm/bindings/ocaml/backends/backend_ocaml.c
@@ -10,6 +10,9 @@
 |* 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"
diff --git a/llvm/bindings/ocaml/bitreader/bitreader_ocaml.c b/llvm/bindings/ocaml/bitreader/bitreader_ocaml.c
--- a/llvm/bindings/ocaml/bitreader/bitreader_ocaml.c
+++ b/llvm/bindings/ocaml/bitreader/bitreader_ocaml.c
@@ -10,6 +10,9 @@
 |* 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/alloc.h"
@@ -24,7 +27,6 @@
 
 /* Llvm.llcontext -> Llvm.llmemorybuffer -> Llvm.llmodule */
 value llvm_get_module(value C, value MemBuf) {
-  CAMLparam2(C, MemBuf);
   LLVMModuleRef M;
 
   if (LLVMGetBitcodeModuleInContext2(Context_val(C), MemoryBuffer_val(MemBuf),
@@ -32,17 +34,16 @@
     llvm_raise(*caml_named_value("Llvm_bitreader.Error"),
                LLVMCreateMessage(""));
 
-  CAMLreturn(to_val(M));
+  return to_val(M);
 }
 
 /* Llvm.llcontext -> Llvm.llmemorybuffer -> Llvm.llmodule */
 value llvm_parse_bitcode(value C, value MemBuf) {
-  CAMLparam2(C, MemBuf);
   LLVMModuleRef M;
 
   if (LLVMParseBitcodeInContext2(Context_val(C), MemoryBuffer_val(MemBuf), &M))
     llvm_raise(*caml_named_value("Llvm_bitreader.Error"),
                LLVMCreateMessage(""));
 
-  CAMLreturn(to_val(M));
+  return to_val(M);
 }
diff --git a/llvm/bindings/ocaml/bitwriter/bitwriter_ocaml.c b/llvm/bindings/ocaml/bitwriter/bitwriter_ocaml.c
--- a/llvm/bindings/ocaml/bitwriter/bitwriter_ocaml.c
+++ b/llvm/bindings/ocaml/bitwriter/bitwriter_ocaml.c
@@ -10,6 +10,9 @@
 |* 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/alloc.h"
@@ -21,14 +24,14 @@
 
 /* Llvm.llmodule -> string -> bool */
 value llvm_write_bitcode_file(value M, value Path) {
-  CAMLparam2(M, Path);
+  CAMLparam1(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, value M, value FD) {
-  CAMLparam3(U, M, FD);
+  CAMLparam1(FD);
   int Unbuffered;
   int Result;
 
@@ -44,6 +47,5 @@
 
 /* Llvm.llmodule -> Llvm.llmemorybuffer */
 value llvm_write_bitcode_to_memory_buffer(value M) {
-  CAMLparam1(M);
-  CAMLreturn(to_val(LLVMWriteBitcodeToMemoryBuffer(Module_val(M))));
+  return to_val(LLVMWriteBitcodeToMemoryBuffer(Module_val(M)));
 }
diff --git a/llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c b/llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c
--- a/llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c
+++ b/llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c
@@ -137,13 +137,11 @@
 }
 
 value llvm_debug_metadata_version(value Unit) {
-  CAMLparam1(Unit);
-  CAMLreturn(Val_int(LLVMDebugMetadataVersion()));
+  return Val_int(LLVMDebugMetadataVersion());
 }
 
 value llvm_get_module_debug_metadata_version(value Module) {
-  CAMLparam1(Module);
-  CAMLreturn(Val_int(LLVMGetModuleDebugMetadataVersion(Module_val(Module))));
+  return Val_int(LLVMGetModuleDebugMetadataVersion(Module_val(Module)));
 }
 
 #define DIFlags_val(v) (*(LLVMDIFlags *)(Data_custom_val(v)))
@@ -161,19 +159,18 @@
 }
 
 LLVMDIFlags llvm_diflags_get(value i_Flag) {
-  CAMLparam1(i_Flag);
   LLVMDIFlags Flags = map_DIFlag(Int_val(i_Flag));
-  CAMLreturn(alloc_diflags(Flags));
+  return alloc_diflags(Flags);
 }
 
 LLVMDIFlags llvm_diflags_set(value Flags, value i_Flag) {
-  CAMLparam2(Flags, i_Flag);
+  CAMLparam1(Flags);
   LLVMDIFlags FlagsNew = DIFlags_val(Flags) | map_DIFlag(Int_val(i_Flag));
   CAMLreturn(alloc_diflags(FlagsNew));
 }
 
 value llvm_diflags_test(value Flags, value i_Flag) {
-  CAMLparam2(Flags, i_Flag);
+  CAMLparam1(Flags);
   LLVMDIFlags Flag = map_DIFlag(Int_val(i_Flag));
   CAMLreturn(Val_bool((DIFlags_val(Flags) & Flag) == Flag));
 }
diff --git a/llvm/bindings/ocaml/executionengine/executionengine_ocaml.c b/llvm/bindings/ocaml/executionengine/executionengine_ocaml.c
--- a/llvm/bindings/ocaml/executionengine/executionengine_ocaml.c
+++ b/llvm/bindings/ocaml/executionengine/executionengine_ocaml.c
@@ -10,6 +10,9 @@
 |* 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/alloc.h"
@@ -39,7 +42,7 @@
 
 /* llcompileroption -> llmodule -> ExecutionEngine.t */
 value llvm_ee_create(value OptRecordOpt, value M) {
-  CAMLparam2(OptRecordOpt, M);
+  CAMLparam1(OptRecordOpt);
   CAMLlocal1(OptRecord);
   LLVMExecutionEngineRef MCJIT;
   char *Error;
@@ -63,48 +66,43 @@
 
 /* ExecutionEngine.t -> unit */
 value llvm_ee_dispose(value EE) {
-  CAMLparam1(EE);
   LLVMDisposeExecutionEngine(ExecutionEngine_val(EE));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llmodule -> ExecutionEngine.t -> unit */
 value llvm_ee_add_module(value M, value EE) {
-  CAMLparam2(M, EE);
   LLVMAddModule(ExecutionEngine_val(EE), Module_val(M));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llmodule -> ExecutionEngine.t -> llmodule */
 value llvm_ee_remove_module(value M, value EE) {
-  CAMLparam2(M, EE);
   LLVMModuleRef RemovedModule;
   char *Error;
   if (LLVMRemoveModule(ExecutionEngine_val(EE), Module_val(M), &RemovedModule,
                        &Error))
     llvm_raise(*caml_named_value("Llvm_executionengine.Error"), Error);
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* ExecutionEngine.t -> unit */
 value llvm_ee_run_static_ctors(value EE) {
-  CAMLparam1(EE);
   LLVMRunStaticConstructors(ExecutionEngine_val(EE));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* ExecutionEngine.t -> unit */
 value llvm_ee_run_static_dtors(value EE) {
-  CAMLparam1(EE);
   LLVMRunStaticDestructors(ExecutionEngine_val(EE));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 extern value llvm_alloc_data_layout(LLVMTargetDataRef TargetData);
 
 /* ExecutionEngine.t -> Llvm_target.DataLayout.t */
 value llvm_ee_get_data_layout(value EE) {
-  CAMLparam1(EE);
+  CAMLparam0();
   CAMLlocal1(DataLayout);
   LLVMTargetDataRef OrigDataLayout;
   char *TargetDataCStr;
@@ -119,20 +117,20 @@
 
 /* Llvm.llvalue -> int64 -> llexecutionengine -> unit */
 value llvm_ee_add_global_mapping(value Global, value Ptr, value EE) {
-  CAMLparam3(Global, Ptr, EE);
+  CAMLparam1(Ptr);
   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);
+  CAMLparam1(Name);
   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);
+  CAMLparam1(Name);
   CAMLreturn(caml_copy_int64((int64_t)LLVMGetFunctionAddress(
       ExecutionEngine_val(EE), String_val(Name))));
 }
diff --git a/llvm/bindings/ocaml/irreader/irreader_ocaml.c b/llvm/bindings/ocaml/irreader/irreader_ocaml.c
--- a/llvm/bindings/ocaml/irreader/irreader_ocaml.c
+++ b/llvm/bindings/ocaml/irreader/irreader_ocaml.c
@@ -10,6 +10,9 @@
 |* 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/alloc.h"
@@ -23,7 +26,7 @@
 
 /* Llvm.llcontext -> Llvm.llmemorybuffer -> Llvm.llmodule */
 value llvm_parse_ir(value C, value MemBuf) {
-  CAMLparam2(C, MemBuf);
+  CAMLparam0();
   CAMLlocal2(Variant, MessageVal);
   LLVMModuleRef M;
   char *Message;
diff --git a/llvm/bindings/ocaml/linker/linker_ocaml.c b/llvm/bindings/ocaml/linker/linker_ocaml.c
--- a/llvm/bindings/ocaml/linker/linker_ocaml.c
+++ b/llvm/bindings/ocaml/linker/linker_ocaml.c
@@ -10,6 +10,9 @@
 |* 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/alloc.h"
@@ -24,10 +27,9 @@
 
 /* llmodule -> llmodule -> unit */
 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"));
 
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/llvm/llvm_ocaml.h b/llvm/bindings/ocaml/llvm/llvm_ocaml.h
--- a/llvm/bindings/ocaml/llvm/llvm_ocaml.h
+++ b/llvm/bindings/ocaml/llvm/llvm_ocaml.h
@@ -33,6 +33,8 @@
 value caml_alloc_some(value);
 #endif
 
+/* ASSUME: Pointer is at least 2-bit aligned! Does not allocate on the OCaml
+   heap. */
 value to_val(void *ptr);
 
 void *from_val(value v);
diff --git a/llvm/bindings/ocaml/llvm/llvm_ocaml.c b/llvm/bindings/ocaml/llvm/llvm_ocaml.c
--- a/llvm/bindings/ocaml/llvm/llvm_ocaml.c
+++ b/llvm/bindings/ocaml/llvm/llvm_ocaml.c
@@ -10,6 +10,9 @@
 |* 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>
@@ -32,23 +35,9 @@
 }
 #endif
 
-value to_val(void *ptr) {
-  if ((((value)ptr) & 1) == 0) {
-    return ((value)ptr) + 1;
-  } else {
-    value v = caml_alloc(1, Abstract_tag);
-    *((void **)Data_abstract_val(v)) = ptr;
-    return v;
-  }
-}
+value to_val(void *ptr) { return ((value)ptr) + 1; }
 
-void *from_val(value v) {
-  if (Is_long(v)) {
-    return (void *)(v - 1);
-  } else {
-    return *((void **)Data_abstract_val(v));
-  }
-}
+void *from_val(value v) { return (void *)(v - 1); }
 
 value llvm_string_of_message(char *Message) {
   value String = caml_copy_string(Message);
@@ -142,42 +131,34 @@
 #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));                                         \
+    if (First)                                                                 \
+      return alloc_variant(1, to_val(First));                                  \
+    return alloc_variant(0, Mom);                                              \
   }                                                                            \
                                                                                \
   /* 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)))));                  \
+    if (Next)                                                                  \
+      return alloc_variant(1, to_val(Next));                                   \
+    return alloc_variant(0, to_val(pfun(cty_val(Kid))));                       \
   }                                                                            \
                                                                                \
   /* 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));                                         \
+    if (Last)                                                                  \
+      return alloc_variant(1, to_val(Last));                                   \
+    return alloc_variant(0, Mom);                                              \
   }                                                                            \
                                                                                \
   /* 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)))));                  \
+    if (Prev)                                                                  \
+      return alloc_variant(1, to_val(Prev));                                   \
+    return alloc_variant(0, to_val(pfun(cty_val(Kid))));                       \
   }
 
 /*===-- Context error handling --------------------------------------------===*/
@@ -199,7 +180,7 @@
 }
 
 static void llvm_remove_diagnostic_handler(value C) {
-  CAMLparam1(C);
+  CAMLparam0();
   LLVMContextRef context = Context_val(C);
   if (LLVMContextGetDiagnosticHandler(context) ==
       llvm_diagnostic_handler_trampoline) {
@@ -212,7 +193,7 @@
 
 /* llcontext -> (Diagnostic.t -> unit) option -> unit */
 value llvm_set_diagnostic_handler(value C, value Handler) {
-  CAMLparam2(C, Handler);
+  CAMLparam1(Handler);
   LLVMContextRef context = Context_val(C);
   llvm_remove_diagnostic_handler(C);
   if (Handler == Val_none) {
@@ -232,28 +213,21 @@
 /*===-- Contexts ----------------------------------------------------------===*/
 
 /* unit -> llcontext */
-value llvm_create_context(value Unit) {
-  CAMLparam1(Unit);
-  CAMLreturn(to_val(LLVMContextCreate()));
-}
+value llvm_create_context(value Unit) { return to_val(LLVMContextCreate()); }
 
 /* llcontext -> unit */
 value llvm_dispose_context(value C) {
-  CAMLparam1(C);
   llvm_remove_diagnostic_handler(C);
   LLVMContextDispose(Context_val(C));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* unit -> llcontext */
-value llvm_global_context(value Unit) {
-  CAMLparam1(Unit);
-  CAMLreturn(to_val(LLVMGetGlobalContext()));
-}
+value llvm_global_context(value Unit) { return to_val(LLVMGetGlobalContext()); }
 
 /* llcontext -> string -> int */
 value llvm_mdkind_id(value C, value Name) {
-  CAMLparam2(C, Name);
+  CAMLparam1(Name);
   unsigned MDKindID = LLVMGetMDKindIDInContext(Context_val(C), String_val(Name),
                                                caml_string_length(Name));
   CAMLreturn(Val_int(MDKindID));
@@ -273,32 +247,29 @@
 
 /* llcontext -> int -> int64 -> llattribute */
 value llvm_create_enum_attr_by_kind(value C, value Kind, value Value) {
-  CAMLparam3(C, Kind, Value);
+  CAMLparam1(Value);
   CAMLreturn(to_val(LLVMCreateEnumAttribute(Context_val(C), Int_val(Kind),
                                             Int64_val(Value))));
 }
 
 /* llattribute -> bool */
 value llvm_is_enum_attr(value A) {
-  CAMLparam1(A);
-  CAMLreturn(Val_int(LLVMIsEnumAttribute(Attribute_val(A))));
+  return Val_int(LLVMIsEnumAttribute(Attribute_val(A)));
 }
 
 /* llattribute -> llattrkind */
 value llvm_get_enum_attr_kind(value A) {
-  CAMLparam1(A);
-  CAMLreturn(Val_int(LLVMGetEnumAttributeKind(Attribute_val(A))));
+  return Val_int(LLVMGetEnumAttributeKind(Attribute_val(A)));
 }
 
 /* llattribute -> int64 */
 value llvm_get_enum_attr_value(value A) {
-  CAMLparam1(A);
-  CAMLreturn(caml_copy_int64(LLVMGetEnumAttributeValue(Attribute_val(A))));
+  return caml_copy_int64(LLVMGetEnumAttributeValue(Attribute_val(A)));
 }
 
 /* llcontext -> kind:string -> name:string -> llattribute */
 value llvm_create_string_attr(value C, value Kind, value Value) {
-  CAMLparam3(C, Kind, Value);
+  CAMLparam2(Kind, Value);
   CAMLreturn(to_val(LLVMCreateStringAttribute(
       Context_val(C), String_val(Kind), caml_string_length(Kind),
       String_val(Value), caml_string_length(Value))));
@@ -306,78 +277,71 @@
 
 /* llattribute -> bool */
 value llvm_is_string_attr(value A) {
-  CAMLparam1(A);
-  CAMLreturn(Val_int(LLVMIsStringAttribute(Attribute_val(A))));
+  return Val_int(LLVMIsStringAttribute(Attribute_val(A)));
 }
 
 /* llattribute -> string */
 value llvm_get_string_attr_kind(value A) {
-  CAMLparam1(A);
   unsigned Length;
   const char *String = LLVMGetStringAttributeKind(Attribute_val(A), &Length);
-  CAMLreturn(cstr_to_string(String, Length));
+  return cstr_to_string(String, Length);
 }
 
 /* llattribute -> string */
 value llvm_get_string_attr_value(value A) {
-  CAMLparam1(A);
   unsigned Length;
   const char *String = LLVMGetStringAttributeValue(Attribute_val(A), &Length);
-  CAMLreturn(cstr_to_string(String, Length));
+  return cstr_to_string(String, Length);
 }
 
 /*===-- Modules -----------------------------------------------------------===*/
 
 /* llcontext -> string -> llmodule */
 value llvm_create_module(value C, value ModuleID) {
-  CAMLparam2(C, ModuleID);
+  CAMLparam1(ModuleID);
   CAMLreturn(to_val(
       LLVMModuleCreateWithNameInContext(String_val(ModuleID), Context_val(C))));
 }
 
 /* llmodule -> unit */
 value llvm_dispose_module(value M) {
-  CAMLparam1(M);
   LLVMDisposeModule(Module_val(M));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llmodule -> string */
 value llvm_target_triple(value M) {
-  CAMLparam1(M);
-  CAMLreturn(caml_copy_string(LLVMGetTarget(Module_val(M))));
+  return caml_copy_string(LLVMGetTarget(Module_val(M)));
 }
 
 /* string -> llmodule -> unit */
 value llvm_set_target_triple(value Trip, value M) {
-  CAMLparam2(Trip, M);
+  CAMLparam1(Trip);
   LLVMSetTarget(Module_val(M), String_val(Trip));
   CAMLreturn(Val_unit);
 }
 
 /* llmodule -> string */
 value llvm_data_layout(value M) {
-  CAMLparam1(M);
-  CAMLreturn(caml_copy_string(LLVMGetDataLayout(Module_val(M))));
+  return caml_copy_string(LLVMGetDataLayout(Module_val(M)));
 }
 
 /* string -> llmodule -> unit */
 value llvm_set_data_layout(value Layout, value M) {
-  CAMLparam2(Layout, M);
+  CAMLparam1(Layout);
   LLVMSetDataLayout(Module_val(M), String_val(Layout));
   CAMLreturn(Val_unit);
 }
 
 /* llmodule -> unit */
 value llvm_dump_module(value M) {
-  CAMLparam1(M);
   LLVMDumpModule(Module_val(M));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* string -> llmodule -> unit */
 value llvm_print_module(value Filename, value M) {
-  CAMLparam2(Filename, M);
+  CAMLparam1(Filename);
   char *Message;
 
   if (LLVMPrintModuleToFile(Module_val(M), String_val(Filename), &Message))
@@ -388,25 +352,23 @@
 
 /* llmodule -> string */
 value llvm_string_of_llmodule(value M) {
-  CAMLparam1(M);
   char *ModuleCStr = LLVMPrintModuleToString(Module_val(M));
   value ModuleStr = caml_copy_string(ModuleCStr);
   LLVMDisposeMessage(ModuleCStr);
 
-  CAMLreturn(ModuleStr);
+  return ModuleStr;
 }
 
 /* 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));
+  return cstr_to_string(Name, (mlsize_t)Len);
 }
 
 /* llmodule -> string -> unit */
 value llvm_set_module_identifier(value M, value Id) {
-  CAMLparam2(M, Id);
+  CAMLparam1(Id);
   LLVMSetModuleIdentifier(Module_val(M), String_val(Id),
                           caml_string_length(Id));
   CAMLreturn(Val_unit);
@@ -414,21 +376,21 @@
 
 /* llmodule -> string -> unit */
 value llvm_set_module_inline_asm(value M, value Asm) {
-  CAMLparam2(M, Asm);
+  CAMLparam1(Asm);
   LLVMSetModuleInlineAsm(Module_val(M), String_val(Asm));
   CAMLreturn(Val_unit);
 }
 
 /* llmodule -> string -> llmetadata option */
 value llvm_get_module_flag(value M, value Key) {
-  CAMLparam2(M, Key);
+  CAMLparam1(Key);
   CAMLreturn(ptr_to_option(LLVMGetModuleFlag(Module_val(M), String_val(Key),
                                              caml_string_length(Key))));
 }
 
 /* llmodule -> ModuleFlagBehavior.t -> string -> llmetadata -> unit */
 value llvm_add_module_flag(value M, value Behaviour, value Key, value Val) {
-  CAMLparam4(M, Behaviour, Key, Val);
+  CAMLparam1(Key);
   LLVMAddModuleFlag(Module_val(M), Int_val(Behaviour), String_val(Key),
                     caml_string_length(Key), Metadata_val(Val));
   CAMLreturn(Val_unit);
@@ -438,37 +400,33 @@
 
 /* lltype -> TypeKind.t */
 value llvm_classify_type(value Ty) {
-  CAMLparam1(Ty);
-  CAMLreturn(Val_int(LLVMGetTypeKind(Type_val(Ty))));
+  return Val_int(LLVMGetTypeKind(Type_val(Ty)));
 }
 
 /* lltype -> bool */
 value llvm_type_is_sized(value Ty) {
-  CAMLparam1(Ty);
-  CAMLreturn(Val_bool(LLVMTypeIsSized(Type_val(Ty))));
+  return Val_bool(LLVMTypeIsSized(Type_val(Ty)));
 }
 
 /* lltype -> llcontext */
 value llvm_type_context(value Ty) {
-  CAMLparam1(Ty);
-  CAMLreturn(to_val(LLVMGetTypeContext(Type_val(Ty))));
+  return to_val(LLVMGetTypeContext(Type_val(Ty)));
 }
 
 /* lltype -> unit */
 value llvm_dump_type(value Val) {
-  CAMLparam1(Val);
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVMDumpType(Type_val(Val));
 #else
   caml_raise_with_arg(*caml_named_value("Llvm.FeatureDisabled"),
                       caml_copy_string("dump"));
 #endif
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* lltype -> string */
 value llvm_string_of_lltype(value M) {
-  CAMLparam1(M);
+  CAMLparam0();
   CAMLlocal1(TypeStr);
   char *TypeCStr = LLVMPrintTypeToString(Type_val(M));
   TypeStr = caml_copy_string(TypeCStr);
@@ -481,84 +439,71 @@
 
 /* llcontext -> lltype */
 value llvm_i1_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMInt1TypeInContext(Context_val(Context))));
+  return to_val(LLVMInt1TypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_i8_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMInt8TypeInContext(Context_val(Context))));
+  return to_val(LLVMInt8TypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_i16_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMInt16TypeInContext(Context_val(Context))));
+  return to_val(LLVMInt16TypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_i32_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMInt32TypeInContext(Context_val(Context))));
+  return to_val(LLVMInt32TypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_i64_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMInt64TypeInContext(Context_val(Context))));
+  return to_val(LLVMInt64TypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> int -> lltype */
 value llvm_integer_type(value Context, value Width) {
-  CAMLparam2(Context, Width);
-  CAMLreturn(
-      to_val(LLVMIntTypeInContext(Context_val(Context), Int_val(Width))));
+  return to_val(LLVMIntTypeInContext(Context_val(Context), Int_val(Width)));
 }
 
 /* lltype -> int */
 value llvm_integer_bitwidth(value IntegerTy) {
-  CAMLparam1(IntegerTy);
-  CAMLreturn(Val_int(LLVMGetIntTypeWidth(Type_val(IntegerTy))));
+  return Val_int(LLVMGetIntTypeWidth(Type_val(IntegerTy)));
 }
 
 /*--... Operations on real types ...........................................--*/
 
 /* llcontext -> lltype */
 value llvm_float_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMFloatTypeInContext(Context_val(Context))));
+  return to_val(LLVMFloatTypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_double_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMDoubleTypeInContext(Context_val(Context))));
+  return to_val(LLVMDoubleTypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_x86fp80_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMX86FP80TypeInContext(Context_val(Context))));
+  return to_val(LLVMX86FP80TypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_fp128_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMFP128TypeInContext(Context_val(Context))));
+  return to_val(LLVMFP128TypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_ppc_fp128_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMPPCFP128TypeInContext(Context_val(Context))));
+  return to_val(LLVMPPCFP128TypeInContext(Context_val(Context)));
 }
 
 /*--... Operations on function types .......................................--*/
 
 /* lltype -> lltype array -> lltype */
 value llvm_function_type(value RetTy, value ParamTys) {
-  CAMLparam2(RetTy, ParamTys);
+  CAMLparam1(ParamTys);
   size_t len = Wosize_val(ParamTys);
   LLVMTypeRef *Temp = alloc_temp(ParamTys);
   LLVMTypeRef Type = LLVMFunctionType(Type_val(RetTy), Temp, len, 0);
@@ -568,7 +513,7 @@
 
 /* lltype -> lltype array -> lltype */
 value llvm_var_arg_function_type(value RetTy, value ParamTys) {
-  CAMLparam2(RetTy, ParamTys);
+  CAMLparam1(ParamTys);
   size_t len = Wosize_val(ParamTys);
   LLVMTypeRef *Temp = alloc_temp(ParamTys);
   LLVMTypeRef Type = LLVMFunctionType(Type_val(RetTy), Temp, len, 1);
@@ -578,20 +523,18 @@
 
 /* lltype -> bool */
 value llvm_is_var_arg(value FunTy) {
-  CAMLparam1(FunTy);
-  CAMLreturn(Val_bool(LLVMIsFunctionVarArg(Type_val(FunTy))));
+  return 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));
+  return to_val(Type);
 }
 
 /* lltype -> lltype array */
 value llvm_param_types(value FunTy) {
-  CAMLparam1(FunTy);
+  CAMLparam0();
   CAMLlocal1(Tys);
   unsigned Length = LLVMCountParamTypes(Type_val(FunTy));
   LLVMTypeRef *Temp = malloc(sizeof(LLVMTypeRef) * Length);
@@ -608,7 +551,7 @@
 
 /* llcontext -> lltype array -> lltype */
 value llvm_struct_type(value C, value ElementTypes) {
-  CAMLparam2(C, ElementTypes);
+  CAMLparam1(ElementTypes);
   size_t Length = Wosize_val(ElementTypes);
   LLVMTypeRef *Temp = alloc_temp(ElementTypes);
   LLVMTypeRef Type = LLVMStructTypeInContext(Context_val(C), Temp, Length, 0);
@@ -618,7 +561,7 @@
 
 /* llcontext -> lltype array -> lltype */
 value llvm_packed_struct_type(value C, value ElementTypes) {
-  CAMLparam2(C, ElementTypes);
+  CAMLparam1(ElementTypes);
   size_t Length = Wosize_val(ElementTypes);
   LLVMTypeRef *Temp = alloc_temp(ElementTypes);
   LLVMTypeRef Type = LLVMStructTypeInContext(Context_val(C), Temp, Length, 1);
@@ -628,13 +571,13 @@
 
 /* llcontext -> string -> lltype */
 value llvm_named_struct_type(value C, value Name) {
-  CAMLparam2(C, Name);
+  CAMLparam1(Name);
   CAMLreturn(to_val(LLVMStructCreateNamed(Context_val(C), String_val(Name))));
 }
 
 /* lltype -> lltype array -> bool -> unit */
 value llvm_struct_set_body(value Ty, value ElementTypes, value Packed) {
-  CAMLparam3(Ty, ElementTypes, Packed);
+  CAMLparam1(ElementTypes);
   unsigned Length = Wosize_val(ElementTypes);
   LLVMTypeRef *Temp = alloc_temp(ElementTypes);
   LLVMStructSetBody(Type_val(Ty), Temp, Length, Bool_val(Packed));
@@ -643,19 +586,17 @@
 
 /* lltype -> string option */
 value llvm_struct_name(value Ty) {
-  CAMLparam1(Ty);
   const char *CStr = LLVMGetStructName(Type_val(Ty));
   size_t Len;
-  if (!CStr) {
-    CAMLreturn(Val_none);
-  }
+  if (!CStr)
+    return Val_none;
   Len = strlen(CStr);
-  CAMLreturn(cstr_to_string_option(CStr, Len));
+  return cstr_to_string_option(CStr, Len);
 }
 
 /* lltype -> lltype array */
 value llvm_struct_element_types(value StructTy) {
-  CAMLparam1(StructTy);
+  CAMLparam0();
   CAMLlocal1(Tys);
   unsigned Length = LLVMCountStructElementTypes(Type_val(StructTy));
   LLVMTypeRef *Temp = alloc_temp(sizeof(LLVMTypeRef) * Length);
@@ -670,27 +611,24 @@
 
 /* lltype -> bool */
 value llvm_is_packed(value StructTy) {
-  CAMLparam1(StructTy);
-  CAMLreturn(Val_bool(LLVMIsPackedStruct(Type_val(StructTy))));
+  return Val_bool(LLVMIsPackedStruct(Type_val(StructTy)));
 }
 
 /* lltype -> bool */
 value llvm_is_opaque(value StructTy) {
-  CAMLparam1(StructTy);
-  CAMLreturn(Val_bool(LLVMIsOpaqueStruct(Type_val(StructTy))));
+  return Val_bool(LLVMIsOpaqueStruct(Type_val(StructTy)));
 }
 
 /* lltype -> bool */
 value llvm_is_literal(value StructTy) {
-  CAMLparam1(StructTy);
-  CAMLreturn(Val_bool(LLVMIsLiteralStruct(Type_val(StructTy))));
+  return Val_bool(LLVMIsLiteralStruct(Type_val(StructTy)));
 }
 
 /*--... Operations on array, pointer, and vector types .....................--*/
 
 /* lltype -> lltype array */
 value llvm_subtypes(value Ty) {
-  CAMLparam1(Ty);
+  CAMLparam0();
   CAMLlocal1(Arr);
   unsigned Length = LLVMGetNumContainedTypes(Type_val(Ty));
   Arr = caml_alloc_tuple(Length);
@@ -705,82 +643,69 @@
 
 /* lltype -> int -> lltype */
 value llvm_array_type(value ElementTy, value Count) {
-  CAMLparam2(ElementTy, Count);
-  CAMLreturn(to_val(LLVMArrayType(Type_val(ElementTy), Int_val(Count))));
+  return to_val(LLVMArrayType(Type_val(ElementTy), Int_val(Count)));
 }
 
 /* llcontext -> lltype */
 value llvm_pointer_type(value C) {
-  CAMLparam1(C);
   LLVMTypeRef Type = LLVMPointerTypeInContext(Context_val(C), 0);
-  CAMLreturn(to_val(Type));
+  return to_val(Type);
 }
 
 /* llcontext -> int -> lltype */
 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));
+  return to_val(Type);
 }
 
 /* lltype -> int -> lltype */
 value llvm_vector_type(value ElementTy, value Count) {
-  CAMLparam2(ElementTy, Count);
-  CAMLreturn(to_val(LLVMVectorType(Type_val(ElementTy), Int_val(Count))));
+  return to_val(LLVMVectorType(Type_val(ElementTy), Int_val(Count)));
 }
 
 /* lltype -> int */
 value llvm_array_length(value ArrayTy) {
-  CAMLparam1(ArrayTy);
-  CAMLreturn(Val_int(LLVMGetArrayLength(Type_val(ArrayTy))));
+  return Val_int(LLVMGetArrayLength(Type_val(ArrayTy)));
 }
 
 /* lltype -> int */
 value llvm_address_space(value PtrTy) {
-  CAMLparam1(PtrTy);
-  CAMLreturn(Val_int(LLVMGetPointerAddressSpace(Type_val(PtrTy))));
+  return Val_int(LLVMGetPointerAddressSpace(Type_val(PtrTy)));
 }
 
 /* lltype -> int */
 value llvm_vector_size(value VectorTy) {
-  CAMLparam1(VectorTy);
-  CAMLreturn(Val_int(LLVMGetVectorSize(Type_val(VectorTy))));
+  return Val_int(LLVMGetVectorSize(Type_val(VectorTy)));
 }
 
 /*--... Operations on other types ..........................................--*/
 
 /* llcontext -> lltype */
 value llvm_void_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMVoidTypeInContext(Context_val(Context))));
+  return to_val(LLVMVoidTypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_label_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMLabelTypeInContext(Context_val(Context))));
+  return to_val(LLVMLabelTypeInContext(Context_val(Context)));
 }
 
 /* llcontext -> lltype */
 value llvm_x86_mmx_type(value Context) {
-  CAMLparam1(Context);
-  CAMLreturn(to_val(LLVMX86MMXTypeInContext(Context_val(Context))));
+  return to_val(LLVMX86MMXTypeInContext(Context_val(Context)));
 }
 
 /* llmodule -> string -> lltype option */
 value llvm_type_by_name(value M, value Name) {
-  CAMLparam2(M, Name);
+  CAMLparam1(Name);
   CAMLreturn(ptr_to_option(LLVMGetTypeByName(Module_val(M), String_val(Name))));
 }
 
 /*===-- VALUES ------------------------------------------------------------===*/
 
 /* llvalue -> lltype */
-value llvm_type_of(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(to_val(LLVMTypeOf(Value_val(Val))));
-}
+value llvm_type_of(value Val) { return to_val(LLVMTypeOf(Value_val(Val))); }
 
 /* keep in sync with ValueKind.t */
 enum ValueKind {
@@ -818,7 +743,7 @@
   } while (0)
 
 value llvm_classify_value(value V) {
-  CAMLparam1(V);
+  CAMLparam0();
   CAMLlocal1(Result);
   LLVMValueRef Val = Value_val(V);
   if (!Val) {
@@ -860,27 +785,25 @@
 
 /* llvalue -> string */
 value llvm_value_name(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(caml_copy_string(LLVMGetValueName(Value_val(Val))));
+  return caml_copy_string(LLVMGetValueName(Value_val(Val)));
 }
 
 /* string -> llvalue -> unit */
 value llvm_set_value_name(value Name, value Val) {
-  CAMLparam2(Name, Val);
+  CAMLparam1(Name);
   LLVMSetValueName(Value_val(Val), String_val(Name));
   CAMLreturn(Val_unit);
 }
 
 /* llvalue -> unit */
 value llvm_dump_value(value Val) {
-  CAMLparam1(Val);
   LLVMDumpValue(Value_val(Val));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> string */
 value llvm_string_of_llvalue(value M) {
-  CAMLparam1(M);
+  CAMLparam0();
   CAMLlocal1(ValueStr);
   char *ValueCStr = LLVMPrintValueToString(Value_val(M));
   ValueStr = caml_copy_string(ValueCStr);
@@ -891,41 +814,36 @@
 
 /* llvalue -> llvalue -> unit */
 value llvm_replace_all_uses_with(value OldVal, value NewVal) {
-  CAMLparam2(OldVal, NewVal);
   LLVMReplaceAllUsesWith(Value_val(OldVal), Value_val(NewVal));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*--... Operations on users ................................................--*/
 
 /* llvalue -> int -> llvalue */
 value llvm_operand(value V, value I) {
-  CAMLparam2(V, I);
-  CAMLreturn(to_val(LLVMGetOperand(Value_val(V), Int_val(I))));
+  return to_val(LLVMGetOperand(Value_val(V), Int_val(I)));
 }
 
 /* llvalue -> int -> lluse */
 value llvm_operand_use(value V, value I) {
-  CAMLparam2(V, I);
-  CAMLreturn(to_val(LLVMGetOperandUse(Value_val(V), Int_val(I))));
+  return to_val(LLVMGetOperandUse(Value_val(V), Int_val(I)));
 }
 
 /* llvalue -> int -> llvalue -> 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);
+  return Val_unit;
 }
 
 /* llvalue -> int */
 value llvm_num_operands(value V) {
-  CAMLparam1(V);
-  CAMLreturn(Val_int(LLVMGetNumOperands(Value_val(V))));
+  return Val_int(LLVMGetNumOperands(Value_val(V)));
 }
 
 /* llvalue -> int array */
 value llvm_indices(value Instr) {
-  CAMLparam1(Instr);
+  CAMLparam0();
   CAMLlocal1(Array);
   unsigned Length = LLVMGetNumIndices(Value_val(Instr));
   const unsigned *Indices = LLVMGetIndices(Value_val(Instr));
@@ -940,111 +858,93 @@
 
 /* llvalue -> bool */
 value llvm_is_constant(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(Val_bool(LLVMIsConstant(Value_val(Val))));
+  return 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));
+  return to_val(Value);
 }
 
 /* lltype -> llvalue */
 value llvm_const_all_ones(value Ty) {
-  CAMLparam1(Ty);
   LLVMValueRef Value = LLVMConstAllOnes(Type_val(Ty));
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* lltype -> llvalue */
 value llvm_const_pointer_null(value Ty) {
-  CAMLparam1(Ty);
   LLVMValueRef Value = LLVMConstPointerNull(Type_val(Ty));
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* lltype -> llvalue */
 value llvm_get_undef(value Ty) {
-  CAMLparam1(Ty);
   LLVMValueRef Value = LLVMGetUndef(Type_val(Ty));
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* lltype -> llvalue */
 value llvm_get_poison(value Ty) {
-  CAMLparam1(Ty);
   LLVMValueRef Value = LLVMGetPoison(Type_val(Ty));
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* llvalue -> bool */
-value llvm_is_null(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(Val_bool(LLVMIsNull(Value_val(Val))));
-}
+value llvm_is_null(value Val) { return Val_bool(LLVMIsNull(Value_val(Val))); }
 
 /* llvalue -> bool */
-value llvm_is_undef(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(Val_bool(LLVMIsUndef(Value_val(Val))));
-}
+value llvm_is_undef(value Val) { return Val_bool(LLVMIsUndef(Value_val(Val))); }
 
 /* llvalue -> bool */
 value llvm_is_poison(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(Val_bool(LLVMIsPoison(Value_val(Val))));
+  return Val_bool(LLVMIsPoison(Value_val(Val)));
 }
 
 /* llvalue -> Opcode.t */
 value llvm_constexpr_get_opcode(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(LLVMIsAConstantExpr(Value_val(Val))
-                 ? Val_int(LLVMGetConstOpcode(Value_val(Val)))
-                 : Val_int(0));
+  return LLVMIsAConstantExpr(Value_val(Val))
+             ? Val_int(LLVMGetConstOpcode(Value_val(Val)))
+             : Val_int(0);
 }
 
 /*--... Operations on instructions .........................................--*/
 
 /* llvalue -> bool */
 value llvm_has_metadata(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(Val_bool(LLVMHasMetadata(Value_val(Val))));
+  return Val_bool(LLVMHasMetadata(Value_val(Val)));
 }
 
 /* llvalue -> int -> llvalue option */
 value llvm_metadata(value Val, value MDKindID) {
-  CAMLparam2(Val, MDKindID);
-  CAMLreturn(ptr_to_option(LLVMGetMetadata(Value_val(Val), Int_val(MDKindID))));
+  return ptr_to_option(LLVMGetMetadata(Value_val(Val), Int_val(MDKindID)));
 }
 
 /* llvalue -> int -> llvalue -> 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);
+  return Val_unit;
 }
 
 /* llvalue -> int -> unit */
 value llvm_clear_metadata(value Val, value MDKindID) {
-  CAMLparam2(Val, MDKindID);
   LLVMSetMetadata(Value_val(Val), Int_val(MDKindID), NULL);
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*--... Operations on metadata .............................................--*/
 
 /* llcontext -> string -> llvalue */
 value llvm_mdstring(value C, value S) {
-  CAMLparam2(C, S);
+  CAMLparam1(S);
   CAMLreturn(to_val(LLVMMDStringInContext(Context_val(C), String_val(S),
                                           caml_string_length(S))));
 }
 
 /* llcontext -> llvalue array -> llvalue */
 value llvm_mdnode(value C, value ElementVals) {
-  CAMLparam2(C, ElementVals);
+  CAMLparam1(ElementVals);
   unsigned Length = Wosize_val(ElementVals);
   LLVMValueRef *Temp = alloc_temp(ElementVals);
   LLVMValueRef Value = LLVMMDNodeInContext(Context_val(C), Temp, Length);
@@ -1053,22 +953,18 @@
 }
 
 /* llcontext -> llvalue */
-value llvm_mdnull(value C) {
-  CAMLparam1(C);
-  CAMLreturn(to_val(NULL));
-}
+value llvm_mdnull(value C) { return to_val(NULL); }
 
 /* llvalue -> string option */
 value llvm_get_mdstring(value V) {
-  CAMLparam1(V);
   unsigned Len;
   const char *CStr = LLVMGetMDString(Value_val(V), &Len);
-  CAMLreturn(cstr_to_string_option(CStr, Len));
+  return cstr_to_string_option(CStr, Len);
 }
 
 /* llvalue -> llvalue array */
 value llvm_get_mdnode_operands(value Value) {
-  CAMLparam1(Value);
+  CAMLparam0();
   CAMLlocal1(Operands);
   LLVMValueRef V = Value_val(Value);
   unsigned Length = LLVMGetMDNodeNumOperands(V);
@@ -1084,7 +980,7 @@
 
 /* llmodule -> string -> llvalue array */
 value llvm_get_namedmd(value M, value Name) {
-  CAMLparam2(M, Name);
+  CAMLparam1(Name);
   CAMLlocal1(Nodes);
   unsigned Length =
       LLVMGetNamedMetadataNumOperands(Module_val(M), String_val(Name));
@@ -1100,81 +996,75 @@
 
 /* llmodule -> string -> llvalue -> unit */
 value llvm_append_namedmd(value M, value Name, value Val) {
-  CAMLparam3(M, Name, Val);
+  CAMLparam1(Name);
   LLVMAddNamedMetadataOperand(Module_val(M), String_val(Name), Value_val(Val));
   CAMLreturn(Val_unit);
 }
 
 /* llvalue -> llmetadata */
 value llvm_value_as_metadata(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(to_val(LLVMValueAsMetadata(Value_val(Val))));
+  return to_val(LLVMValueAsMetadata(Value_val(Val)));
 }
 
 /* llcontext -> llmetadata -> llvalue */
 value llvm_metadata_as_value(value C, value MD) {
-  CAMLparam2(C, MD);
-  CAMLreturn(to_val(LLVMMetadataAsValue(Context_val(C), Metadata_val(MD))));
+  return to_val(LLVMMetadataAsValue(Context_val(C), Metadata_val(MD)));
 }
 
 /*--... Operations on scalar constants .....................................--*/
 
 /* lltype -> int -> llvalue */
 value llvm_const_int(value IntTy, value N) {
-  CAMLparam2(IntTy, N);
-  CAMLreturn(to_val(LLVMConstInt(Type_val(IntTy), (long long)Long_val(N), 1)));
+  return to_val(LLVMConstInt(Type_val(IntTy), (long long)Long_val(N), 1));
 }
 
 /* lltype -> Int64.t -> bool -> llvalue */
 value llvm_const_of_int64(value IntTy, value N, value SExt) {
-  CAMLparam3(IntTy, N, SExt);
+  CAMLparam1(N);
   CAMLreturn(
       to_val(LLVMConstInt(Type_val(IntTy), Int64_val(N), Bool_val(SExt))));
 }
 
 /* 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)) {
-    CAMLreturn(Val_none);
+    return Val_none;
   }
-  CAMLreturn(caml_alloc_some(caml_copy_int64(LLVMConstIntGetSExtValue(Const))));
+  return caml_alloc_some(caml_copy_int64(LLVMConstIntGetSExtValue(Const)));
 }
 
 /* lltype -> string -> int -> llvalue */
 value llvm_const_int_of_string(value IntTy, value S, value Radix) {
-  CAMLparam3(IntTy, S, Radix);
+  CAMLparam1(S);
   CAMLreturn(to_val(LLVMConstIntOfStringAndSize(
       Type_val(IntTy), String_val(S), caml_string_length(S), Int_val(Radix))));
 }
 
 /* lltype -> float -> llvalue */
 value llvm_const_float(value RealTy, value N) {
-  CAMLparam2(RealTy, N);
-  CAMLreturn(to_val(LLVMConstReal(Type_val(RealTy), Double_val(N))));
+  return to_val(LLVMConstReal(Type_val(RealTy), Double_val(N)));
 }
 
 /* llvalue -> float option */
 value llvm_float_of_const(value C) {
-  CAMLparam1(C);
   LLVMValueRef Const = Value_val(C);
   LLVMBool LosesInfo;
   double Result;
   if (!LLVMIsAConstantFP(Const)) {
-    CAMLreturn(Val_none);
+    return Val_none;
   }
   Result = LLVMConstRealGetDouble(Const, &LosesInfo);
   if (LosesInfo) {
-    CAMLreturn(Val_none);
+    return Val_none;
   }
-  CAMLreturn(caml_alloc_some(caml_copy_double(Result)));
+  return caml_alloc_some(caml_copy_double(Result));
 }
 
 /* lltype -> string -> llvalue */
 value llvm_const_float_of_string(value RealTy, value S) {
-  CAMLparam2(RealTy, S);
+  CAMLparam1(S);
   CAMLreturn(to_val(LLVMConstRealOfStringAndSize(
       Type_val(RealTy), String_val(S), caml_string_length(S))));
 }
@@ -1183,21 +1073,21 @@
 
 /* llcontext -> string -> llvalue */
 value llvm_const_string(value Context, value Str) {
-  CAMLparam2(Context, Str);
+  CAMLparam1(Str);
   CAMLreturn(to_val(LLVMConstStringInContext(
       Context_val(Context), String_val(Str), caml_string_length(Str), 1)));
 }
 
 /* llcontext -> string -> llvalue */
 value llvm_const_stringz(value Context, value Str) {
-  CAMLparam2(Context, Str);
+  CAMLparam1(Str);
   CAMLreturn(to_val(LLVMConstStringInContext(
       Context_val(Context), String_val(Str), caml_string_length(Str), 0)));
 }
 
 /* lltype -> llvalue array -> llvalue */
 value llvm_const_array(value ElementTy, value ElementVals) {
-  CAMLparam2(ElementTy, ElementVals);
+  CAMLparam1(ElementVals);
   unsigned Length = Wosize_val(ElementVals);
   LLVMValueRef *Temp = alloc_temp(ElementVals);
   LLVMValueRef Value = LLVMConstArray(Type_val(ElementTy), Temp, Length);
@@ -1207,7 +1097,7 @@
 
 /* llcontext -> llvalue array -> llvalue */
 value llvm_const_struct(value C, value ElementVals) {
-  CAMLparam2(C, ElementVals);
+  CAMLparam1(ElementVals);
   unsigned Length = Wosize_val(ElementVals);
   LLVMValueRef *Temp = alloc_temp(ElementVals);
   LLVMValueRef Value =
@@ -1218,7 +1108,7 @@
 
 /* lltype -> llvalue array -> llvalue */
 value llvm_const_named_struct(value Ty, value ElementVals) {
-  CAMLparam2(Ty, ElementVals);
+  CAMLparam1(ElementVals);
   unsigned Length = Wosize_val(ElementVals);
   LLVMValueRef *Temp = alloc_temp(ElementVals);
   LLVMValueRef Value =
@@ -1229,7 +1119,7 @@
 
 /* llcontext -> llvalue array -> llvalue */
 value llvm_const_packed_struct(value C, value ElementVals) {
-  CAMLparam2(C, ElementVals);
+  CAMLparam1(ElementVals);
   unsigned Length = Wosize_val(ElementVals);
   LLVMValueRef *Temp = alloc_temp(ElementVals);
   LLVMValueRef Value =
@@ -1250,191 +1140,164 @@
 
 /* llvalue -> string option */
 value llvm_string_of_const(value C) {
-  CAMLparam1(C);
   size_t Len;
   const char *CStr;
   LLVMValueRef Const = Value_val(C);
   if (!LLVMIsAConstantDataSequential(Const) || !LLVMIsConstantString(Const)) {
-    CAMLreturn(Val_none);
+    return Val_none;
   }
   CStr = LLVMGetAsString(Const, &Len);
-  CAMLreturn(cstr_to_string_option(CStr, Len));
+  return cstr_to_string_option(CStr, Len);
 }
 
 /* llvalue -> int -> llvalue option */
 value llvm_aggregate_element(value Const, value N) {
-  CAMLparam2(Const, N);
-  CAMLreturn(
-      ptr_to_option(LLVMGetAggregateElement(Value_val(Const), Int_val(N))));
+  return 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));
+  return to_val(Value);
 }
 
 /* lltype -> llvalue */
 value llvm_size_of(value Type) {
-  CAMLparam1(Type);
   LLVMValueRef Value = LLVMSizeOf(Type_val(Type));
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* llvalue -> llvalue */
 value llvm_const_neg(value Value) {
-  CAMLparam1(Value);
   LLVMValueRef NegValue = LLVMConstNeg(Value_val(Value));
-  CAMLreturn(to_val(NegValue));
+  return to_val(NegValue);
 }
 
 /* llvalue -> llvalue */
 value llvm_const_nsw_neg(value Value) {
-  CAMLparam1(Value);
   LLVMValueRef NegValue = LLVMConstNSWNeg(Value_val(Value));
-  CAMLreturn(to_val(NegValue));
+  return to_val(NegValue);
 }
 
 /* llvalue -> llvalue */
 value llvm_const_nuw_neg(value Value) {
-  CAMLparam1(Value);
   LLVMValueRef NegValue = LLVMConstNUWNeg(Value_val(Value));
-  CAMLreturn(to_val(NegValue));
+  return to_val(NegValue);
 }
 
 /* llvalue -> llvalue */
 value llvm_const_not(value Value) {
-  CAMLparam1(Value);
   LLVMValueRef NotValue = LLVMConstNot(Value_val(Value));
-  CAMLreturn(to_val(NotValue));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return to_val(Value);
 }
 
 /* Icmp.t -> llvalue -> llvalue -> llvalue */
 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))));
+  return to_val(LLVMConstICmp(Int_val(Pred) + LLVMIntEQ, Value_val(LHSConstant),
+                              Value_val(RHSConstant)));
 }
 
 /* Fcmp.t -> llvalue -> llvalue -> llvalue */
 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))));
+  return 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));
+  return 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));
+  return 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));
+  return to_val(Value);
 }
 
 /* lltype -> llvalue -> llvalue array -> llvalue */
 value llvm_const_gep(value Ty, value ConstantVal, value Indices) {
-  CAMLparam3(Ty, ConstantVal, Indices);
+  CAMLparam1(Indices);
   unsigned Length = Wosize_val(Indices);
   LLVMValueRef *Temp = alloc_temp(Indices);
   LLVMValueRef Value =
@@ -1445,7 +1308,7 @@
 
 /* lltype -> llvalue -> llvalue array -> llvalue */
 value llvm_const_in_bounds_gep(value Ty, value ConstantVal, value Indices) {
-  CAMLparam3(Ty, ConstantVal, Indices);
+  CAMLparam1(Indices);
   unsigned Length = Wosize_val(Indices);
   LLVMValueRef *Temp = alloc_temp(Indices);
   LLVMValueRef Value =
@@ -1456,165 +1319,143 @@
 
 /* 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return to_val(Value);
 }
 
 /* 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return to_val(Value);
 }
 
 /* llvalue -> lltype -> is_signed:bool -> llvalue */
 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))));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return 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));
+  return to_val(Value);
 }
 
 /* lltype -> string -> string -> bool -> bool -> llvalue */
 value llvm_const_inline_asm(value Ty, value Asm, value Constraints,
                             value HasSideEffects, value IsAlignStack) {
-  CAMLparam5(Ty, Asm, Constraints, HasSideEffects, IsAlignStack);
+  CAMLparam2(Asm, Constraints);
   CAMLreturn(to_val(
       LLVMConstInlineAsm(Type_val(Ty), String_val(Asm), String_val(Constraints),
                          Bool_val(HasSideEffects), Bool_val(IsAlignStack))));
@@ -1622,107 +1463,93 @@
 
 /* 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));
+  return 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));
+  return to_val(Module);
 }
 
 /* llvalue -> bool */
 value llvm_is_declaration(value Global) {
-  CAMLparam1(Global);
-  CAMLreturn(Val_bool(LLVMIsDeclaration(Value_val(Global))));
+  return Val_bool(LLVMIsDeclaration(Value_val(Global)));
 }
 
 /* llvalue -> Linkage.t */
 value llvm_linkage(value Global) {
-  CAMLparam1(Global);
-  CAMLreturn(Val_int(LLVMGetLinkage(Value_val(Global))));
+  return Val_int(LLVMGetLinkage(Value_val(Global)));
 }
 
 /* Linkage.t -> llvalue -> unit */
 value llvm_set_linkage(value Linkage, value Global) {
-  CAMLparam2(Linkage, Global);
   LLVMSetLinkage(Value_val(Global), Int_val(Linkage));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> bool */
 value llvm_unnamed_addr(value Global) {
-  CAMLparam1(Global);
-  CAMLreturn(Val_bool(LLVMHasUnnamedAddr(Value_val(Global))));
+  return Val_bool(LLVMHasUnnamedAddr(Value_val(Global)));
 }
 
 /* bool -> llvalue -> unit */
 value llvm_set_unnamed_addr(value UseUnnamedAddr, value Global) {
-  CAMLparam2(UseUnnamedAddr, Global);
   LLVMSetUnnamedAddr(Value_val(Global), Bool_val(UseUnnamedAddr));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> string */
 value llvm_section(value Global) {
-  CAMLparam1(Global);
-  CAMLreturn(caml_copy_string(LLVMGetSection(Value_val(Global))));
+  return caml_copy_string(LLVMGetSection(Value_val(Global)));
 }
 
 /* string -> llvalue -> unit */
 value llvm_set_section(value Section, value Global) {
-  CAMLparam2(Section, Global);
+  CAMLparam1(Section);
   LLVMSetSection(Value_val(Global), String_val(Section));
   CAMLreturn(Val_unit);
 }
 
 /* llvalue -> Visibility.t */
 value llvm_visibility(value Global) {
-  CAMLparam1(Global);
-  CAMLreturn(Val_int(LLVMGetVisibility(Value_val(Global))));
+  return Val_int(LLVMGetVisibility(Value_val(Global)));
 }
 
 /* Visibility.t -> llvalue -> unit */
 value llvm_set_visibility(value Viz, value Global) {
-  CAMLparam2(Viz, Global);
   LLVMSetVisibility(Value_val(Global), Int_val(Viz));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> DLLStorageClass.t */
 value llvm_dll_storage_class(value Global) {
-  CAMLparam1(Global);
-  CAMLreturn(Val_int(LLVMGetDLLStorageClass(Value_val(Global))));
+  return Val_int(LLVMGetDLLStorageClass(Value_val(Global)));
 }
 
 /* DLLStorageClass.t -> llvalue -> unit */
 value llvm_set_dll_storage_class(value Viz, value Global) {
-  CAMLparam2(Viz, Global);
   LLVMSetDLLStorageClass(Value_val(Global), Int_val(Viz));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> int */
 value llvm_alignment(value Global) {
-  CAMLparam1(Global);
-  CAMLreturn(Val_int(LLVMGetAlignment(Value_val(Global))));
+  return Val_int(LLVMGetAlignment(Value_val(Global)));
 }
 
 /* int -> llvalue -> unit */
 value llvm_set_alignment(value Bytes, value Global) {
-  CAMLparam2(Bytes, Global);
   LLVMSetAlignment(Value_val(Global), Int_val(Bytes));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> (llmdkind * llmetadata) array */
 value llvm_global_copy_all_metadata(value Global) {
-  CAMLparam1(Global);
+  CAMLparam0();
   CAMLlocal1(Array);
   size_t NumEntries;
   LLVMValueMetadataEntry *Entries =
@@ -1743,26 +1570,20 @@
 
 /* llvalue -> lluse option */
 value llvm_use_begin(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(ptr_to_option(LLVMGetFirstUse(Value_val(Val))));
+  return ptr_to_option(LLVMGetFirstUse(Value_val(Val)));
 }
 
 /* lluse -> lluse option */
 value llvm_use_succ(value U) {
-  CAMLparam1(U);
-  CAMLreturn(ptr_to_option(LLVMGetNextUse(Use_val(U))));
+  return ptr_to_option(LLVMGetNextUse(Use_val(U)));
 }
 
 /* lluse -> llvalue */
-value llvm_user(value UR) {
-  CAMLparam1(UR);
-  CAMLreturn(to_val(LLVMGetUser(Use_val(UR))));
-}
+value llvm_user(value UR) { return to_val(LLVMGetUser(Use_val(UR))); }
 
 /* lluse -> llvalue */
 value llvm_used_value(value UR) {
-  CAMLparam1(UR);
-  CAMLreturn(to_val(LLVMGetUsedValue(Use_val(UR))));
+  return to_val(LLVMGetUsedValue(Use_val(UR)));
 }
 
 /*--... Operations on global variables .....................................--*/
@@ -1772,7 +1593,7 @@
 
 /* lltype -> string -> llmodule -> llvalue */
 value llvm_declare_global(value Ty, value Name, value M) {
-  CAMLparam3(Ty, Name, M);
+  CAMLparam1(Name);
   LLVMValueRef GlobalVar;
   if ((GlobalVar = LLVMGetNamedGlobal(Module_val(M), String_val(Name)))) {
     if (LLVMGlobalGetValueType(GlobalVar) != Type_val(Ty)) {
@@ -1788,7 +1609,7 @@
 /* lltype -> string -> int -> llmodule -> llvalue */
 value llvm_declare_qualified_global(value Ty, value Name, value AddressSpace,
                                     value M) {
-  CAMLparam4(Ty, Name, AddressSpace, M);
+  CAMLparam1(Name);
   LLVMValueRef GlobalVar;
   if ((GlobalVar = LLVMGetNamedGlobal(Module_val(M), String_val(Name)))) {
     if (LLVMGlobalGetValueType(GlobalVar) != Type_val(Ty)) {
@@ -1803,14 +1624,14 @@
 
 /* string -> llmodule -> llvalue option */
 value llvm_lookup_global(value Name, value M) {
-  CAMLparam2(Name, M);
+  CAMLparam1(Name);
   CAMLreturn(
       ptr_to_option(LLVMGetNamedGlobal(Module_val(M), String_val(Name))));
 }
 
 /* string -> llvalue -> llmodule -> llvalue */
 value llvm_define_global(value Name, value Initializer, value M) {
-  CAMLparam3(Name, Initializer, M);
+  CAMLparam1(Name);
   LLVMValueRef GlobalVar = LLVMAddGlobal(
       Module_val(M), LLVMTypeOf(Value_val(Initializer)), String_val(Name));
   LLVMSetInitializer(GlobalVar, Value_val(Initializer));
@@ -1820,7 +1641,7 @@
 /* string -> llvalue -> int -> llmodule -> llvalue */
 value llvm_define_qualified_global(value Name, value Initializer,
                                    value AddressSpace, value M) {
-  CAMLparam4(Name, Initializer, AddressSpace, M);
+  CAMLparam1(Name);
   LLVMValueRef GlobalVar = LLVMAddGlobalInAddressSpace(
       Module_val(M), LLVMTypeOf(Value_val(Initializer)), String_val(Name),
       Int_val(AddressSpace));
@@ -1830,83 +1651,71 @@
 
 /* llvalue -> unit */
 value llvm_delete_global(value GlobalVar) {
-  CAMLparam1(GlobalVar);
   LLVMDeleteGlobal(Value_val(GlobalVar));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> llvalue option */
 value llvm_global_initializer(value GlobalVar) {
-  CAMLparam1(GlobalVar);
-  CAMLreturn(ptr_to_option(LLVMGetInitializer(Value_val(GlobalVar))));
+  return ptr_to_option(LLVMGetInitializer(Value_val(GlobalVar)));
 }
 
 /* llvalue -> llvalue -> unit */
 value llvm_set_initializer(value ConstantVal, value GlobalVar) {
-  CAMLparam2(ConstantVal, GlobalVar);
   LLVMSetInitializer(Value_val(GlobalVar), Value_val(ConstantVal));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> unit */
 value llvm_remove_initializer(value GlobalVar) {
-  CAMLparam1(GlobalVar);
   LLVMSetInitializer(Value_val(GlobalVar), NULL);
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> bool */
 value llvm_is_thread_local(value GlobalVar) {
-  CAMLparam1(GlobalVar);
-  CAMLreturn(Val_bool(LLVMIsThreadLocal(Value_val(GlobalVar))));
+  return Val_bool(LLVMIsThreadLocal(Value_val(GlobalVar)));
 }
 
 /* bool -> llvalue -> unit */
 value llvm_set_thread_local(value IsThreadLocal, value GlobalVar) {
-  CAMLparam2(IsThreadLocal, GlobalVar);
   LLVMSetThreadLocal(Value_val(GlobalVar), Bool_val(IsThreadLocal));
-  CAMLreturn(Val_unit);
+  Val_unit;
 }
 
 /* llvalue -> ThreadLocalMode.t */
 value llvm_thread_local_mode(value GlobalVar) {
-  CAMLparam1(GlobalVar);
-  CAMLreturn(Val_int(LLVMGetThreadLocalMode(Value_val(GlobalVar))));
+  return Val_int(LLVMGetThreadLocalMode(Value_val(GlobalVar)));
 }
 
 /* ThreadLocalMode.t -> llvalue -> unit */
 value llvm_set_thread_local_mode(value ThreadLocalMode, value GlobalVar) {
-  CAMLparam2(ThreadLocalMode, GlobalVar);
   LLVMSetThreadLocalMode(Value_val(GlobalVar), Int_val(ThreadLocalMode));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> bool */
 value llvm_is_externally_initialized(value GlobalVar) {
-  CAMLparam1(GlobalVar);
-  CAMLreturn(Val_bool(LLVMIsExternallyInitialized(Value_val(GlobalVar))));
+  return Val_bool(LLVMIsExternallyInitialized(Value_val(GlobalVar)));
 }
 
 /* bool -> llvalue -> unit */
 value llvm_set_externally_initialized(value IsExternallyInitialized,
                                       value GlobalVar) {
-  CAMLparam2(IsExternallyInitialized, GlobalVar);
   LLVMSetExternallyInitialized(Value_val(GlobalVar),
                                Bool_val(IsExternallyInitialized));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> bool */
 value llvm_is_global_constant(value GlobalVar) {
-  CAMLparam1(GlobalVar);
-  CAMLreturn(Val_bool(LLVMIsGlobalConstant(Value_val(GlobalVar))));
+  return Val_bool(LLVMIsGlobalConstant(Value_val(GlobalVar)));
 }
 
 /* bool -> llvalue -> unit */
 value llvm_set_global_constant(value Flag, value GlobalVar) {
-  CAMLparam2(Flag, GlobalVar);
   LLVMSetGlobalConstant(Value_val(GlobalVar), Bool_val(Flag));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*--... Operations on aliases ..............................................--*/
@@ -1914,7 +1723,7 @@
 /* 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);
+  CAMLparam1(Name);
   CAMLreturn(
       to_val(LLVMAddAlias2(Module_val(M), Type_val(ValueTy), Int_val(AddrSpace),
                            Value_val(Aliasee), String_val(Name))));
@@ -1927,7 +1736,7 @@
 
 /* string -> lltype -> llmodule -> llvalue */
 value llvm_declare_function(value Name, value Ty, value M) {
-  CAMLparam3(Name, Ty, M);
+  CAMLparam1(Name);
   LLVMValueRef Fn;
   if ((Fn = LLVMGetNamedFunction(Module_val(M), String_val(Name)))) {
     if (LLVMGlobalGetValueType(Fn) != Type_val(Ty)) {
@@ -1942,14 +1751,14 @@
 
 /* string -> llmodule -> llvalue option */
 value llvm_lookup_function(value Name, value M) {
-  CAMLparam2(Name, M);
+  CAMLparam1(Name);
   CAMLreturn(
       ptr_to_option(LLVMGetNamedFunction(Module_val(M), String_val(Name))));
 }
 
 /* string -> lltype -> llmodule -> llvalue */
 value llvm_define_function(value Name, value Ty, value M) {
-  CAMLparam3(Name, Ty, M);
+  CAMLparam1(Name);
   LLVMValueRef Fn =
       LLVMAddFunction(Module_val(M), String_val(Name), Type_val(Ty));
   LLVMAppendBasicBlockInContext(LLVMGetTypeContext(Type_val(Ty)), Fn, "entry");
@@ -1958,57 +1767,51 @@
 
 /* llvalue -> unit */
 value llvm_delete_function(value Fn) {
-  CAMLparam1(Fn);
   LLVMDeleteFunction(Value_val(Fn));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> bool */
 value llvm_is_intrinsic(value Fn) {
-  CAMLparam1(Fn);
-  CAMLreturn(Val_bool(LLVMGetIntrinsicID(Value_val(Fn))));
+  return Val_bool(LLVMGetIntrinsicID(Value_val(Fn)));
 }
 
 /* llvalue -> int */
 value llvm_function_call_conv(value Fn) {
-  CAMLparam1(Fn);
-  CAMLreturn(Val_int(LLVMGetFunctionCallConv(Value_val(Fn))));
+  return Val_int(LLVMGetFunctionCallConv(Value_val(Fn)));
 }
 
 /* int -> llvalue -> unit */
 value llvm_set_function_call_conv(value Id, value Fn) {
-  CAMLparam1(Fn);
   LLVMSetFunctionCallConv(Value_val(Fn), Int_val(Id));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> string option */
 value llvm_gc(value Fn) {
-  CAMLparam1(Fn);
   const char *GC = LLVMGetGC(Value_val(Fn));
   if (!GC) {
-    CAMLreturn(Val_none);
+    return Val_none;
   }
-  CAMLreturn(caml_alloc_some(caml_copy_string(GC)));
+  return caml_alloc_some(caml_copy_string(GC));
 }
 
 /* string option -> llvalue -> unit */
 value llvm_set_gc(value GC, value Fn) {
-  CAMLparam2(GC, Fn);
+  CAMLparam1(GC);
   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(value F, value A, value Index) {
-  CAMLparam3(F, A, Index);
   LLVMAddAttributeAtIndex(Value_val(F), Int_val(Index), Attribute_val(A));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> int -> llattribute array */
 value llvm_function_attrs(value F, value Index) {
-  CAMLparam2(F, Index);
+  CAMLparam0();
   CAMLlocal1(Array);
   unsigned Length = LLVMGetAttributeCountAtIndex(Value_val(F), Int_val(Index));
   Array = caml_alloc_tuple(Length);
@@ -2023,14 +1826,13 @@
 
 /* llvalue -> llattrkind -> int -> 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);
+  return Val_unit;
 }
 
 /* llvalue -> string -> int -> unit */
 value llvm_remove_string_function_attr(value F, value Kind, value Index) {
-  CAMLparam3(F, Kind, Index);
+  CAMLparam1(Kind);
   LLVMRemoveStringAttributeAtIndex(Value_val(F), Int_val(Index),
                                    String_val(Kind), caml_string_length(Kind));
   CAMLreturn(Val_unit);
@@ -2043,13 +1845,12 @@
 
 /* llvalue -> int -> llvalue */
 value llvm_param(value Fn, value Index) {
-  CAMLparam2(Fn, Index);
-  CAMLreturn(to_val(LLVMGetParam(Value_val(Fn), Int_val(Index))));
+  return to_val(LLVMGetParam(Value_val(Fn), Int_val(Index)));
 }
 
 /* llvalue -> llvalue array */
 value llvm_params(value Fn) {
-  CAMLparam1(Fn);
+  CAMLparam0();
   CAMLlocal1(Params);
   unsigned Length = LLVMCountParams(Value_val(Fn));
   LLVMValueRef *Temp = malloc(sizeof(LLVMValueRef) * Length);
@@ -2064,40 +1865,35 @@
 
 /* llvalue -> llvalue */
 value llvm_param_parent(value Value) {
-  CAMLparam1(Value);
   LLVMValueRef Parent = LLVMGetParamParent(Value_val(Value));
-  CAMLreturn(to_val(Parent));
+  return to_val(Parent);
 }
 
 /*--... Operations on basic blocks .........................................--*/
 
 /* llbasicblock -> llvalue */
 value llvm_value_of_block(value BB) {
-  CAMLparam1(BB);
-  CAMLreturn(to_val(LLVMBasicBlockAsValue(BasicBlock_val(BB))));
+  return to_val(LLVMBasicBlockAsValue(BasicBlock_val(BB)));
 }
 
 /* llvalue -> bool */
 value llvm_value_is_block(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(Val_bool(LLVMValueIsBasicBlock(Value_val(Val))));
+  return Val_bool(LLVMValueIsBasicBlock(Value_val(Val)));
 }
 
 /* llbasicblock -> llvalue */
 value llvm_block_of_value(value Val) {
-  CAMLparam1(Val);
-  CAMLreturn(to_val(LLVMValueAsBasicBlock(Value_val(Val))));
+  return to_val(LLVMValueAsBasicBlock(Value_val(Val)));
 }
 
 /* llbasicblock -> llvalue */
 value llvm_block_parent(value BB) {
-  CAMLparam1(BB);
-  CAMLreturn(to_val(LLVMGetBasicBlockParent(BasicBlock_val(BB))));
+  return to_val(LLVMGetBasicBlockParent(BasicBlock_val(BB)));
 }
 
 /* llvalue -> llbasicblock array */
 value llvm_basic_blocks(value Fn) {
-  CAMLparam1(Fn);
+  CAMLparam0();
   CAMLlocal1(MLArray);
   unsigned Length = LLVMCountBasicBlocks(Value_val(Fn));
   LLVMBasicBlockRef *Temp = malloc(sizeof(LLVMBasicBlockRef) * Length);
@@ -2112,9 +1908,8 @@
 
 /* llvalue -> llbasicblock */
 value llvm_entry_block(value Val) {
-  CAMLparam1(Val);
   LLVMBasicBlockRef BB = LLVMGetEntryBasicBlock(Value_val(Val));
-  CAMLreturn(to_val(BB));
+  return to_val(BB);
 }
 
 DEFINE_ITERATORS(block, BasicBlock, Value_val, LLVMBasicBlockRef,
@@ -2122,48 +1917,43 @@
 
 /* llbasicblock -> llvalue option */
 value llvm_block_terminator(value Block) {
-  CAMLparam1(Block);
-  CAMLreturn(ptr_to_option(LLVMGetBasicBlockTerminator(BasicBlock_val(Block))));
+  return ptr_to_option(LLVMGetBasicBlockTerminator(BasicBlock_val(Block)));
 }
 
 /* llbasicblock -> unit */
 value llvm_delete_block(value BB) {
-  CAMLparam1(BB);
   LLVMDeleteBasicBlock(BasicBlock_val(BB));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llbasicblock -> unit */
 value llvm_remove_block(value BB) {
-  CAMLparam1(BB);
   LLVMRemoveBasicBlockFromParent(BasicBlock_val(BB));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llbasicblock -> llbasicblock -> unit */
 value llvm_move_block_before(value Pos, value BB) {
-  CAMLparam2(Pos, BB);
   LLVMMoveBasicBlockBefore(BasicBlock_val(BB), BasicBlock_val(Pos));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llbasicblock -> llbasicblock -> unit */
 value llvm_move_block_after(value Pos, value BB) {
-  CAMLparam2(Pos, BB);
   LLVMMoveBasicBlockAfter(BasicBlock_val(BB), BasicBlock_val(Pos));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* string -> llvalue -> llbasicblock */
 value llvm_append_block(value Context, value Name, value Fn) {
-  CAMLparam3(Context, Name, Fn);
+  CAMLparam1(Name);
   CAMLreturn(to_val(LLVMAppendBasicBlockInContext(
       Context_val(Context), Value_val(Fn), String_val(Name))));
 }
 
 /* llcontext -> string -> llbasicblock -> llbasicblock */
 value llvm_insert_block(value Context, value Name, value BB) {
-  CAMLparam3(Context, Name, BB);
+  CAMLparam1(Name);
   CAMLreturn(to_val(LLVMInsertBasicBlockInContext(
       Context_val(Context), BasicBlock_val(BB), String_val(Name))));
 }
@@ -2172,9 +1962,8 @@
 
 /* llvalue -> llbasicblock */
 value llvm_instr_parent(value Inst) {
-  CAMLparam1(Inst);
   LLVMBasicBlockRef BB = LLVMGetInstructionParent(Value_val(Inst));
-  CAMLreturn(to_val(BB));
+  return to_val(BB);
 }
 
 DEFINE_ITERATORS(instr, Instruction, BasicBlock_val, LLVMValueRef, Value_val,
@@ -2182,68 +1971,59 @@
 
 /* llvalue -> Opcode.t */
 value llvm_instr_get_opcode(value Inst) {
-  CAMLparam1(Inst);
   LLVMOpcode o;
   if (!LLVMIsAInstruction(Value_val(Inst)))
     caml_failwith("Not an instruction");
   o = LLVMGetInstructionOpcode(Value_val(Inst));
   assert(o <= LLVMFreeze);
-  CAMLreturn(Val_int(o));
+  return Val_int(o);
 }
 
 /* llvalue -> ICmp.t option */
 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)));
+  if (!x)
+    return Val_none;
+  return caml_alloc_some(Val_int(x - LLVMIntEQ));
 }
 
 /* llvalue -> FCmp.t option */
 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)));
+  if (!x)
+    return Val_none;
+  return caml_alloc_some(Val_int(x - LLVMRealPredicateFalse));
 }
 
 /* llvalue -> llvalue */
 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))));
+  return to_val(LLVMInstructionClone(Value_val(Inst)));
 }
 
 /*--... Operations on call sites ...........................................--*/
 
 /* llvalue -> int */
 value llvm_instruction_call_conv(value Inst) {
-  CAMLparam1(Inst);
-  CAMLreturn(Val_int(LLVMGetInstructionCallConv(Value_val(Inst))));
+  return Val_int(LLVMGetInstructionCallConv(Value_val(Inst)));
 }
 
 /* int -> llvalue -> unit */
 value llvm_set_instruction_call_conv(value CC, value Inst) {
-  CAMLparam2(CC, Inst);
   LLVMSetInstructionCallConv(Value_val(Inst), Int_val(CC));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> llattribute -> int -> 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);
+  return Val_unit;
 }
 
 /* llvalue -> int -> llattribute array */
 value llvm_call_site_attrs(value F, value Index) {
-  CAMLparam2(F, Index);
+  CAMLparam0();
   CAMLlocal2(Temp, Array);
   unsigned Length = LLVMGetCallSiteAttributeCount(Value_val(F), Int_val(Index));
   Temp = caml_alloc(1, Abstract_tag);
@@ -2258,14 +2038,13 @@
 
 /* llvalue -> llattrkind -> int -> 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);
+  return Val_unit;
 }
 
 /* llvalue -> string -> int -> unit */
 value llvm_remove_string_call_site_attr(value F, value Kind, value Index) {
-  CAMLparam3(F, Kind, Index);
+  CAMLparam1(Kind);
   LLVMRemoveCallSiteStringAttribute(Value_val(F), Int_val(Index),
                                     String_val(Kind), caml_string_length(Kind));
   CAMLreturn(Val_unit);
@@ -2275,99 +2054,84 @@
 
 /* llvalue -> int */
 value llvm_num_arg_operands(value V) {
-  CAMLparam1(V);
-  CAMLreturn(Val_int(LLVMGetNumArgOperands(Value_val(V))));
+  return Val_int(LLVMGetNumArgOperands(Value_val(V)));
 }
 
 /* llvalue -> bool */
 value llvm_is_tail_call(value CallInst) {
-  CAMLparam1(CallInst);
-  CAMLreturn(Val_bool(LLVMIsTailCall(Value_val(CallInst))));
+  return Val_bool(LLVMIsTailCall(Value_val(CallInst)));
 }
 
 /* bool -> llvalue -> unit */
 value llvm_set_tail_call(value IsTailCall, value CallInst) {
-  CAMLparam2(IsTailCall, CallInst);
   LLVMSetTailCall(Value_val(CallInst), Bool_val(IsTailCall));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> llbasicblock */
 value llvm_get_normal_dest(value Val) {
-  CAMLparam1(Val);
   LLVMBasicBlockRef BB = LLVMGetNormalDest(Value_val(Val));
-  CAMLreturn(to_val(BB));
+  return to_val(BB);
 }
 
 /* llvalue -> llbasicblock */
 value llvm_get_unwind_dest(value Val) {
-  CAMLparam1(Val);
   LLVMBasicBlockRef BB = LLVMGetUnwindDest(Value_val(Val));
-  CAMLreturn(to_val(BB));
+  return to_val(BB);
 }
 
 /*--... Operations on load/store instructions (only)........................--*/
 
 /* llvalue -> bool */
 value llvm_is_volatile(value MemoryInst) {
-  CAMLparam1(MemoryInst);
-  CAMLreturn(Val_bool(LLVMGetVolatile(Value_val(MemoryInst))));
+  return Val_bool(LLVMGetVolatile(Value_val(MemoryInst)));
 }
 
 /* bool -> llvalue -> unit */
 value llvm_set_volatile(value IsVolatile, value MemoryInst) {
-  CAMLparam1(MemoryInst);
   LLVMSetVolatile(Value_val(MemoryInst), Bool_val(IsVolatile));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*--.. Operations on terminators ...........................................--*/
 
 /* llvalue -> int -> llbasicblock */
 value llvm_successor(value V, value I) {
-  CAMLparam2(V, I);
-  CAMLreturn(to_val(LLVMGetSuccessor(Value_val(V), Int_val(I))));
+  return to_val(LLVMGetSuccessor(Value_val(V), Int_val(I)));
 }
 
 /* llvalue -> int -> llvalue -> 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);
+  return Val_unit;
 }
 
 /* llvalue -> int */
 value llvm_num_successors(value V) {
-  CAMLparam1(V);
-  CAMLreturn(Val_int(LLVMGetNumSuccessors(Value_val(V))));
+  return Val_int(LLVMGetNumSuccessors(Value_val(V)));
 }
 
 /*--.. Operations on branch ................................................--*/
 
 /* llvalue -> llvalue */
-value llvm_condition(value V) {
-  CAMLparam1(V);
-  CAMLreturn(to_val(LLVMGetCondition(Value_val(V))));
-}
+value llvm_condition(value V) { return to_val(LLVMGetCondition(Value_val(V))); }
 
 /* llvalue -> llvalue -> unit */
 value llvm_set_condition(value B, value C) {
-  CAMLparam2(B, C);
   LLVMSetCondition(Value_val(B), Value_val(C));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> bool */
 value llvm_is_conditional(value V) {
-  CAMLparam1(V);
-  CAMLreturn(Val_bool(LLVMIsConditional(Value_val(V))));
+  return Val_bool(LLVMIsConditional(Value_val(V)));
 }
 
 /*--... Operations on phi nodes ............................................--*/
 
 /* (llvalue * llbasicblock) -> llvalue -> unit */
 value llvm_add_incoming(value Incoming, value PhiNode) {
-  CAMLparam2(Incoming, PhiNode);
+  CAMLparam1(Incoming);
   LLVMValueRef V = Value_val(Field(Incoming, 0));
   LLVMBasicBlockRef BB = BasicBlock_val(Field(Incoming, 1));
   LLVMAddIncoming(Value_val(PhiNode), &V, &BB, 1);
@@ -2376,7 +2140,7 @@
 
 /* llvalue -> (llvalue * llbasicblock) list */
 value llvm_incoming(value Phi) {
-  CAMLparam1(Phi);
+  CAMLparam0();
   CAMLlocal5(Hd, Tl, V, BB, List);
   LLVMValueRef PhiNode = Value_val(Phi);
 
@@ -2400,9 +2164,8 @@
 
 /* llvalue -> unit */
 value llvm_delete_instruction(value Instruction) {
-  CAMLparam1(Instruction);
   LLVMInstructionEraseFromParent(Value_val(Instruction));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*===-- Instruction builders ----------------------------------------------===*/
@@ -2427,8 +2190,7 @@
 
 /* llcontext -> llbuilder */
 value llvm_builder(value C) {
-  CAMLparam1(C);
-  CAMLreturn(alloc_builder(LLVMCreateBuilderInContext(Context_val(C))));
+  return alloc_builder(LLVMCreateBuilderInContext(Context_val(C)));
 }
 
 /* (llbasicblock, llvalue) llpos -> llbuilder -> unit */
@@ -2455,7 +2217,7 @@
 
 /* llvalue -> string -> llbuilder -> unit */
 value llvm_insert_into_builder(value I, value Name, value B) {
-  CAMLparam3(I, Name, B);
+  CAMLparam2(Name, B);
   LLVMInsertIntoBuilderWithName(Builder_val(B), Value_val(I), String_val(Name));
   CAMLreturn(Val_unit);
 }
@@ -2464,7 +2226,7 @@
 
 /* llbuilder -> llvalue -> unit */
 value llvm_set_current_debug_location(value B, value V) {
-  CAMLparam2(B, V);
+  CAMLparam1(B);
   LLVMSetCurrentDebugLocation(Builder_val(B), Value_val(V));
   CAMLreturn(Val_unit);
 }
@@ -2484,7 +2246,7 @@
 
 /* llbuilder -> llvalue -> unit */
 value llvm_set_inst_debug_location(value B, value V) {
-  CAMLparam2(B, V);
+  CAMLparam1(B);
   LLVMSetInstDebugLocation(Builder_val(B), Value_val(V));
   CAMLreturn(Val_unit);
 }
@@ -2499,7 +2261,7 @@
 
 /* llvalue -> llbuilder -> llvalue */
 value llvm_build_ret(value Val, value B) {
-  CAMLparam2(Val, B);
+  CAMLparam1(B);
   CAMLreturn(to_val(LLVMBuildRet(Builder_val(B), Value_val(Val))));
 }
 
@@ -2515,13 +2277,13 @@
 
 /* llbasicblock -> llbuilder -> llvalue */
 value llvm_build_br(value BB, value B) {
-  CAMLparam2(BB, B);
+  CAMLparam1(B);
   CAMLreturn(to_val(LLVMBuildBr(Builder_val(B), BasicBlock_val(BB))));
 }
 
 /* llvalue -> llbasicblock -> llbasicblock -> llbuilder -> llvalue */
 value llvm_build_cond_br(value If, value Then, value Else, value B) {
-  CAMLparam4(If, Then, Else, B);
+  CAMLparam1(B);
   CAMLreturn(
       to_val(LLVMBuildCondBr(Builder_val(B), Value_val(If),
                              BasicBlock_val(Then), BasicBlock_val(Else))));
@@ -2529,7 +2291,7 @@
 
 /* llvalue -> llbasicblock -> int -> llbuilder -> llvalue */
 value llvm_build_switch(value Of, value Else, value EstimatedCount, value B) {
-  CAMLparam4(Of, Else, EstimatedCount, B);
+  CAMLparam1(B);
   CAMLreturn(
       to_val(LLVMBuildSwitch(Builder_val(B), Value_val(Of),
                              BasicBlock_val(Else), Int_val(EstimatedCount))));
@@ -2537,58 +2299,54 @@
 
 /* lltype -> string -> llbuilder -> llvalue */
 value llvm_build_malloc(value Ty, value Name, value B) {
-  CAMLparam3(Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildMalloc(Builder_val(B), Type_val(Ty), String_val(Name))));
 }
 
 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_array_malloc(value Ty, value Val, value Name, value B) {
-  CAMLparam4(Ty, Val, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildArrayMalloc(Builder_val(B), Type_val(Ty),
                                          Value_val(Val), String_val(Name))));
 }
 
 /* llvalue -> llbuilder -> llvalue */
 value llvm_build_free(value P, value B) {
-  CAMLparam2(P, B);
+  CAMLparam1(B);
   CAMLreturn(to_val(LLVMBuildFree(Builder_val(B), Value_val(P))));
 }
 
 /* llvalue -> llvalue -> llbasicblock -> 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);
+  return Val_unit;
 }
 
 /* llvalue -> llbasicblock */
 value llvm_switch_default_dest(value Val) {
-  CAMLparam1(Val);
   LLVMBasicBlockRef BB = LLVMGetSwitchDefaultDest(Value_val(Val));
-  CAMLreturn(to_val(BB));
+  return to_val(BB);
 }
 
 /* llvalue -> int -> llbuilder -> llvalue */
 value llvm_build_indirect_br(value Addr, value EstimatedDests, value B) {
-  CAMLparam3(Addr, EstimatedDests, B);
+  CAMLparam1(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);
+  return Val_unit;
 }
 
 /* lltype -> llvalue -> llvalue array -> llbasicblock -> llbasicblock ->
    string -> llbuilder -> llvalue */
 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);
+  CAMLparam3(Args, Name, B);
   unsigned Length = Wosize_val(Args);
   LLVMValueRef *Temp = alloc_temp(Args);
   LLVMValueRef Value = LLVMBuildInvoke2(
@@ -2608,7 +2366,7 @@
 /* lltype -> llvalue -> int -> string -> llbuilder -> llvalue */
 value llvm_build_landingpad(value Ty, value PersFn, value NumClauses,
                             value Name, value B) {
-  CAMLparam5(Ty, PersFn, NumClauses, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildLandingPad(Builder_val(B), Type_val(Ty),
                                         Value_val(PersFn), Int_val(NumClauses),
                                         String_val(Name))));
@@ -2616,27 +2374,24 @@
 
 /* llvalue -> llvalue -> unit */
 value llvm_add_clause(value LandingPadInst, value ClauseVal) {
-  CAMLparam2(LandingPadInst, ClauseVal);
   LLVMAddClause(Value_val(LandingPadInst), Value_val(ClauseVal));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> bool */
 value llvm_is_cleanup(value LandingPadInst) {
-  CAMLparam1(LandingPadInst);
-  CAMLreturn(Val_bool(LLVMIsCleanup(Value_val(LandingPadInst))));
+  return Val_bool(LLVMIsCleanup(Value_val(LandingPadInst)));
 }
 
 /* llvalue -> bool -> unit */
 value llvm_set_cleanup(value LandingPadInst, value flag) {
-  CAMLparam2(LandingPadInst, flag);
   LLVMSetCleanup(Value_val(LandingPadInst), Bool_val(flag));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llvalue -> llbuilder -> llvalue */
 value llvm_build_resume(value Exn, value B) {
-  CAMLparam2(Exn, B);
+  CAMLparam1(B);
   CAMLreturn(to_val(LLVMBuildResume(Builder_val(B), Value_val(Exn))));
 }
 
@@ -2650,210 +2405,210 @@
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_add(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildAdd(Builder_val(B), Value_val(LHS), Value_val(RHS),
                                  String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_nsw_add(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildNSWAdd(Builder_val(B), Value_val(LHS),
                                     Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_nuw_add(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildNUWAdd(Builder_val(B), Value_val(LHS),
                                     Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_fadd(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFAdd(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_sub(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildSub(Builder_val(B), Value_val(LHS), Value_val(RHS),
                                  String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_nsw_sub(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildNSWSub(Builder_val(B), Value_val(LHS),
                                     Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_nuw_sub(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildNUWSub(Builder_val(B), Value_val(LHS),
                                     Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_fsub(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFSub(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_mul(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildMul(Builder_val(B), Value_val(LHS), Value_val(RHS),
                                  String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_nsw_mul(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildNSWMul(Builder_val(B), Value_val(LHS),
                                     Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_nuw_mul(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildNUWMul(Builder_val(B), Value_val(LHS),
                                     Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_fmul(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFMul(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_udiv(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildUDiv(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_sdiv(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildSDiv(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_exact_sdiv(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildExactSDiv(Builder_val(B), Value_val(LHS),
                                        Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_fdiv(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFDiv(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_urem(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildURem(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_srem(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildSRem(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_frem(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFRem(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_shl(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildShl(Builder_val(B), Value_val(LHS), Value_val(RHS),
                                  String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_lshr(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildLShr(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_ashr(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildAShr(Builder_val(B), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_and(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildAnd(Builder_val(B), Value_val(LHS), Value_val(RHS),
                                  String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_or(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildOr(Builder_val(B), Value_val(LHS), Value_val(RHS),
                                 String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_xor(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildXor(Builder_val(B), Value_val(LHS), Value_val(RHS),
                                  String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_neg(value X, value Name, value B) {
-  CAMLparam3(X, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildNeg(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_nsw_neg(value X, value Name, value B) {
-  CAMLparam3(X, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildNSWNeg(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_nuw_neg(value X, value Name, value B) {
-  CAMLparam3(X, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildNUWNeg(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_fneg(value X, value Name, value B) {
-  CAMLparam3(X, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildFNeg(Builder_val(B), Value_val(X), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_not(value X, value Name, value B) {
-  CAMLparam3(X, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildNot(Builder_val(B), Value_val(X), String_val(Name))));
 }
@@ -2862,28 +2617,28 @@
 
 /* lltype -> string -> llbuilder -> llvalue */
 value llvm_build_alloca(value Ty, value Name, value B) {
-  CAMLparam3(Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildAlloca(Builder_val(B), Type_val(Ty), String_val(Name))));
 }
 
 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_array_alloca(value Ty, value Size, value Name, value B) {
-  CAMLparam4(Ty, Size, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildArrayAlloca(Builder_val(B), Type_val(Ty),
                                          Value_val(Size), String_val(Name))));
 }
 
 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_load(value Ty, value Pointer, value Name, value B) {
-  CAMLparam4(Ty, Pointer, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildLoad2(Builder_val(B), Type_val(Ty),
                                    Value_val(Pointer), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> llbuilder -> llvalue */
 value llvm_build_store(value Value, value Pointer, value B) {
-  CAMLparam3(Value, Pointer, B);
+  CAMLparam1(B);
   CAMLreturn(to_val(
       LLVMBuildStore(Builder_val(B), Value_val(Value), Value_val(Pointer))));
 }
@@ -2892,8 +2647,7 @@
    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);
+  CAMLparam2(Name, B);
   LLVMValueRef Instr;
   Instr = LLVMBuildAtomicRMW(Builder_val(B), Int_val(BinOp), Value_val(Ptr),
                              Value_val(Val), Int_val(Ord), Bool_val(ST));
@@ -2909,7 +2663,7 @@
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
 value llvm_build_gep(value Ty, value Pointer, value Indices, value Name,
                      value B) {
-  CAMLparam5(Ty, Pointer, Indices, Name, B);
+  CAMLparam3(Indices, Name, B);
   unsigned Length = Wosize_val(Indices);
   LLVMValueRef *Temp = alloc_temp(Indices);
   LLVMValueRef Value =
@@ -2922,7 +2676,7 @@
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
 value llvm_build_in_bounds_gep(value Ty, value Pointer, value Indices,
                                value Name, value B) {
-  CAMLparam5(Ty, Pointer, Indices, Name, B);
+  CAMLparam3(Indices, Name, B);
   unsigned Length = Wosize_val(Indices);
   LLVMValueRef *Temp = alloc_temp(Indices);
   LLVMValueRef Value =
@@ -2935,7 +2689,7 @@
 /* lltype -> llvalue -> int -> string -> llbuilder -> llvalue */
 value llvm_build_struct_gep(value Ty, value Pointer, value Index, value Name,
                             value B) {
-  CAMLparam5(Ty, Pointer, Index, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildStructGEP2(Builder_val(B), Type_val(Ty),
                                         Value_val(Pointer), Int_val(Index),
                                         String_val(Name))));
@@ -2959,126 +2713,126 @@
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_trunc(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildTrunc(Builder_val(B), Value_val(X), Type_val(Ty),
                                    String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_zext(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildZExt(Builder_val(B), Value_val(X), Type_val(Ty),
                                   String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_sext(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildSExt(Builder_val(B), Value_val(X), Type_val(Ty),
                                   String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_fptoui(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFPToUI(Builder_val(B), Value_val(X), Type_val(Ty),
                                     String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_fptosi(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFPToSI(Builder_val(B), Value_val(X), Type_val(Ty),
                                     String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_uitofp(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildUIToFP(Builder_val(B), Value_val(X), Type_val(Ty),
                                     String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_sitofp(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildSIToFP(Builder_val(B), Value_val(X), Type_val(Ty),
                                     String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_fptrunc(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFPTrunc(Builder_val(B), Value_val(X), Type_val(Ty),
                                      String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_fpext(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFPExt(Builder_val(B), Value_val(X), Type_val(Ty),
                                    String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_prttoint(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildPtrToInt(Builder_val(B), Value_val(X),
                                       Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_inttoptr(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildIntToPtr(Builder_val(B), Value_val(X),
                                       Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_bitcast(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildBitCast(Builder_val(B), Value_val(X), Type_val(Ty),
                                      String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_zext_or_bitcast(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildZExtOrBitCast(Builder_val(B), Value_val(X),
                                            Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_sext_or_bitcast(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildSExtOrBitCast(Builder_val(B), Value_val(X),
                                            Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_trunc_or_bitcast(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildTruncOrBitCast(Builder_val(B), Value_val(X),
                                             Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_pointercast(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildPointerCast(Builder_val(B), Value_val(X),
                                          Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_intcast(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildIntCast(Builder_val(B), Value_val(X), Type_val(Ty),
                                      String_val(Name))));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_fpcast(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFPCast(Builder_val(B), Value_val(X), Type_val(Ty),
                                     String_val(Name))));
 }
@@ -3087,7 +2841,7 @@
 
 /* Icmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_icmp(value Pred, value LHS, value RHS, value Name, value B) {
-  CAMLparam5(Pred, LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildICmp(Builder_val(B), Int_val(Pred) + LLVMIntEQ,
                            Value_val(LHS), Value_val(RHS), String_val(Name))));
@@ -3095,7 +2849,7 @@
 
 /* Fcmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_fcmp(value Pred, value LHS, value RHS, value Name, value B) {
-  CAMLparam5(Pred, LHS, RHS, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildFCmp(Builder_val(B), Int_val(Pred), Value_val(LHS),
                                   Value_val(RHS), String_val(Name))));
 }
@@ -3126,14 +2880,14 @@
 
 /* lltype -> string -> llbuilder -> value */
 value llvm_build_empty_phi(value Type, value Name, value B) {
-  CAMLparam3(Type, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildPhi(Builder_val(B), Type_val(Type), String_val(Name))));
 }
 
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
 value llvm_build_call(value FnTy, value Fn, value Params, value Name, value B) {
-  CAMLparam5(FnTy, Fn, Params, Name, B);
+  CAMLparam3(Params, Name, B);
   unsigned Length = Wosize_val(Params);
   LLVMValueRef *Temp = alloc_temp(Params);
   LLVMValueRef Value =
@@ -3145,7 +2899,7 @@
 
 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_select(value If, value Then, value Else, value Name, value B) {
-  CAMLparam5(If, Then, Else, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildSelect(Builder_val(B), Value_val(If), Value_val(Then),
                              Value_val(Else), String_val(Name))));
@@ -3153,14 +2907,14 @@
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_va_arg(value List, value Ty, value Name, value B) {
-  CAMLparam4(List, Ty, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildVAArg(Builder_val(B), Value_val(List),
                                    Type_val(Ty), String_val(Name))));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_extractelement(value Vec, value Idx, value Name, value B) {
-  CAMLparam4(Vec, Idx, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildExtractElement(Builder_val(B), Value_val(Vec),
                                             Value_val(Idx), String_val(Name))));
 }
@@ -3168,7 +2922,7 @@
 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_insertelement(value Vec, value Element, value Idx, value Name,
                                value B) {
-  CAMLparam5(Vec, Element, Idx, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildInsertElement(Builder_val(B), Value_val(Vec),
                                            Value_val(Element), Value_val(Idx),
                                            String_val(Name))));
@@ -3177,7 +2931,7 @@
 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_shufflevector(value V1, value V2, value Mask, value Name,
                                value B) {
-  CAMLparam5(V1, V2, Mask, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildShuffleVector(Builder_val(B), Value_val(V1),
                                            Value_val(V2), Value_val(Mask),
                                            String_val(Name))));
@@ -3185,7 +2939,7 @@
 
 /* llvalue -> int -> string -> llbuilder -> llvalue */
 value llvm_build_extractvalue(value Aggregate, value Idx, value Name, value B) {
-  CAMLparam4(Aggregate, Idx, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildExtractValue(Builder_val(B), Value_val(Aggregate),
                                           Int_val(Idx), String_val(Name))));
 }
@@ -3193,7 +2947,7 @@
 /* llvalue -> llvalue -> int -> string -> llbuilder -> llvalue */
 value llvm_build_insertvalue(value Aggregate, value Val, value Idx, value Name,
                              value B) {
-  CAMLparam5(Aggregate, Val, Idx, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(LLVMBuildInsertValue(Builder_val(B), Value_val(Aggregate),
                                          Value_val(Val), Int_val(Idx),
                                          String_val(Name))));
@@ -3201,14 +2955,14 @@
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_is_null(value Val, value Name, value B) {
-  CAMLparam3(Val, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(
       LLVMBuildIsNull(Builder_val(B), Value_val(Val), String_val(Name))));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_is_not_null(value Val, value Name, value B) {
-  CAMLparam3(Val, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(to_val(
       LLVMBuildIsNotNull(Builder_val(B), Value_val(Val), String_val(Name))));
 }
@@ -3216,7 +2970,7 @@
 /* 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);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildPtrDiff2(Builder_val(B), Type_val(ElemTy), Value_val(LHS),
                                Value_val(RHS), String_val(Name))));
@@ -3224,7 +2978,7 @@
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_freeze(value X, value Name, value B) {
-  CAMLparam3(X, Name, B);
+  CAMLparam2(Name, B);
   CAMLreturn(
       to_val(LLVMBuildFreeze(Builder_val(B), Value_val(X), String_val(Name))));
 }
@@ -3283,54 +3037,45 @@
 
 /* llmemorybuffer -> unit */
 value llvm_memorybuffer_dispose(value MemBuf) {
-  CAMLparam1(MemBuf);
   LLVMDisposeMemoryBuffer(MemoryBuffer_val(MemBuf));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*===-- Pass Managers -----------------------------------------------------===*/
 
 /* unit -> [ `Module ] PassManager.t */
 value llvm_passmanager_create(value Unit) {
-  CAMLparam1(Unit);
-  CAMLreturn(to_val(LLVMCreatePassManager()));
+  return to_val(LLVMCreatePassManager());
 }
 
 /* llmodule -> [ `Function ] PassManager.t */
 value llvm_passmanager_create_function(value Module) {
-  CAMLparam1(Module);
-  CAMLreturn(
-      to_val(LLVMCreateFunctionPassManagerForModule(Module_val(Module))));
+  return to_val(LLVMCreateFunctionPassManagerForModule(Module_val(Module)));
 }
 
 /* llmodule -> [ `Function ] PassManager.t -> bool */
 value llvm_passmanager_run_module(value M, value PM) {
-  CAMLparam2(M, PM);
-  CAMLreturn(Val_bool(LLVMRunPassManager(PassManager_val(PM), Module_val(M))));
+  return Val_bool(LLVMRunPassManager(PassManager_val(PM), Module_val(M)));
 }
 
 /* [ `Function ] PassManager.t -> bool */
 value llvm_passmanager_initialize(value FPM) {
-  CAMLparam1(FPM);
-  CAMLreturn(Val_bool(LLVMInitializeFunctionPassManager(PassManager_val(FPM))));
+  return Val_bool(LLVMInitializeFunctionPassManager(PassManager_val(FPM)));
 }
 
 /* llvalue -> [ `Function ] PassManager.t -> bool */
 value llvm_passmanager_run_function(value F, value FPM) {
-  CAMLparam2(F, FPM);
-  CAMLreturn(
-      Val_bool(LLVMRunFunctionPassManager(PassManager_val(FPM), Value_val(F))));
+  return Val_bool(
+      LLVMRunFunctionPassManager(PassManager_val(FPM), Value_val(F)));
 }
 
 /* [ `Function ] PassManager.t -> bool */
 value llvm_passmanager_finalize(value FPM) {
-  CAMLparam1(FPM);
-  CAMLreturn(Val_bool(LLVMFinalizeFunctionPassManager(PassManager_val(FPM))));
+  return Val_bool(LLVMFinalizeFunctionPassManager(PassManager_val(FPM)));
 }
 
 /* PassManager.any PassManager.t -> unit */
 value llvm_passmanager_dispose(value PM) {
-  CAMLparam1(PM);
   LLVMDisposePassManager(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/target/target_ocaml.c b/llvm/bindings/ocaml/target/target_ocaml.c
--- a/llvm/bindings/ocaml/target/target_ocaml.c
+++ b/llvm/bindings/ocaml/target/target_ocaml.c
@@ -10,6 +10,9 @@
 |* 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"
@@ -80,7 +83,7 @@
 
 /* Llvm.llcontext -> DataLayout.t -> Llvm.lltype */
 value llvm_datalayout_intptr_type(value C, value DL) {
-  CAMLparam2(C, DL);
+  CAMLparam1(DL);
   LLVMTypeRef Type =
       LLVMIntPtrTypeInContext(Context_val(C), DataLayout_val(DL));
   CAMLreturn(to_val(Type));
@@ -88,13 +91,13 @@
 
 /* int -> DataLayout.t -> int */
 value llvm_datalayout_qualified_pointer_size(value AS, value DL) {
-  CAMLparam2(AS, DL);
+  CAMLparam1(DL);
   CAMLreturn(Val_int(LLVMPointerSizeForAS(DataLayout_val(DL), Int_val(AS))));
 }
 
 /* Llvm.llcontext -> int -> DataLayout.t -> Llvm.lltype */
 value llvm_datalayout_qualified_intptr_type(value C, value AS, value DL) {
-  CAMLparam3(C, AS, DL);
+  CAMLparam1(DL);
   LLVMTypeRef Type = LLVMIntPtrTypeForASInContext(
       Context_val(C), DataLayout_val(DL), Int_val(AS));
   CAMLreturn(to_val(Type));
@@ -102,62 +105,62 @@
 
 /* Llvm.lltype -> DataLayout.t -> Int64.t */
 value llvm_datalayout_size_in_bits(value Ty, value DL) {
-  CAMLparam2(Ty, DL);
+  CAMLparam1(DL);
   CAMLreturn(
       caml_copy_int64(LLVMSizeOfTypeInBits(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> Int64.t */
 value llvm_datalayout_store_size(value Ty, value DL) {
-  CAMLparam2(Ty, DL);
+  CAMLparam1(DL);
   CAMLreturn(
       caml_copy_int64(LLVMStoreSizeOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> Int64.t */
 value llvm_datalayout_abi_size(value Ty, value DL) {
-  CAMLparam2(Ty, DL);
+  CAMLparam1(DL);
   CAMLreturn(
       caml_copy_int64(LLVMABISizeOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> int */
 value llvm_datalayout_abi_align(value Ty, value DL) {
-  CAMLparam2(Ty, DL);
+  CAMLparam1(DL);
   CAMLreturn(Val_int(LLVMABIAlignmentOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> int */
 value llvm_datalayout_stack_align(value Ty, value DL) {
-  CAMLparam2(Ty, DL);
+  CAMLparam1(DL);
   CAMLreturn(
       Val_int(LLVMCallFrameAlignmentOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.lltype -> DataLayout.t -> int */
 value llvm_datalayout_preferred_align(value Ty, value DL) {
-  CAMLparam2(Ty, DL);
+  CAMLparam1(DL);
   CAMLreturn(
       Val_int(LLVMPreferredAlignmentOfType(DataLayout_val(DL), Type_val(Ty))));
 }
 
 /* Llvm.llvalue -> DataLayout.t -> int */
 value llvm_datalayout_preferred_align_of_global(value GlobalVar, value DL) {
-  CAMLparam2(GlobalVar, DL);
+  CAMLparam1(DL);
   CAMLreturn(Val_int(LLVMPreferredAlignmentOfGlobal(DataLayout_val(DL),
                                                     Value_val(GlobalVar))));
 }
 
 /* Llvm.lltype -> Int64.t -> DataLayout.t -> int */
 value llvm_datalayout_element_at_offset(value Ty, value Offset, value DL) {
-  CAMLparam3(Ty, Offset, DL);
+  CAMLparam2(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(value Ty, value Index, value DL) {
-  CAMLparam3(Ty, Index, DL);
+  CAMLparam2(Index, DL);
   CAMLreturn(caml_copy_int64(
       LLVMOffsetOfElement(DataLayout_val(DL), Type_val(Ty), Int_val(Index))));
 }
@@ -168,7 +171,7 @@
 
 /* unit -> string */
 value llvm_target_default_triple(value Unit) {
-  CAMLparam1(Unit);
+  CAMLparam0();
   CAMLlocal1(TripleStr);
   char *TripleCStr = LLVMGetDefaultTargetTriple();
   TripleStr = caml_copy_string(TripleCStr);
@@ -178,14 +181,12 @@
 
 /* unit -> Target.t option */
 value llvm_target_first(value Unit) {
-  CAMLparam1(Unit);
-  CAMLreturn(ptr_to_option(LLVMGetFirstTarget()));
+  return ptr_to_option(LLVMGetFirstTarget());
 }
 
 /* Target.t -> Target.t option */
 value llvm_target_succ(value Target) {
-  CAMLparam1(Target);
-  CAMLreturn(ptr_to_option(LLVMGetNextTarget(Target_val(Target))));
+  return ptr_to_option(LLVMGetNextTarget(Target_val(Target)));
 }
 
 /* string -> Target.t option */
@@ -208,32 +209,27 @@
 
 /* Target.t -> string */
 value llvm_target_name(value Target) {
-  CAMLparam1(Target);
-  CAMLreturn(caml_copy_string(LLVMGetTargetName(Target_val(Target))));
+  return caml_copy_string(LLVMGetTargetName(Target_val(Target)));
 }
 
 /* Target.t -> string */
 value llvm_target_description(value Target) {
-  CAMLparam1(Target);
-  CAMLreturn(caml_copy_string(LLVMGetTargetDescription(Target_val(Target))));
+  return caml_copy_string(LLVMGetTargetDescription(Target_val(Target)));
 }
 
 /* Target.t -> bool */
 value llvm_target_has_jit(value Target) {
-  CAMLparam1(Target);
-  CAMLreturn(Val_bool(LLVMTargetHasJIT(Target_val(Target))));
+  return Val_bool(LLVMTargetHasJIT(Target_val(Target)));
 }
 
 /* Target.t -> bool */
 value llvm_target_has_target_machine(value Target) {
-  CAMLparam1(Target);
-  CAMLreturn(Val_bool(LLVMTargetHasTargetMachine(Target_val(Target))));
+  return Val_bool(LLVMTargetHasTargetMachine(Target_val(Target)));
 }
 
 /* Target.t -> bool */
 value llvm_target_has_asm_backend(value Target) {
-  CAMLparam1(Target);
-  CAMLreturn(Val_bool(LLVMTargetHasAsmBackend(Target_val(Target))));
+  return Val_bool(LLVMTargetHasAsmBackend(Target_val(Target)));
 }
 
 /*===---- Target Machine --------------------------------------------------===*/
@@ -333,7 +329,7 @@
 
 /* bool -> TargetMachine.t -> unit */
 value llvm_targetmachine_set_verbose_asm(value Verb, value Machine) {
-  CAMLparam2(Verb, Machine);
+  CAMLparam1(Machine);
   LLVMSetTargetMachineAsmVerbosity(TargetMachine_val(Machine), Bool_val(Verb));
   CAMLreturn(Val_unit);
 }
@@ -341,7 +337,7 @@
 /* Llvm.llmodule -> CodeGenFileType.t -> string -> TargetMachine.t -> unit */
 value llvm_targetmachine_emit_to_file(value Module, value FileType,
                                       value FileName, value Machine) {
-  CAMLparam4(Module, FileType, FileName, Machine);
+  CAMLparam2(FileName, Machine);
   char *ErrorMessage;
 
   if (LLVMTargetMachineEmitToFile(
@@ -372,7 +368,7 @@
 
 /* TargetMachine.t -> Llvm.PassManager.t -> unit */
 value llvm_targetmachine_add_analysis_passes(value PM, value Machine) {
-  CAMLparam2(PM, Machine);
+  CAMLparam1(Machine);
   LLVMAddAnalysisPasses(TargetMachine_val(Machine), PassManager_val(PM));
   CAMLreturn(Val_unit);
 }
diff --git a/llvm/bindings/ocaml/transforms/ipo/ipo_ocaml.c b/llvm/bindings/ocaml/transforms/ipo/ipo_ocaml.c
--- a/llvm/bindings/ocaml/transforms/ipo/ipo_ocaml.c
+++ b/llvm/bindings/ocaml/transforms/ipo/ipo_ocaml.c
@@ -10,6 +10,9 @@
 |* 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"
@@ -20,84 +23,72 @@
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_constant_merge(value PM) {
-  CAMLparam1(PM);
   LLVMAddConstantMergePass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_merge_functions(value PM) {
-  CAMLparam1(PM);
   LLVMAddMergeFunctionsPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_dead_arg_elimination(value PM) {
-  CAMLparam1(PM);
   LLVMAddDeadArgEliminationPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_function_attrs(value PM) {
-  CAMLparam1(PM);
   LLVMAddFunctionAttrsPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_function_inlining(value PM) {
-  CAMLparam1(PM);
   LLVMAddFunctionInliningPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_always_inliner(value PM) {
-  CAMLparam1(PM);
   LLVMAddAlwaysInlinerPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_global_dce(value PM) {
-  CAMLparam1(PM);
   LLVMAddGlobalDCEPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_global_optimizer(value PM) {
-  CAMLparam1(PM);
   LLVMAddGlobalOptimizerPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_ipsccp(value PM) {
-  CAMLparam1(PM);
   LLVMAddIPSCCPPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> all_but_main:bool -> unit */
 value llvm_add_internalize(value PM, value AllButMain) {
-  CAMLparam2(PM, AllButMain);
   LLVMAddInternalizePass(PassManager_val(PM), Bool_val(AllButMain));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_strip_dead_prototypes(value PM) {
-  CAMLparam1(PM);
   LLVMAddStripDeadPrototypesPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_strip_symbols(value PM) {
-  CAMLparam1(PM);
   LLVMAddStripSymbolsPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/transforms/passmgr_builder/passmgr_builder_ocaml.c b/llvm/bindings/ocaml/transforms/passmgr_builder/passmgr_builder_ocaml.c
--- a/llvm/bindings/ocaml/transforms/passmgr_builder/passmgr_builder_ocaml.c
+++ b/llvm/bindings/ocaml/transforms/passmgr_builder/passmgr_builder_ocaml.c
@@ -10,6 +10,9 @@
 |* 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/custom.h"
@@ -40,27 +43,26 @@
 
 /* t -> unit */
 value llvm_pmbuilder_create(value Unit) {
-  CAMLparam1(Unit);
-  CAMLreturn(alloc_pmbuilder(LLVMPassManagerBuilderCreate()));
+  return alloc_pmbuilder(LLVMPassManagerBuilderCreate());
 }
 
 /* int -> t -> unit */
 value llvm_pmbuilder_set_opt_level(value OptLevel, value PMB) {
-  CAMLparam2(OptLevel, PMB);
+  CAMLparam1(PMB);
   LLVMPassManagerBuilderSetOptLevel(PMBuilder_val(PMB), Int_val(OptLevel));
   CAMLreturn(Val_unit);
 }
 
 /* int -> t -> unit */
 value llvm_pmbuilder_set_size_level(value SizeLevel, value PMB) {
-  CAMLparam2(SizeLevel, PMB);
+  CAMLparam1(PMB);
   LLVMPassManagerBuilderSetSizeLevel(PMBuilder_val(PMB), Int_val(SizeLevel));
   CAMLreturn(Val_unit);
 }
 
 /* int -> t -> unit */
 value llvm_pmbuilder_use_inliner_with_threshold(value Threshold, value PMB) {
-  CAMLparam2(Threshold, PMB);
+  CAMLparam1(PMB);
   LLVMPassManagerBuilderSetOptLevel(PMBuilder_val(PMB), Int_val(Threshold));
   CAMLreturn(Val_unit);
 }
@@ -68,7 +70,7 @@
 /* bool -> t -> unit */
 value llvm_pmbuilder_set_disable_unit_at_a_time(value DisableUnitAtATime,
                                                 value PMB) {
-  CAMLparam2(DisableUnitAtATime, PMB);
+  CAMLparam1(PMB);
   LLVMPassManagerBuilderSetDisableUnitAtATime(PMBuilder_val(PMB),
                                               Bool_val(DisableUnitAtATime));
   CAMLreturn(Val_unit);
@@ -76,7 +78,7 @@
 
 /* bool -> t -> unit */
 value llvm_pmbuilder_set_disable_unroll_loops(value DisableUnroll, value PMB) {
-  CAMLparam2(DisableUnroll, PMB);
+  CAMLparam1(PMB);
   LLVMPassManagerBuilderSetDisableUnrollLoops(PMBuilder_val(PMB),
                                               Bool_val(DisableUnroll));
   CAMLreturn(Val_unit);
@@ -84,7 +86,7 @@
 
 /* [ `Function ] Llvm.PassManager.t -> t -> unit */
 value llvm_pmbuilder_populate_function_pass_manager(value PM, value PMB) {
-  CAMLparam2(PM, PMB);
+  CAMLparam1(PMB);
   LLVMPassManagerBuilderPopulateFunctionPassManager(PMBuilder_val(PMB),
                                                     PassManager_val(PM));
   CAMLreturn(Val_unit);
@@ -92,7 +94,7 @@
 
 /* [ `Module ] Llvm.PassManager.t -> t -> unit */
 value llvm_pmbuilder_populate_module_pass_manager(value PM, value PMB) {
-  CAMLparam2(PM, PMB);
+  CAMLparam1(PMB);
   LLVMPassManagerBuilderPopulateModulePassManager(PMBuilder_val(PMB),
                                                   PassManager_val(PM));
   CAMLreturn(Val_unit);
diff --git a/llvm/bindings/ocaml/transforms/scalar_opts/scalar_opts_ocaml.c b/llvm/bindings/ocaml/transforms/scalar_opts/scalar_opts_ocaml.c
--- a/llvm/bindings/ocaml/transforms/scalar_opts/scalar_opts_ocaml.c
+++ b/llvm/bindings/ocaml/transforms/scalar_opts/scalar_opts_ocaml.c
@@ -10,6 +10,9 @@
 |* 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"
@@ -21,274 +24,235 @@
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_aggressive_dce(value PM) {
-  CAMLparam1(PM);
   LLVMAddAggressiveDCEPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 value llvm_add_dce(value PM) {
-  CAMLparam1(PM);
   LLVMAddDCEPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_alignment_from_assumptions(value PM) {
-  CAMLparam1(PM);
   LLVMAddAlignmentFromAssumptionsPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_cfg_simplification(value PM) {
-  CAMLparam1(PM);
   LLVMAddCFGSimplificationPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_dead_store_elimination(value PM) {
-  CAMLparam1(PM);
   LLVMAddDeadStoreEliminationPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_scalarizer(value PM) {
-  CAMLparam1(PM);
   LLVMAddScalarizerPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_merged_load_store_motion(value PM) {
-  CAMLparam1(PM);
   LLVMAddMergedLoadStoreMotionPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_gvn(value PM) {
-  CAMLparam1(PM);
   LLVMAddGVNPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_ind_var_simplify(value PM) {
-  CAMLparam1(PM);
   LLVMAddIndVarSimplifyPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_instruction_combining(value PM) {
-  CAMLparam1(PM);
   LLVMAddInstructionCombiningPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_jump_threading(value PM) {
-  CAMLparam1(PM);
   LLVMAddJumpThreadingPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_licm(value PM) {
-  CAMLparam1(PM);
   LLVMAddLICMPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_loop_deletion(value PM) {
-  CAMLparam1(PM);
   LLVMAddLoopDeletionPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_loop_idiom(value PM) {
-  CAMLparam1(PM);
   LLVMAddLoopIdiomPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_loop_rotate(value PM) {
-  CAMLparam1(PM);
   LLVMAddLoopRotatePass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_loop_reroll(value PM) {
-  CAMLparam1(PM);
   LLVMAddLoopRerollPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_loop_unroll(value PM) {
-  CAMLparam1(PM);
   LLVMAddLoopUnrollPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_memcpy_opt(value PM) {
-  CAMLparam1(PM);
   LLVMAddMemCpyOptPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_partially_inline_lib_calls(value PM) {
-  CAMLparam1(PM);
   LLVMAddPartiallyInlineLibCallsPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_lower_atomic(value PM) {
-  CAMLparam1(PM);
   LLVMAddLowerAtomicPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_lower_switch(value PM) {
-  CAMLparam1(PM);
   LLVMAddLowerSwitchPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_promote_memory_to_register(value PM) {
-  CAMLparam1(PM);
   LLVMAddPromoteMemoryToRegisterPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_reassociation(value PM) {
-  CAMLparam1(PM);
   LLVMAddReassociatePass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_sccp(value PM) {
-  CAMLparam1(PM);
   LLVMAddSCCPPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_scalar_repl_aggregates(value PM) {
-  CAMLparam1(PM);
   LLVMAddScalarReplAggregatesPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_scalar_repl_aggregates_ssa(value PM) {
-  CAMLparam1(PM);
   LLVMAddScalarReplAggregatesPassSSA(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* int -> [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_scalar_repl_aggregates_with_threshold(value threshold,
                                                      value PM) {
-  CAMLparam2(threshold, PM);
   LLVMAddScalarReplAggregatesPassWithThreshold(PassManager_val(PM),
                                                Int_val(threshold));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_simplify_lib_calls(value PM) {
-  CAMLparam1(PM);
   LLVMAddSimplifyLibCallsPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_tail_call_elimination(value PM) {
-  CAMLparam1(PM);
   LLVMAddTailCallEliminationPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_demote_memory_to_register(value PM) {
-  CAMLparam1(PM);
   LLVMAddDemoteMemoryToRegisterPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_verifier(value PM) {
-  CAMLparam1(PM);
   LLVMAddVerifierPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_correlated_value_propagation(value PM) {
-  CAMLparam1(PM);
   LLVMAddCorrelatedValuePropagationPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_early_cse(value PM) {
-  CAMLparam1(PM);
   LLVMAddEarlyCSEPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_lower_expect_intrinsic(value PM) {
-  CAMLparam1(PM);
   LLVMAddLowerExpectIntrinsicPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_lower_constant_intrinsics(value PM) {
-  CAMLparam1(PM);
   LLVMAddLowerConstantIntrinsicsPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_type_based_alias_analysis(value PM) {
-  CAMLparam1(PM);
   LLVMAddTypeBasedAliasAnalysisPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_scoped_no_alias_aa(value PM) {
-  CAMLparam1(PM);
   LLVMAddScopedNoAliasAAPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_basic_alias_analysis(value PM) {
-  CAMLparam1(PM);
   LLVMAddBasicAliasAnalysisPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_unify_function_exit_nodes(value PM) {
-  CAMLparam1(PM);
   LLVMAddUnifyFunctionExitNodesPass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/transforms/utils/transform_utils_ocaml.c b/llvm/bindings/ocaml/transforms/utils/transform_utils_ocaml.c
--- a/llvm/bindings/ocaml/transforms/utils/transform_utils_ocaml.c
+++ b/llvm/bindings/ocaml/transforms/utils/transform_utils_ocaml.c
@@ -29,6 +29,5 @@
 
 /* llmodule -> llmodule */
 value llvm_clone_module(value M) {
-  CAMLparam1(M);
-  CAMLreturn(to_val(LLVMCloneModule(Module_val(M))));
+  return to_val(LLVMCloneModule(Module_val(M)));
 }
diff --git a/llvm/bindings/ocaml/transforms/vectorize/vectorize_ocaml.c b/llvm/bindings/ocaml/transforms/vectorize/vectorize_ocaml.c
--- a/llvm/bindings/ocaml/transforms/vectorize/vectorize_ocaml.c
+++ b/llvm/bindings/ocaml/transforms/vectorize/vectorize_ocaml.c
@@ -10,6 +10,9 @@
 |* 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"
@@ -20,14 +23,12 @@
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_loop_vectorize(value PM) {
-  CAMLparam1(PM);
   LLVMAddLoopVectorizePass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 value llvm_add_slp_vectorize(value PM) {
-  CAMLparam1(PM);
   LLVMAddSLPVectorizePass(PassManager_val(PM));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }