diff --git a/llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c b/llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c
diff --git a/llvm/bindings/ocaml/executionengine/executionengine_ocaml.c b/llvm/bindings/ocaml/executionengine/executionengine_ocaml.c
@@ -29,7 +29,7 @@
 void llvm_raise(value Prototype, char *Message);
 
 /* unit -> bool */
-CAMLprim value llvm_ee_initialize(value Unit) {
+value llvm_ee_initialize(value Unit) {
   LLVMLinkInMCJIT();
 
   return Val_bool(!LLVMInitializeNativeTarget() &&
@@ -38,7 +38,7 @@ CAMLprim value llvm_ee_initialize(value Unit) {
 }
 
 /* llmodule -> llcompileroption -> ExecutionEngine.t */
-CAMLprim LLVMExecutionEngineRef llvm_ee_create(value OptRecordOpt, LLVMModuleRef M) {
+LLVMExecutionEngineRef llvm_ee_create(value OptRecordOpt, LLVMModuleRef M) {
   value OptRecord;
   LLVMExecutionEngineRef MCJIT;
   char *Error;
@@ -54,26 +54,26 @@ CAMLprim LLVMExecutionEngineRef llvm_ee_create(value OptRecordOpt, LLVMModuleRef
     Options.MCJMM = NULL;
   }
 
-  if (LLVMCreateMCJITCompilerForModule(&MCJIT, M, &Options,
-                                      sizeof(Options), &Error))
+  if (LLVMCreateMCJITCompilerForModule(&MCJIT, M, &Options, sizeof(Options),
+                                       &Error))
     llvm_raise(*caml_named_value("Llvm_executionengine.Error"), Error);
   return MCJIT;
 }
 
 /* ExecutionEngine.t -> unit */
-CAMLprim value llvm_ee_dispose(LLVMExecutionEngineRef EE) {
+value llvm_ee_dispose(LLVMExecutionEngineRef EE) {
   LLVMDisposeExecutionEngine(EE);
   return Val_unit;
 }
 
 /* llmodule -> ExecutionEngine.t -> unit */
-CAMLprim value llvm_ee_add_module(LLVMModuleRef M, LLVMExecutionEngineRef EE) {
+value llvm_ee_add_module(LLVMModuleRef M, LLVMExecutionEngineRef EE) {
   LLVMAddModule(EE, M);
   return Val_unit;
 }
 
 /* llmodule -> ExecutionEngine.t -> llmodule */
-CAMLprim value llvm_ee_remove_module(LLVMModuleRef M, LLVMExecutionEngineRef EE) {
+value llvm_ee_remove_module(LLVMModuleRef M, LLVMExecutionEngineRef EE) {
   LLVMModuleRef RemovedModule;
   char *Error;
   if (LLVMRemoveModule(EE, M, &RemovedModule, &Error))
@@ -82,24 +82,24 @@ CAMLprim value llvm_ee_remove_module(LLVMModuleRef M, LLVMExecutionEngineRef EE)
 }
 
 /* ExecutionEngine.t -> unit */
-CAMLprim value llvm_ee_run_static_ctors(LLVMExecutionEngineRef EE) {
+value llvm_ee_run_static_ctors(LLVMExecutionEngineRef EE) {
   LLVMRunStaticConstructors(EE);
   return Val_unit;
 }
 
 /* ExecutionEngine.t -> unit */
-CAMLprim value llvm_ee_run_static_dtors(LLVMExecutionEngineRef EE) {
+value llvm_ee_run_static_dtors(LLVMExecutionEngineRef EE) {
   LLVMRunStaticDestructors(EE);
   return Val_unit;
 }
 
 extern value llvm_alloc_data_layout(LLVMTargetDataRef TargetData);
 
 /* ExecutionEngine.t -> Llvm_target.DataLayout.t */
-CAMLprim value llvm_ee_get_data_layout(LLVMExecutionEngineRef EE) {
+value llvm_ee_get_data_layout(LLVMExecutionEngineRef EE) {
   value DataLayout;
   LLVMTargetDataRef OrigDataLayout;
-  char* TargetDataCStr;
+  char *TargetDataCStr;
 
   OrigDataLayout = LLVMGetExecutionEngineTargetData(EE);
   TargetDataCStr = LLVMCopyStringRepOfTargetData(OrigDataLayout);
@@ -110,18 +110,17 @@ CAMLprim value llvm_ee_get_data_layout(LLVMExecutionEngineRef EE) {
 }
 
 /* Llvm.llvalue -> int64 -> llexecutionengine -> unit */
-CAMLprim value llvm_ee_add_global_mapping(LLVMValueRef Global, value Ptr,
-                                          LLVMExecutionEngineRef EE) {
-  LLVMAddGlobalMapping(EE, Global, (void*) (Int64_val(Ptr)));
+value llvm_ee_add_global_mapping(LLVMValueRef Global, value Ptr,
+                                 LLVMExecutionEngineRef EE) {
+  LLVMAddGlobalMapping(EE, Global, (void *)(Int64_val(Ptr)));
   return Val_unit;
 }
 
-CAMLprim value llvm_ee_get_global_value_address(value Name,
-						LLVMExecutionEngineRef EE) {
-  return caml_copy_int64((int64_t) LLVMGetGlobalValueAddress(EE, String_val(Name)));
+value llvm_ee_get_global_value_address(value Name, LLVMExecutionEngineRef EE) {
+  return caml_copy_int64(
+      (int64_t)LLVMGetGlobalValueAddress(EE, String_val(Name)));
 }
 
-CAMLprim value llvm_ee_get_function_address(value Name,
-					    LLVMExecutionEngineRef EE) {
-  return caml_copy_int64((int64_t) LLVMGetFunctionAddress(EE, String_val(Name)));
+value llvm_ee_get_function_address(value Name, LLVMExecutionEngineRef EE) {
+  return caml_copy_int64((int64_t)LLVMGetFunctionAddress(EE, String_val(Name)));
 }
diff --git a/llvm/bindings/ocaml/irreader/irreader_ocaml.c b/llvm/bindings/ocaml/irreader/irreader_ocaml.c
@@ -21,8 +21,7 @@
 void llvm_raise(value Prototype, char *Message);
 
 /* Llvm.llcontext -> Llvm.llmemorybuffer -> Llvm.llmodule */
-CAMLprim value llvm_parse_ir(LLVMContextRef C,
-                             LLVMMemoryBufferRef MemBuf) {
+value llvm_parse_ir(LLVMContextRef C, LLVMMemoryBufferRef MemBuf) {
   CAMLparam0();
   CAMLlocal2(Variant, MessageVal);
   LLVMModuleRef M;
@@ -31,5 +30,5 @@ CAMLprim value llvm_parse_ir(LLVMContextRef C,
   if (LLVMParseIRInContext(C, MemBuf, &M, &Message))
     llvm_raise(*caml_named_value("Llvm_irreader.Error"), Message);
 
-  CAMLreturn((value) M);
+  CAMLreturn((value)M);
 }
diff --git a/llvm/bindings/ocaml/linker/linker_ocaml.c b/llvm/bindings/ocaml/linker/linker_ocaml.c
@@ -25,9 +25,10 @@
 void llvm_raise(value Prototype, char *Message);
 
 /* llmodule -> llmodule -> unit */
-CAMLprim value llvm_link_modules(LLVMModuleRef Dst, LLVMModuleRef Src) {
+value llvm_link_modules(LLVMModuleRef Dst, LLVMModuleRef Src) {
   if (LLVMLinkModules2(Dst, Src))
-    llvm_raise(*caml_named_value("Llvm_linker.Error"), LLVMCreateMessage("Linking failed"));
+    llvm_raise(*caml_named_value("Llvm_linker.Error"),
+               LLVMCreateMessage("Linking failed"));
 
   return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/llvm/llvm_ocaml.c b/llvm/bindings/ocaml/llvm/llvm_ocaml.c
diff --git a/llvm/bindings/ocaml/llvm/llvm_ocaml.h b/llvm/bindings/ocaml/llvm/llvm_ocaml.h
@@ -20,11 +20,22 @@
 
 #include "caml/alloc.h"
 #include "caml/custom.h"
+#include "caml/version.h"
+
+#if OCAML_VERSION < 41200
+/* operations on OCaml option values, defined by OCaml 4.12 */
+#define Val_none Val_int(0)
+#define Some_val(v) Field(v, 0)
+#define Tag_some 0
+#define Is_none(v) ((v) == Val_none)
+#define Is_some(v) Is_block(v)
+value caml_alloc_some(value);
+#endif
 
 /* Convert a C pointer to an OCaml option */
-CAMLprim value ptr_to_option(void *Ptr);
+value ptr_to_option(void *Ptr);
 
 /* Convert a C string into an OCaml string */
-CAMLprim value cstr_to_string(const char *Str, mlsize_t Len);
+value cstr_to_string(const char *Str, mlsize_t Len);
 
 #endif // LLVM_LLVM_OCAML_H
diff --git a/llvm/bindings/ocaml/target/CMakeLists.txt b/llvm/bindings/ocaml/target/CMakeLists.txt
@@ -2,4 +2,5 @@ add_ocaml_library(llvm_target
   OCAML    llvm_target
   OCAMLDEP llvm
   C        target_ocaml
+  CFLAGS   "-I${CMAKE_CURRENT_SOURCE_DIR}/../llvm"
   LLVM     Target)
diff --git a/llvm/bindings/ocaml/target/target_ocaml.c b/llvm/bindings/ocaml/target/target_ocaml.c
diff --git a/llvm/bindings/ocaml/transforms/ipo/ipo_ocaml.c b/llvm/bindings/ocaml/transforms/ipo/ipo_ocaml.c
@@ -20,85 +20,85 @@
 #include "caml/misc.h"
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_argument_promotion(LLVMPassManagerRef PM) {
+value llvm_add_argument_promotion(LLVMPassManagerRef PM) {
   LLVMAddArgumentPromotionPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_constant_merge(LLVMPassManagerRef PM) {
+value llvm_add_constant_merge(LLVMPassManagerRef PM) {
   LLVMAddConstantMergePass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_merge_functions(LLVMPassManagerRef PM) {
+value llvm_add_merge_functions(LLVMPassManagerRef PM) {
   LLVMAddMergeFunctionsPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_dead_arg_elimination(LLVMPassManagerRef PM) {
+value llvm_add_dead_arg_elimination(LLVMPassManagerRef PM) {
   LLVMAddDeadArgEliminationPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_function_attrs(LLVMPassManagerRef PM) {
+value llvm_add_function_attrs(LLVMPassManagerRef PM) {
   LLVMAddFunctionAttrsPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_function_inlining(LLVMPassManagerRef PM) {
+value llvm_add_function_inlining(LLVMPassManagerRef PM) {
   LLVMAddFunctionInliningPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_always_inliner(LLVMPassManagerRef PM) {
+value llvm_add_always_inliner(LLVMPassManagerRef PM) {
   LLVMAddAlwaysInlinerPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_global_dce(LLVMPassManagerRef PM) {
+value llvm_add_global_dce(LLVMPassManagerRef PM) {
   LLVMAddGlobalDCEPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_global_optimizer(LLVMPassManagerRef PM) {
+value llvm_add_global_optimizer(LLVMPassManagerRef PM) {
   LLVMAddGlobalOptimizerPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_prune_eh(LLVMPassManagerRef PM) {
+value llvm_add_prune_eh(LLVMPassManagerRef PM) {
   LLVMAddPruneEHPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_ipsccp(LLVMPassManagerRef PM) {
+value llvm_add_ipsccp(LLVMPassManagerRef PM) {
   LLVMAddIPSCCPPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> all_but_main:bool -> unit */
-CAMLprim value llvm_add_internalize(LLVMPassManagerRef PM, value AllButMain) {
+value llvm_add_internalize(LLVMPassManagerRef PM, value AllButMain) {
   LLVMAddInternalizePass(PM, Bool_val(AllButMain));
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_strip_dead_prototypes(LLVMPassManagerRef PM) {
+value llvm_add_strip_dead_prototypes(LLVMPassManagerRef PM) {
   LLVMAddStripDeadPrototypesPass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_strip_symbols(LLVMPassManagerRef PM) {
+value llvm_add_strip_symbols(LLVMPassManagerRef PM) {
   LLVMAddStripSymbolsPass(PM);
   return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/transforms/passmgr_builder/passmgr_builder_ocaml.c b/llvm/bindings/ocaml/transforms/passmgr_builder/passmgr_builder_ocaml.c
@@ -20,92 +20,83 @@
 #include "caml/custom.h"
 #include "caml/misc.h"
 
-#define PMBuilder_val(v)  (*(LLVMPassManagerBuilderRef *)(Data_custom_val(v)))
+#define PMBuilder_val(v) (*(LLVMPassManagerBuilderRef *)(Data_custom_val(v)))
 
 static void llvm_finalize_pmbuilder(value PMB) {
   LLVMPassManagerBuilderDispose(PMBuilder_val(PMB));
 }
 
 static struct custom_operations pmbuilder_ops = {
-  (char *) "Llvm_passmgr_builder.t",
-  llvm_finalize_pmbuilder,
-  custom_compare_default,
-  custom_hash_default,
-  custom_serialize_default,
-  custom_deserialize_default,
-  custom_compare_ext_default
-};
+    (char *)"Llvm_passmgr_builder.t", llvm_finalize_pmbuilder,
+    custom_compare_default,           custom_hash_default,
+    custom_serialize_default,         custom_deserialize_default,
+    custom_compare_ext_default};
 
 static value alloc_pmbuilder(LLVMPassManagerBuilderRef Ref) {
-  value Val = alloc_custom(&pmbuilder_ops,
-                           sizeof(LLVMPassManagerBuilderRef), 0, 1);
+  value Val =
+      alloc_custom(&pmbuilder_ops, sizeof(LLVMPassManagerBuilderRef), 0, 1);
   PMBuilder_val(Val) = Ref;
   return Val;
 }
 
 /* t -> unit */
-CAMLprim value llvm_pmbuilder_create(value Unit) {
+value llvm_pmbuilder_create(value Unit) {
   return alloc_pmbuilder(LLVMPassManagerBuilderCreate());
 }
 
 /* int -> t -> unit */
-CAMLprim value llvm_pmbuilder_set_opt_level(value OptLevel, value PMB) {
+value llvm_pmbuilder_set_opt_level(value OptLevel, value PMB) {
   LLVMPassManagerBuilderSetOptLevel(PMBuilder_val(PMB), Int_val(OptLevel));
   return Val_unit;
 }
 
 /* int -> t -> unit */
-CAMLprim value llvm_pmbuilder_set_size_level(value SizeLevel, value PMB) {
+value llvm_pmbuilder_set_size_level(value SizeLevel, value PMB) {
   LLVMPassManagerBuilderSetSizeLevel(PMBuilder_val(PMB), Int_val(SizeLevel));
   return Val_unit;
 }
 
 /* int -> t -> unit */
-CAMLprim value llvm_pmbuilder_use_inliner_with_threshold(
-                      value Threshold, value PMB) {
+value llvm_pmbuilder_use_inliner_with_threshold(value Threshold, value PMB) {
   LLVMPassManagerBuilderSetOptLevel(PMBuilder_val(PMB), Int_val(Threshold));
   return Val_unit;
 }
 
 /* bool -> t -> unit */
-CAMLprim value llvm_pmbuilder_set_disable_unit_at_a_time(
-                      value DisableUnitAtATime, value PMB) {
-  LLVMPassManagerBuilderSetDisableUnitAtATime(
-                      PMBuilder_val(PMB), Bool_val(DisableUnitAtATime));
+value llvm_pmbuilder_set_disable_unit_at_a_time(value DisableUnitAtATime,
+                                                value PMB) {
+  LLVMPassManagerBuilderSetDisableUnitAtATime(PMBuilder_val(PMB),
+                                              Bool_val(DisableUnitAtATime));
   return Val_unit;
 }
 
 /* bool -> t -> unit */
-CAMLprim value llvm_pmbuilder_set_disable_unroll_loops(
-                      value DisableUnroll, value PMB) {
-  LLVMPassManagerBuilderSetDisableUnrollLoops(
-                      PMBuilder_val(PMB), Bool_val(DisableUnroll));
+value llvm_pmbuilder_set_disable_unroll_loops(value DisableUnroll, value PMB) {
+  LLVMPassManagerBuilderSetDisableUnrollLoops(PMBuilder_val(PMB),
+                                              Bool_val(DisableUnroll));
   return Val_unit;
 }
 
 /* [ `Function ] Llvm.PassManager.t -> t -> unit */
-CAMLprim value llvm_pmbuilder_populate_function_pass_manager(
-                      LLVMPassManagerRef PM, value PMB) {
-  LLVMPassManagerBuilderPopulateFunctionPassManager(
-                      PMBuilder_val(PMB), PM);
+value llvm_pmbuilder_populate_function_pass_manager(LLVMPassManagerRef PM,
+                                                    value PMB) {
+  LLVMPassManagerBuilderPopulateFunctionPassManager(PMBuilder_val(PMB), PM);
   return Val_unit;
 }
 
 /* [ `Module ] Llvm.PassManager.t -> t -> unit */
-CAMLprim value llvm_pmbuilder_populate_module_pass_manager(
-                      LLVMPassManagerRef PM, value PMB) {
-  LLVMPassManagerBuilderPopulateModulePassManager(
-                      PMBuilder_val(PMB), PM);
+value llvm_pmbuilder_populate_module_pass_manager(LLVMPassManagerRef PM,
+                                                  value PMB) {
+  LLVMPassManagerBuilderPopulateModulePassManager(PMBuilder_val(PMB), PM);
   return Val_unit;
 }
 
 /* [ `Module ] Llvm.PassManager.t ->
    internalize:bool -> run_inliner:bool -> t -> unit */
-CAMLprim value llvm_pmbuilder_populate_lto_pass_manager(
-                      LLVMPassManagerRef PM, value Internalize, value RunInliner,
-                      value PMB) {
+value llvm_pmbuilder_populate_lto_pass_manager(LLVMPassManagerRef PM,
+                                               value Internalize,
+                                               value RunInliner, value PMB) {
   LLVMPassManagerBuilderPopulateLTOPassManager(
-                      PMBuilder_val(PMB), PM,
-                      Bool_val(Internalize), Bool_val(RunInliner));
+      PMBuilder_val(PMB), PM, Bool_val(Internalize), Bool_val(RunInliner));
   return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/transforms/scalar_opts/scalar_opts_ocaml.c b/llvm/bindings/ocaml/transforms/scalar_opts/scalar_opts_ocaml.c
@@ -21,241 +21,241 @@
 #include "caml/misc.h"
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_aggressive_dce(LLVMPassManagerRef PM) {
+value llvm_add_aggressive_dce(LLVMPassManagerRef PM) {
   LLVMAddAggressiveDCEPass(PM);
   return Val_unit;
 }
 
-CAMLprim value llvm_add_dce(LLVMPassManagerRef PM) {
+value llvm_add_dce(LLVMPassManagerRef PM) {
   LLVMAddDCEPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_alignment_from_assumptions(LLVMPassManagerRef PM) {
+value llvm_add_alignment_from_assumptions(LLVMPassManagerRef PM) {
   LLVMAddAlignmentFromAssumptionsPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_cfg_simplification(LLVMPassManagerRef PM) {
+value llvm_add_cfg_simplification(LLVMPassManagerRef PM) {
   LLVMAddCFGSimplificationPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_dead_store_elimination(LLVMPassManagerRef PM) {
+value llvm_add_dead_store_elimination(LLVMPassManagerRef PM) {
   LLVMAddDeadStoreEliminationPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_scalarizer(LLVMPassManagerRef PM) {
+value llvm_add_scalarizer(LLVMPassManagerRef PM) {
   LLVMAddScalarizerPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_merged_load_store_motion(LLVMPassManagerRef PM) {
+value llvm_add_merged_load_store_motion(LLVMPassManagerRef PM) {
   LLVMAddMergedLoadStoreMotionPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_gvn(LLVMPassManagerRef PM) {
+value llvm_add_gvn(LLVMPassManagerRef PM) {
   LLVMAddGVNPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_ind_var_simplify(LLVMPassManagerRef PM) {
+value llvm_add_ind_var_simplify(LLVMPassManagerRef PM) {
   LLVMAddIndVarSimplifyPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_instruction_combining(LLVMPassManagerRef PM) {
+value llvm_add_instruction_combining(LLVMPassManagerRef PM) {
   LLVMAddInstructionCombiningPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_jump_threading(LLVMPassManagerRef PM) {
+value llvm_add_jump_threading(LLVMPassManagerRef PM) {
   LLVMAddJumpThreadingPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_licm(LLVMPassManagerRef PM) {
+value llvm_add_licm(LLVMPassManagerRef PM) {
   LLVMAddLICMPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_loop_deletion(LLVMPassManagerRef PM) {
+value llvm_add_loop_deletion(LLVMPassManagerRef PM) {
   LLVMAddLoopDeletionPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_loop_idiom(LLVMPassManagerRef PM) {
+value llvm_add_loop_idiom(LLVMPassManagerRef PM) {
   LLVMAddLoopIdiomPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_loop_rotate(LLVMPassManagerRef PM) {
+value llvm_add_loop_rotate(LLVMPassManagerRef PM) {
   LLVMAddLoopRotatePass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_loop_reroll(LLVMPassManagerRef PM) {
+value llvm_add_loop_reroll(LLVMPassManagerRef PM) {
   LLVMAddLoopRerollPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_loop_unroll(LLVMPassManagerRef PM) {
+value llvm_add_loop_unroll(LLVMPassManagerRef PM) {
   LLVMAddLoopUnrollPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_loop_unswitch(LLVMPassManagerRef PM) {
+value llvm_add_loop_unswitch(LLVMPassManagerRef PM) {
   LLVMAddLoopUnswitchPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_memcpy_opt(LLVMPassManagerRef PM) {
+value llvm_add_memcpy_opt(LLVMPassManagerRef PM) {
   LLVMAddMemCpyOptPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_partially_inline_lib_calls(LLVMPassManagerRef PM) {
+value llvm_add_partially_inline_lib_calls(LLVMPassManagerRef PM) {
   LLVMAddPartiallyInlineLibCallsPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_lower_atomic(LLVMPassManagerRef PM) {
+value llvm_add_lower_atomic(LLVMPassManagerRef PM) {
   LLVMAddLowerAtomicPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_lower_switch(LLVMPassManagerRef PM) {
+value llvm_add_lower_switch(LLVMPassManagerRef PM) {
   LLVMAddLowerSwitchPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_promote_memory_to_register(LLVMPassManagerRef PM) {
+value llvm_add_promote_memory_to_register(LLVMPassManagerRef PM) {
   LLVMAddPromoteMemoryToRegisterPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_reassociation(LLVMPassManagerRef PM) {
+value llvm_add_reassociation(LLVMPassManagerRef PM) {
   LLVMAddReassociatePass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_sccp(LLVMPassManagerRef PM) {
+value llvm_add_sccp(LLVMPassManagerRef PM) {
   LLVMAddSCCPPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_scalar_repl_aggregates(LLVMPassManagerRef PM) {
+value llvm_add_scalar_repl_aggregates(LLVMPassManagerRef PM) {
   LLVMAddScalarReplAggregatesPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_scalar_repl_aggregates_ssa(LLVMPassManagerRef PM) {
+value llvm_add_scalar_repl_aggregates_ssa(LLVMPassManagerRef PM) {
   LLVMAddScalarReplAggregatesPassSSA(PM);
   return Val_unit;
 }
 
 /* int -> [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_scalar_repl_aggregates_with_threshold(value threshold,
-                                                              LLVMPassManagerRef PM) {
+value llvm_add_scalar_repl_aggregates_with_threshold(value threshold,
+                                                     LLVMPassManagerRef PM) {
   LLVMAddScalarReplAggregatesPassWithThreshold(PM, Int_val(threshold));
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_simplify_lib_calls(LLVMPassManagerRef PM) {
+value llvm_add_simplify_lib_calls(LLVMPassManagerRef PM) {
   LLVMAddSimplifyLibCallsPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_tail_call_elimination(LLVMPassManagerRef PM) {
+value llvm_add_tail_call_elimination(LLVMPassManagerRef PM) {
   LLVMAddTailCallEliminationPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_demote_memory_to_register(LLVMPassManagerRef PM) {
+value llvm_add_demote_memory_to_register(LLVMPassManagerRef PM) {
   LLVMAddDemoteMemoryToRegisterPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_verifier(LLVMPassManagerRef PM) {
+value llvm_add_verifier(LLVMPassManagerRef PM) {
   LLVMAddVerifierPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_correlated_value_propagation(LLVMPassManagerRef PM) {
+value llvm_add_correlated_value_propagation(LLVMPassManagerRef PM) {
   LLVMAddCorrelatedValuePropagationPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_early_cse(LLVMPassManagerRef PM) {
+value llvm_add_early_cse(LLVMPassManagerRef PM) {
   LLVMAddEarlyCSEPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_lower_expect_intrinsic(LLVMPassManagerRef PM) {
+value llvm_add_lower_expect_intrinsic(LLVMPassManagerRef PM) {
   LLVMAddLowerExpectIntrinsicPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_lower_constant_intrinsics(LLVMPassManagerRef PM) {
+value llvm_add_lower_constant_intrinsics(LLVMPassManagerRef PM) {
   LLVMAddLowerConstantIntrinsicsPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_type_based_alias_analysis(LLVMPassManagerRef PM) {
+value llvm_add_type_based_alias_analysis(LLVMPassManagerRef PM) {
   LLVMAddTypeBasedAliasAnalysisPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_scoped_no_alias_aa(LLVMPassManagerRef PM) {
+value llvm_add_scoped_no_alias_aa(LLVMPassManagerRef PM) {
   LLVMAddScopedNoAliasAAPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_basic_alias_analysis(LLVMPassManagerRef PM) {
+value llvm_add_basic_alias_analysis(LLVMPassManagerRef PM) {
   LLVMAddBasicAliasAnalysisPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_unify_function_exit_nodes(LLVMPassManagerRef PM) {
+value llvm_add_unify_function_exit_nodes(LLVMPassManagerRef PM) {
   LLVMAddUnifyFunctionExitNodesPass(PM);
   return Val_unit;
 }
diff --git a/llvm/bindings/ocaml/transforms/utils/transform_utils_ocaml.c b/llvm/bindings/ocaml/transforms/utils/transform_utils_ocaml.c
@@ -26,6 +26,4 @@
  */
 
 /* llmodule -> llmodule */
-CAMLprim LLVMModuleRef llvm_clone_module(LLVMModuleRef M) {
-  return LLVMCloneModule(M);
-}
+LLVMModuleRef llvm_clone_module(LLVMModuleRef M) { return LLVMCloneModule(M); }
diff --git a/llvm/bindings/ocaml/transforms/vectorize/vectorize_ocaml.c b/llvm/bindings/ocaml/transforms/vectorize/vectorize_ocaml.c
@@ -20,13 +20,13 @@
 #include "caml/misc.h"
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_loop_vectorize(LLVMPassManagerRef PM) {
+value llvm_add_loop_vectorize(LLVMPassManagerRef PM) {
   LLVMAddLoopVectorizePass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_slp_vectorize(LLVMPassManagerRef PM) {
+value llvm_add_slp_vectorize(LLVMPassManagerRef PM) {
   LLVMAddSLPVectorizePass(PM);
   return Val_unit;
 }