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"
@@ -42,23 +45,20 @@
 
 /* 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 */
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);
@@ -140,42 +129,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 --------------------------------------------===*/
@@ -197,7 +178,7 @@
 }
 
 static void llvm_remove_diagnostic_handler(value C) {
-  CAMLparam1(C);
+  CAMLparam0();
   LLVMContextRef context = Context_val(C);
   if (LLVMContextGetDiagnosticHandler(context) ==
       llvm_diagnostic_handler_trampoline) {
@@ -210,7 +191,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) {
@@ -230,28 +211,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));
@@ -271,32 +245,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))));
@@ -304,78 +275,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))
@@ -386,25 +350,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);
@@ -412,21 +374,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);
@@ -436,37 +398,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);
@@ -479,84 +437,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);
@@ -566,7 +511,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);
@@ -576,20 +521,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);
@@ -606,7 +549,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);
@@ -616,7 +559,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);
@@ -626,13 +569,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));
@@ -641,19 +584,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);
@@ -668,27 +609,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);
@@ -703,82 +641,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 {
@@ -816,7 +741,7 @@
   } while (0)
 
 value llvm_classify_value(value V) {
-  CAMLparam1(V);
+  CAMLparam0();
   CAMLlocal1(Result);
   LLVMValueRef Val = Value_val(V);
   if (!Val) {
@@ -858,27 +783,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);
@@ -889,41 +812,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));
@@ -938,111 +856,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);
@@ -1051,22 +951,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);
@@ -1082,7 +978,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));
@@ -1098,81 +994,71 @@
 
 /* llmodule -> string -> llvalue -> unit */
 value llvm_append_namedmd(value M, value Name, value Val) {
-  CAMLparam3(M, Name, Val);
   LLVMAddNamedMetadataOperand(Module_val(M), String_val(Name), Value_val(Val));
-  CAMLreturn(Val_unit);
+  return 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);
-  CAMLreturn(
-      to_val(LLVMConstInt(Type_val(IntTy), Int64_val(N), Bool_val(SExt))));
+  return 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);
-  CAMLreturn(to_val(LLVMConstIntOfStringAndSize(
-      Type_val(IntTy), String_val(S), caml_string_length(S), Int_val(Radix))));
+  return 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))));
 }
@@ -1180,22 +1066,22 @@
 /*--... Operations on composite constants ..................................--*/
 
 /* llcontext -> string -> llvalue */
-value llvm_const_string(value Context, value Str, value NullTerminate) {
-  CAMLparam3(Context, Str, NullTerminate);
+value llvm_const_string(value Context, value 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, value NullTerminate) {
-  CAMLparam3(Context, Str, NullTerminate);
+value llvm_const_stringz(value Context, value 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);
@@ -1205,7 +1091,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 =
@@ -1216,7 +1102,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 =
@@ -1227,7 +1113,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 =
@@ -1248,190 +1134,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 */
 value llvm_const_element(value Const, value N) {
-  CAMLparam2(Const, N);
-  CAMLreturn(to_val(LLVMGetElementAsConstant(Value_val(Const), Int_val(N))));
+  return to_val(LLVMGetElementAsConstant(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 =
@@ -1442,7 +1302,7 @@
 
 /* llvalue -> llvalue array -> llvalue */
 value llvm_const_in_bounds_gep(value ConstantVal, value Indices) {
-  CAMLparam2(ConstantVal, Indices);
+  CAMLparam1(Indices);
   unsigned Length = Wosize_val(Indices);
   LLVMValueRef *Temp = alloc_temp(Indices);
   LLVMValueRef Value =
@@ -1452,165 +1312,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))));
@@ -1618,107 +1456,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 =
@@ -1739,26 +1563,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 .....................................--*/
@@ -1768,7 +1586,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)) {
@@ -1784,7 +1602,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)) {
@@ -1799,14 +1617,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));
@@ -1816,7 +1634,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));
@@ -1826,83 +1644,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 ..............................................--*/
@@ -1910,7 +1716,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))));
@@ -1923,7 +1729,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)) {
@@ -1938,14 +1744,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");
@@ -1954,57 +1760,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);
@@ -2019,14 +1819,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);
@@ -2039,13 +1838,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);
@@ -2060,40 +1858,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);
@@ -2108,9 +1901,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,
@@ -2118,48 +1910,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))));
 }
@@ -2168,9 +1955,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,
@@ -2178,68 +1964,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);
@@ -2254,14 +2031,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);
@@ -2271,99 +2047,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);
@@ -2372,7 +2133,7 @@
 
 /* llvalue -> (llvalue * llbasicblock) list */
 value llvm_incoming(value Phi) {
-  CAMLparam1(Phi);
+  CAMLparam0();
   CAMLlocal5(Hd, Tl, V, BB, List);
   LLVMValueRef PhiNode = Value_val(Phi);
 
@@ -2396,9 +2157,8 @@
 
 /* llvalue -> unit */
 value llvm_delete_instruction(value Instruction) {
-  CAMLparam1(Instruction);
   LLVMInstructionEraseFromParent(Value_val(Instruction));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*===-- Instruction builders ----------------------------------------------===*/
@@ -2423,13 +2183,11 @@
 
 /* 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 */
 value llvm_position_builder(value Pos, value B) {
-  CAMLparam2(Pos, B);
   if (Tag_val(Pos) == 0) {
     LLVMBasicBlockRef BB = BasicBlock_val(Field(Pos, 0));
     LLVMPositionBuilderAtEnd(Builder_val(B), BB);
@@ -2437,7 +2195,7 @@
     LLVMValueRef I = Value_val(Field(Pos, 0));
     LLVMPositionBuilderBefore(Builder_val(B), I);
   }
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llbuilder -> llbasicblock */
@@ -2451,25 +2209,22 @@
 
 /* llvalue -> string -> llbuilder -> unit */
 value llvm_insert_into_builder(value I, value Name, value B) {
-  CAMLparam3(I, Name, B);
   LLVMInsertIntoBuilderWithName(Builder_val(B), Value_val(I), String_val(Name));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*--... Metadata ...........................................................--*/
 
 /* llbuilder -> llvalue -> unit */
 value llvm_set_current_debug_location(value B, value V) {
-  CAMLparam2(B, V);
   LLVMSetCurrentDebugLocation(Builder_val(B), Value_val(V));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llbuilder -> unit */
 value llvm_clear_current_debug_location(value B) {
-  CAMLparam1(B);
   LLVMSetCurrentDebugLocation(Builder_val(B), NULL);
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* llbuilder -> llvalue option */
@@ -2480,118 +2235,100 @@
 
 /* llbuilder -> llvalue -> unit */
 value llvm_set_inst_debug_location(value B, value V) {
-  CAMLparam2(B, V);
   LLVMSetInstDebugLocation(Builder_val(B), Value_val(V));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /*--... Terminators ........................................................--*/
 
 /* llbuilder -> llvalue */
 value llvm_build_ret_void(value B) {
-  CAMLparam1(B);
-  CAMLreturn(to_val(LLVMBuildRetVoid(Builder_val(B))));
+  return to_val(LLVMBuildRetVoid(Builder_val(B)));
 }
 
 /* llvalue -> llbuilder -> llvalue */
 value llvm_build_ret(value Val, value B) {
-  CAMLparam2(Val, B);
-  CAMLreturn(to_val(LLVMBuildRet(Builder_val(B), Value_val(Val))));
+  return to_val(LLVMBuildRet(Builder_val(B), Value_val(Val)));
 }
 
 /* llvalue array -> llbuilder -> llvalue */
 value llvm_build_aggregate_ret(value RetVals, value B) {
-  CAMLparam2(RetVals, B);
   unsigned Length = Wosize_val(RetVals);
   LLVMValueRef *Temp = alloc_temp(RetVals);
   LLVMValueRef Value = LLVMBuildAggregateRet(Builder_val(B), Temp, Length);
   free(Temp);
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* llbasicblock -> llbuilder -> llvalue */
 value llvm_build_br(value BB, value B) {
-  CAMLparam2(BB, B);
-  CAMLreturn(to_val(LLVMBuildBr(Builder_val(B), BasicBlock_val(BB))));
+  return 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);
-  CAMLreturn(
-      to_val(LLVMBuildCondBr(Builder_val(B), Value_val(If),
-                             BasicBlock_val(Then), BasicBlock_val(Else))));
+  return to_val(LLVMBuildCondBr(Builder_val(B), Value_val(If),
+                                BasicBlock_val(Then), BasicBlock_val(Else)));
 }
 
 /* llvalue -> llbasicblock -> int -> llbuilder -> llvalue */
 value llvm_build_switch(value Of, value Else, value EstimatedCount, value B) {
-  CAMLparam4(Of, Else, EstimatedCount, B);
-  CAMLreturn(
-      to_val(LLVMBuildSwitch(Builder_val(B), Value_val(Of),
-                             BasicBlock_val(Else), Int_val(EstimatedCount))));
+  return to_val(LLVMBuildSwitch(Builder_val(B), Value_val(Of),
+                                BasicBlock_val(Else), Int_val(EstimatedCount)));
 }
 
 /* lltype -> string -> llbuilder -> llvalue */
 value llvm_build_malloc(value Ty, value Name, value B) {
-  CAMLparam3(Ty, Name, B);
-  CAMLreturn(
-      to_val(LLVMBuildMalloc(Builder_val(B), Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildArrayMalloc(Builder_val(B), Type_val(Ty),
-                                         Value_val(Val), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFree(Builder_val(B), Value_val(P))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildIndirectBr(Builder_val(B), Value_val(Addr),
-                                        Int_val(EstimatedDests))));
+  return 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);
   unsigned Length = Wosize_val(Args);
   LLVMValueRef *Temp = alloc_temp(Args);
   LLVMValueRef Value = LLVMBuildInvoke2(
       Builder_val(B), Type_val(FnTy), Value_val(Fn), Temp, Length,
       BasicBlock_val(Then), BasicBlock_val(Catch), String_val(Name));
   free(Temp);
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* lltype -> llvalue -> llvalue array -> llbasicblock -> llbasicblock ->
@@ -2604,297 +2341,252 @@
 /* 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);
-  CAMLreturn(to_val(LLVMBuildLandingPad(Builder_val(B), Type_val(Ty),
-                                        Value_val(PersFn), Int_val(NumClauses),
-                                        String_val(Name))));
+  return to_val(LLVMBuildLandingPad(Builder_val(B), Type_val(Ty),
+                                    Value_val(PersFn), Int_val(NumClauses),
+                                    String_val(Name)));
 }
 
 /* llvalue -> llvalue -> unit */
 value llvm_add_clause(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);
-  CAMLreturn(to_val(LLVMBuildResume(Builder_val(B), Value_val(Exn))));
+  return to_val(LLVMBuildResume(Builder_val(B), Value_val(Exn)));
 }
 
 /* llbuilder -> llvalue */
 value llvm_build_unreachable(value B) {
-  CAMLparam1(B);
-  CAMLreturn(to_val(LLVMBuildUnreachable(Builder_val(B))));
+  return to_val(LLVMBuildUnreachable(Builder_val(B)));
 }
 
 /*--... Arithmetic .........................................................--*/
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_add(value LHS, value RHS, value Name, value B) {
-  CAMLparam4(LHS, RHS, Name, B);
-  CAMLreturn(to_val(LLVMBuildAdd(Builder_val(B), Value_val(LHS), Value_val(RHS),
-                                 String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildNSWAdd(Builder_val(B), Value_val(LHS),
-                                    Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildNUWAdd(Builder_val(B), Value_val(LHS),
-                                    Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFAdd(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildSub(Builder_val(B), Value_val(LHS), Value_val(RHS),
-                                 String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildNSWSub(Builder_val(B), Value_val(LHS),
-                                    Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildNUWSub(Builder_val(B), Value_val(LHS),
-                                    Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFSub(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildMul(Builder_val(B), Value_val(LHS), Value_val(RHS),
-                                 String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildNSWMul(Builder_val(B), Value_val(LHS),
-                                    Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildNUWMul(Builder_val(B), Value_val(LHS),
-                                    Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFMul(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildUDiv(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildSDiv(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildExactSDiv(Builder_val(B), Value_val(LHS),
-                                       Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFDiv(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildURem(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildSRem(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFRem(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildShl(Builder_val(B), Value_val(LHS), Value_val(RHS),
-                                 String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildLShr(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildAShr(Builder_val(B), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildAnd(Builder_val(B), Value_val(LHS), Value_val(RHS),
-                                 String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildOr(Builder_val(B), Value_val(LHS), Value_val(RHS),
-                                String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildXor(Builder_val(B), Value_val(LHS), Value_val(RHS),
-                                 String_val(Name))));
+  return 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);
-  CAMLreturn(
-      to_val(LLVMBuildNeg(Builder_val(B), Value_val(X), String_val(Name))));
+  return 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);
-  CAMLreturn(
-      to_val(LLVMBuildNSWNeg(Builder_val(B), Value_val(X), String_val(Name))));
+  return 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);
-  CAMLreturn(
-      to_val(LLVMBuildNUWNeg(Builder_val(B), Value_val(X), String_val(Name))));
+  return 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);
-  CAMLreturn(
-      to_val(LLVMBuildFNeg(Builder_val(B), Value_val(X), String_val(Name))));
+  return 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);
-  CAMLreturn(
-      to_val(LLVMBuildNot(Builder_val(B), Value_val(X), String_val(Name))));
+  return to_val(LLVMBuildNot(Builder_val(B), Value_val(X), String_val(Name)));
 }
 
 /*--... Memory .............................................................--*/
 
 /* lltype -> string -> llbuilder -> llvalue */
 value llvm_build_alloca(value Ty, value Name, value B) {
-  CAMLparam3(Ty, Name, B);
-  CAMLreturn(
-      to_val(LLVMBuildAlloca(Builder_val(B), Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildArrayAlloca(Builder_val(B), Type_val(Ty),
-                                         Value_val(Size), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildLoad2(Builder_val(B), Type_val(Ty),
-                                   Value_val(Pointer), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(
-      LLVMBuildStore(Builder_val(B), Value_val(Value), Value_val(Pointer))));
+  return to_val(
+      LLVMBuildStore(Builder_val(B), Value_val(Value), Value_val(Pointer)));
 }
 
 /* AtomicRMWBinOp.t -> llvalue -> llvalue -> AtomicOrdering.t ->
    bool -> string -> llbuilder -> llvalue */
 value llvm_build_atomicrmw_native(value BinOp, value Ptr, value Val, value Ord,
                                   value ST, value Name, value B) {
-  CAMLparam5(BinOp, Ptr, Val, Ord, ST);
-  CAMLxparam2(Name, B);
   LLVMValueRef Instr;
   Instr = LLVMBuildAtomicRMW(Builder_val(B), Int_val(BinOp), Value_val(Ptr),
                              Value_val(Val), Int_val(Ord), Bool_val(ST));
   LLVMSetValueName(Instr, String_val(Name));
-  CAMLreturn(to_val(Instr));
+  return to_val(Instr);
 }
 
 value llvm_build_atomicrmw_bytecode(value *argv, int argn) {
@@ -2905,195 +2597,170 @@
 /* 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);
   unsigned Length = Wosize_val(Indices);
   LLVMValueRef *Temp = alloc_temp(Indices);
   LLVMValueRef Value =
       LLVMBuildGEP2(Builder_val(B), Type_val(Ty), Value_val(Pointer), Temp,
                     Length, String_val(Name));
   free(Temp);
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* 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);
   unsigned Length = Wosize_val(Indices);
   LLVMValueRef *Temp = alloc_temp(Indices);
   LLVMValueRef Value =
       LLVMBuildInBoundsGEP2(Builder_val(B), Type_val(Ty), Value_val(Pointer),
                             Temp, Length, String_val(Name));
   free(Temp);
-  CAMLreturn(to_val(Value));
+  return to_val(Value);
 }
 
 /* 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);
-  CAMLreturn(to_val(LLVMBuildStructGEP2(Builder_val(B), Type_val(Ty),
-                                        Value_val(Pointer), Int_val(Index),
-                                        String_val(Name))));
+  return to_val(LLVMBuildStructGEP2(Builder_val(B), Type_val(Ty),
+                                    Value_val(Pointer), Int_val(Index),
+                                    String_val(Name)));
 }
 
 /* string -> string -> llbuilder -> llvalue */
 value llvm_build_global_string(value Str, value Name, value B) {
-  CAMLparam3(Str, Name, B);
-  CAMLreturn(to_val(LLVMBuildGlobalString(Builder_val(B), String_val(Str),
-                                          String_val(Name))));
+  return to_val(
+      LLVMBuildGlobalString(Builder_val(B), String_val(Str), String_val(Name)));
 }
 
 /* string -> string -> llbuilder -> llvalue */
 value llvm_build_global_stringptr(value Str, value Name, value B) {
-  CAMLparam3(Str, Name, B);
-  CAMLreturn(to_val(LLVMBuildGlobalStringPtr(Builder_val(B), String_val(Str),
-                                             String_val(Name))));
+  return to_val(LLVMBuildGlobalStringPtr(Builder_val(B), String_val(Str),
+                                         String_val(Name)));
 }
 
 /*--... Casts ..............................................................--*/
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_trunc(value X, value Ty, value Name, value B) {
-  CAMLparam4(X, Ty, Name, B);
-  CAMLreturn(to_val(LLVMBuildTrunc(Builder_val(B), Value_val(X), Type_val(Ty),
-                                   String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildZExt(Builder_val(B), Value_val(X), Type_val(Ty),
-                                  String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildSExt(Builder_val(B), Value_val(X), Type_val(Ty),
-                                  String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFPToUI(Builder_val(B), Value_val(X), Type_val(Ty),
-                                    String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFPToSI(Builder_val(B), Value_val(X), Type_val(Ty),
-                                    String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildUIToFP(Builder_val(B), Value_val(X), Type_val(Ty),
-                                    String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildSIToFP(Builder_val(B), Value_val(X), Type_val(Ty),
-                                    String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFPTrunc(Builder_val(B), Value_val(X), Type_val(Ty),
-                                     String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFPExt(Builder_val(B), Value_val(X), Type_val(Ty),
-                                   String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildPtrToInt(Builder_val(B), Value_val(X),
-                                      Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildIntToPtr(Builder_val(B), Value_val(X),
-                                      Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildBitCast(Builder_val(B), Value_val(X), Type_val(Ty),
-                                     String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildZExtOrBitCast(Builder_val(B), Value_val(X),
-                                           Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildSExtOrBitCast(Builder_val(B), Value_val(X),
-                                           Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildTruncOrBitCast(Builder_val(B), Value_val(X),
-                                            Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildPointerCast(Builder_val(B), Value_val(X),
-                                         Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildIntCast(Builder_val(B), Value_val(X), Type_val(Ty),
-                                     String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildFPCast(Builder_val(B), Value_val(X), Type_val(Ty),
-                                    String_val(Name))));
+  return to_val(LLVMBuildFPCast(Builder_val(B), Value_val(X), Type_val(Ty),
+                                String_val(Name)));
 }
 
 /*--... Comparisons ........................................................--*/
 
 /* 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);
-  CAMLreturn(
-      to_val(LLVMBuildICmp(Builder_val(B), Int_val(Pred) + LLVMIntEQ,
-                           Value_val(LHS), Value_val(RHS), String_val(Name))));
+  return to_val(LLVMBuildICmp(Builder_val(B), Int_val(Pred) + LLVMIntEQ,
+                              Value_val(LHS), Value_val(RHS),
+                              String_val(Name)));
 }
 
 /* Fcmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_fcmp(value Pred, value LHS, value RHS, value Name, value B) {
-  CAMLparam5(Pred, LHS, RHS, Name, B);
-  CAMLreturn(to_val(LLVMBuildFCmp(Builder_val(B), Int_val(Pred), Value_val(LHS),
-                                  Value_val(RHS), String_val(Name))));
+  return to_val(LLVMBuildFCmp(Builder_val(B), Int_val(Pred), Value_val(LHS),
+                              Value_val(RHS), String_val(Name)));
 }
 
 /*--... Miscellaneous instructions .........................................--*/
@@ -3122,9 +2789,7 @@
 
 /* lltype -> string -> llbuilder -> value */
 value llvm_build_empty_phi(value Type, value Name, value B) {
-  CAMLparam3(Type, Name, B);
-  CAMLreturn(
-      to_val(LLVMBuildPhi(Builder_val(B), Type_val(Type), String_val(Name))));
+  return to_val(LLVMBuildPhi(Builder_val(B), Type_val(Type), String_val(Name)));
 }
 
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
@@ -3141,88 +2806,76 @@
 
 /* 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);
-  CAMLreturn(
-      to_val(LLVMBuildSelect(Builder_val(B), Value_val(If), Value_val(Then),
-                             Value_val(Else), String_val(Name))));
+  return to_val(LLVMBuildSelect(Builder_val(B), Value_val(If), Value_val(Then),
+                                Value_val(Else), String_val(Name)));
 }
 
 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 value llvm_build_va_arg(value List, value Ty, value Name, value B) {
-  CAMLparam4(List, Ty, Name, B);
-  CAMLreturn(to_val(LLVMBuildVAArg(Builder_val(B), Value_val(List),
-                                   Type_val(Ty), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(LLVMBuildExtractElement(Builder_val(B), Value_val(Vec),
-                                            Value_val(Idx), String_val(Name))));
+  return to_val(LLVMBuildExtractElement(Builder_val(B), Value_val(Vec),
+                                        Value_val(Idx), String_val(Name)));
 }
 
 /* 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);
-  CAMLreturn(to_val(LLVMBuildInsertElement(Builder_val(B), Value_val(Vec),
-                                           Value_val(Element), Value_val(Idx),
-                                           String_val(Name))));
+  return to_val(LLVMBuildInsertElement(Builder_val(B), Value_val(Vec),
+                                       Value_val(Element), Value_val(Idx),
+                                       String_val(Name)));
 }
 
 /* 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);
-  CAMLreturn(to_val(LLVMBuildShuffleVector(Builder_val(B), Value_val(V1),
-                                           Value_val(V2), Value_val(Mask),
-                                           String_val(Name))));
+  return to_val(LLVMBuildShuffleVector(Builder_val(B), Value_val(V1),
+                                       Value_val(V2), Value_val(Mask),
+                                       String_val(Name)));
 }
 
 /* llvalue -> int -> string -> llbuilder -> llvalue */
 value llvm_build_extractvalue(value Aggregate, value Idx, value Name, value B) {
-  CAMLparam4(Aggregate, Idx, Name, B);
-  CAMLreturn(to_val(LLVMBuildExtractValue(Builder_val(B), Value_val(Aggregate),
-                                          Int_val(Idx), String_val(Name))));
+  return to_val(LLVMBuildExtractValue(Builder_val(B), Value_val(Aggregate),
+                                      Int_val(Idx), String_val(Name)));
 }
 
 /* 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);
-  CAMLreturn(to_val(LLVMBuildInsertValue(Builder_val(B), Value_val(Aggregate),
-                                         Value_val(Val), Int_val(Idx),
-                                         String_val(Name))));
+  return to_val(LLVMBuildInsertValue(Builder_val(B), Value_val(Aggregate),
+                                     Value_val(Val), Int_val(Idx),
+                                     String_val(Name)));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_is_null(value Val, value Name, value B) {
-  CAMLparam3(Val, Name, B);
-  CAMLreturn(to_val(
-      LLVMBuildIsNull(Builder_val(B), Value_val(Val), String_val(Name))));
+  return 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);
-  CAMLreturn(to_val(
-      LLVMBuildIsNotNull(Builder_val(B), Value_val(Val), String_val(Name))));
+  return to_val(
+      LLVMBuildIsNotNull(Builder_val(B), Value_val(Val), String_val(Name)));
 }
 
 /* lltype -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_ptrdiff(value ElemTy, value LHS, value RHS, value Name,
                          value B) {
-  CAMLparam5(ElemTy, LHS, RHS, Name, B);
-  CAMLreturn(
-      to_val(LLVMBuildPtrDiff2(Builder_val(B), Type_val(ElemTy), Value_val(LHS),
-                               Value_val(RHS), String_val(Name))));
+  return to_val(LLVMBuildPtrDiff2(Builder_val(B), Type_val(ElemTy),
+                                  Value_val(LHS), Value_val(RHS),
+                                  String_val(Name)));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 value llvm_build_freeze(value X, value Name, value B) {
-  CAMLparam3(X, Name, B);
-  CAMLreturn(
-      to_val(LLVMBuildFreeze(Builder_val(B), Value_val(X), String_val(Name))));
+  return to_val(
+      LLVMBuildFreeze(Builder_val(B), Value_val(X), String_val(Name)));
 }
 
 /*===-- Memory buffers ----------------------------------------------------===*/
@@ -3279,54 +2932,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;
 }