Address comments

llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c

 value llvm_di_file_get_source(value File) {
   unsigned Len;
   const char *Source = LLVMDIFileGetSource(Metadata_val(File), &Len);
   return cstr_to_string(Source, Len);
 }
 
 value llvm_dibuild_get_or_create_type_array(value Builder, value Data) {
   unsigned int Count = Wosize_val(Data);
-  LLVMMetadataRef *Temp = alloc_temp(Data);
+  LLVMMetadataRef *Temp = from_val_array(Data);
   LLVMMetadataRef Metadata =
       LLVMDIBuilderGetOrCreateTypeArray(DIBuilder_val(Builder), Temp, Count);
   free(Temp);
   return to_val(Metadata);
 }
 
 value llvm_dibuild_get_or_create_array(value Builder, value Data) {
   unsigned int Count = Wosize_val(Data);
-  LLVMMetadataRef *Temp = alloc_temp(Data);
+  LLVMMetadataRef *Temp = from_val_array(Data);
   LLVMMetadataRef Metadata =
       LLVMDIBuilderGetOrCreateArray(DIBuilder_val(Builder), Temp, Count);
   free(Temp);
   return to_val(Metadata);
 }
 
 value llvm_dibuild_create_subroutine_type(value Builder, value File,
                                           value ParameterTypes, value Flags) {
   unsigned int Count = Wosize_val(ParameterTypes);
-  LLVMMetadataRef *Temp = alloc_temp(ParameterTypes);
+  LLVMMetadataRef *Temp = from_val_array(ParameterTypes);
   LLVMMetadataRef Metadata = LLVMDIBuilderCreateSubroutineType(
       DIBuilder_val(Builder), Metadata_val(File), Temp,
       Wosize_val(ParameterTypes), DIFlags_val(Flags));
   free(Temp);
   return to_val(Metadata);
 }
 
 value llvm_dibuild_create_enumerator(value Builder, value Name, value Value,
                                      value IsUnsigned) {
   return to_val(LLVMDIBuilderCreateEnumerator(
       DIBuilder_val(Builder), String_val(Name), caml_string_length(Name),
       (int64_t)Int_val(Value), Bool_val(IsUnsigned)));
 }
 
 value llvm_dibuild_create_enumeration_type_native(
     value Builder, value Scope, value Name, value File, value LineNumber,
     value SizeInBits, value AlignInBits, value Elements, value ClassTy) {
   unsigned int Count = Wosize_val(Elements);
-  LLVMMetadataRef *Temp = alloc_temp(Elements);
+  LLVMMetadataRef *Temp = from_val_array(Elements);
   LLVMMetadataRef Metadata = LLVMDIBuilderCreateEnumerationType(
       DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
       caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
       (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits), Temp, Count,
       Metadata_val(ClassTy));
   free(Temp);
   return to_val(Metadata);
 }
return llvm_dibuild_create_enumeration_type_native(argv[0], // Builder
                                                      argv[8]  // ClassTy
   );
 }
 
 value llvm_dibuild_create_union_type_native(
     value Builder, value Scope, value Name, value File, value LineNumber,
     value SizeInBits, value AlignInBits, value Flags, value Elements,
     value RunTimeLanguage, value UniqueId) {
-  LLVMMetadataRef *Temp = alloc_temp(Elements);
+  LLVMMetadataRef *Temp = from_val_array(Elements);
   LLVMMetadataRef Metadata = LLVMDIBuilderCreateUnionType(
       DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
       caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
       (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits), DIFlags_val(Flags),
       Temp, Wosize_val(Elements), Int_val(RunTimeLanguage),
       String_val(UniqueId), caml_string_length(UniqueId));
   free(Temp);
   return to_val(Metadata);
return llvm_dibuild_create_union_type_native(argv[0], // Builder
                                                argv[9], // RunTimeLanguage
                                                argv[10] // UniqueId
   );
 }
 
 value llvm_dibuild_create_array_type(value Builder, value Size,
                                      value AlignInBits, value Ty,
                                      value Subscripts) {
-  LLVMMetadataRef *Temp = alloc_temp(Subscripts);
+  LLVMMetadataRef *Temp = from_val_array(Subscripts);
   LLVMMetadataRef Metadata = LLVMDIBuilderCreateArrayType(
       DIBuilder_val(Builder), (uint64_t)Int_val(Size), Int_val(AlignInBits),
       Metadata_val(Ty), Temp, Wosize_val(Subscripts));
   free(Temp);
   return to_val(Metadata);
 }
 
 value llvm_dibuild_create_vector_type(value Builder, value Size,
                                       value AlignInBits, value Ty,
                                       value Subscripts) {
-  LLVMMetadataRef *Temp = alloc_temp(Subscripts);
+  LLVMMetadataRef *Temp = from_val_array(Subscripts);
   LLVMMetadataRef Metadata = LLVMDIBuilderCreateVectorType(
       DIBuilder_val(Builder), (uint64_t)Int_val(Size), Int_val(AlignInBits),
       Metadata_val(Ty), Temp, Wosize_val(Subscripts));
   free(Temp);
   return to_val(Metadata);
 }
 
 value llvm_dibuild_create_unspecified_type(value Builder, value Name) {
return llvm_dibuild_create_pointer_type_native(argv[0], // Builder
                                                  argv[5]  // Name
   );
 }
 
 value llvm_dibuild_create_struct_type_native(
     value Builder, value Scope, value Name, value File, value LineNumber,
     value SizeInBits, value AlignInBits, value Flags, value DerivedFrom,
     value Elements, value RunTimeLanguage, value VTableHolder, value UniqueId) {
-  LLVMMetadataRef *Temp = alloc_temp(Elements);
+  LLVMMetadataRef *Temp = from_val_array(Elements);
   LLVMMetadataRef Metadata = LLVMDIBuilderCreateStructType(
       DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
       caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
       (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits), DIFlags_val(Flags),
       Metadata_val(DerivedFrom), Temp, Wosize_val(Elements),
       Int_val(RunTimeLanguage), Metadata_val(VTableHolder),
       String_val(UniqueId), caml_string_length(UniqueId));
   free(Temp);
value llvm_dibuild_create_bit_field_member_type_bytecode(value *argv, int arg) {
   );
 }
 
 value llvm_dibuild_create_class_type_native(
     value Builder, value Scope, value Name, value File, value LineNumber,
     value SizeInBits, value AlignInBits, value OffsetInBits, value Flags,
     value DerivedFrom, value Elements, value VTableHolder,
     value TemplateParamsNode, value UniqueIdentifier) {
-  LLVMMetadataRef *Temp = alloc_temp(Elements);
+  LLVMMetadataRef *Temp = from_val_array(Elements);
   LLVMMetadataRef Metadata = LLVMDIBuilderCreateClassType(
       DIBuilder_val(Builder), Metadata_val(Scope), String_val(Name),
       caml_string_length(Name), Metadata_val(File), Int_val(LineNumber),
       (uint64_t)Int_val(SizeInBits), Int_val(AlignInBits),
       (uint64_t)Int_val(OffsetInBits), DIFlags_val(Flags),
       Metadata_val(DerivedFrom), Temp, Wosize_val(Elements),
       Metadata_val(VTableHolder), Metadata_val(TemplateParamsNode),
       String_val(UniqueIdentifier), caml_string_length(UniqueIdentifier));

llvm/bindings/ocaml/debuginfo/llvm_debuginfo.ml

external dibuild_create_debug_location_helper :
   scope:Llvm.llmetadata ->
   inlined_at:Llvm.llmetadata ->
   Llvm.llmetadata = "llvm_dibuild_create_debug_location"
 
 external llmetadata_null : unit -> Llvm.llmetadata = "llvm_metadata_null"
 
 let dibuild_create_debug_location ?(inlined_at = llmetadata_null ()) llctx ~line
     ~column ~scope =
-  dibuild_create_debug_location_helper llctx line column scope inlined_at
+  dibuild_create_debug_location_helper llctx ~line ~column ~scope ~inlined_at
 
 external di_location_get_line : location:Llvm.llmetadata -> int
   = "llvm_di_location_get_line"
 
 external di_location_get_column : location:Llvm.llmetadata -> int
   = "llvm_di_location_get_column"
 
 external di_location_get_scope : location:Llvm.llmetadata -> Llvm.llmetadata

llvm/bindings/ocaml/llvm/llvm_ocaml.h

 /* to_val and from_val convert between an OCaml value and a pointer from LLVM,
    which points outside the OCaml heap. They assume that all pointers from LLVM
    are 2-byte aligned: to_val sets the low bit so that OCaml treats the value
    as an integer, and from_val clears the low bit. */
 value to_val(void *ptr);
 
 void *from_val(value v);
 
-void *alloc_temp(value Elements);
+/* from_val_array takes an OCaml array value of LLVM references encoded with
+   the representation described above and returns a malloc'd array
+   of unencoded LLVM references. The returned array must be deallocated using
+   free. */
+void *from_val_array(value Elements);
 
 #define DiagnosticInfo_val(v) ((LLVMDiagnosticInfoRef)from_val(v))
 #define Context_val(v) ((LLVMContextRef)from_val(v))
 #define Attribute_val(v) ((LLVMAttributeRef)from_val(v))
 #define Module_val(v) ((LLVMModuleRef)from_val(v))
 #define Metadata_val(v) ((LLVMMetadataRef)from_val(v))
 #define Type_val(v) ((LLVMTypeRef)from_val(v))
 #define Value_val(v) ((LLVMValueRef)from_val(v))

llvm/bindings/ocaml/llvm/llvm_ocaml.c

value to_val(void *ptr) {
   assert((((value)ptr) & 1) == 0 &&
          "OCaml bindings assume LLVM objects are at least 2-byte aligned");
   return ((value)ptr) | 1;
 }
 
 void *from_val(value v) {
   assert(Is_long(v) && "OCaml values representing LLVM objects should have the "
                        "low bit set so that the OCaml GC "
-                       "treats them as integers");
+                       "treats them as tagged integers");
   return (void *)(v ^ 1);
 }
 
 value llvm_string_of_message(char *Message) {
   value String = caml_copy_string(Message);
   LLVMDisposeMessage(Message);
 
   return String;
value llvm_parse_command_line_options(value Overview, value Args) {
   } else {
     COverview = String_val(Field(Overview, 0));
   }
   LLVMParseCommandLineOptions(Wosize_val(Args),
                               (const char *const *)Op_val(Args), COverview);
   return Val_unit;
 }
 
-void *alloc_temp(value Elements) {
-  unsigned Length = Wosize_val(Elements);
+void *from_val_array(value Elements) {
+  mlsize_t Length = Wosize_val(Elements);
   void **Temp = malloc(sizeof(void *) * Length);
   if (Temp == NULL)
     caml_raise_out_of_memory();
   for (unsigned I = 0; I < Length; ++I) {
     Temp[I] = from_val(Field(Elements, I));
   }
   return Temp;
 }

 value llvm_string_of_llmodule(value M) {
   char *ModuleCStr = LLVMPrintModuleToString(Module_val(M));
   value ModuleStr = caml_copy_string(ModuleCStr);
   LLVMDisposeMessage(ModuleCStr);
 
   return ModuleStr;
 }
 
-/* llmodule -> string -> unit */
-value llvm_set_module_inline_asm(value M, value Asm) {
-  LLVMSetModuleInlineAsm(Module_val(M), String_val(Asm));
-  return Val_unit;
-}
-
 /* llmodule -> llcontext */
 value llvm_get_module_context(value M) {
   LLVMContextRef C = LLVMGetModuleContext(Module_val(M));
   return to_val(C);
 }
 
 /* llmodule -> string */
 value llvm_get_module_identifier(value M) {
   size_t Len;
   const char *Name = LLVMGetModuleIdentifier(Module_val(M), &Len);
   return cstr_to_string(Name, (mlsize_t)Len);
 }
 
 /* llmodule -> string -> unit */
 value llvm_set_module_identifier(value M, value Id) {
   LLVMSetModuleIdentifier(Module_val(M), String_val(Id),
                           caml_string_length(Id));
   return Val_unit;
 }
 
+/* llmodule -> string -> unit */
+value llvm_set_module_inline_asm(value M, value Asm) {
+  LLVMSetModuleInlineAsm(Module_val(M), String_val(Asm));
+  return Val_unit;
+}
+
 /* llmodule -> string -> llmetadata option */
 value llvm_get_module_flag(value M, value Key) {
   return 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) {

 value llvm_ppc_fp128_type(value Context) {
   return to_val(LLVMPPCFP128TypeInContext(Context_val(Context)));
 }
 
 /*--... Operations on function types .......................................--*/
 
 /* lltype -> lltype array -> lltype */
 value llvm_function_type(value RetTy, value ParamTys) {
-  CAMLparam1(ParamTys);
-  size_t len = Wosize_val(ParamTys);
-  LLVMTypeRef *Temp = alloc_temp(ParamTys);
+  mlsize_t len = Wosize_val(ParamTys);
+  LLVMTypeRef *Temp = from_val_array(ParamTys);
   LLVMTypeRef Type = LLVMFunctionType(Type_val(RetTy), Temp, len, 0);
   free(Temp);
-  CAMLreturn(to_val(Type));
+  return to_val(Type);
 }
 
 /* lltype -> lltype array -> lltype */
 value llvm_var_arg_function_type(value RetTy, value ParamTys) {
-  CAMLparam1(ParamTys);
-  size_t len = Wosize_val(ParamTys);
-  LLVMTypeRef *Temp = alloc_temp(ParamTys);
+  mlsize_t len = Wosize_val(ParamTys);
+  LLVMTypeRef *Temp = from_val_array(ParamTys);
   LLVMTypeRef Type = LLVMFunctionType(Type_val(RetTy), Temp, len, 1);
   free(Temp);
-  CAMLreturn(to_val(Type));
+  return to_val(Type);
 }
 
 /* lltype -> bool */
 value llvm_is_var_arg(value FunTy) {
   return Val_bool(LLVMIsFunctionVarArg(Type_val(FunTy)));
 }
 
 /* lltype -> lltype */
value llvm_param_types(value FunTy) {
   }
   return Tys;
 }
 
 /*--... Operations on struct types .........................................--*/
 
 /* llcontext -> lltype array -> lltype */
 value llvm_struct_type(value C, value ElementTypes) {
-  CAMLparam1(ElementTypes);
-  size_t Length = Wosize_val(ElementTypes);
-  LLVMTypeRef *Temp = alloc_temp(ElementTypes);
+  mlsize_t Length = Wosize_val(ElementTypes);
+  LLVMTypeRef *Temp = from_val_array(ElementTypes);
   LLVMTypeRef Type = LLVMStructTypeInContext(Context_val(C), Temp, Length, 0);
   free(Temp);
-  CAMLreturn(to_val(Type));
+  return to_val(Type);
 }
 
 /* llcontext -> lltype array -> lltype */
 value llvm_packed_struct_type(value C, value ElementTypes) {
-  CAMLparam1(ElementTypes);
-  size_t Length = Wosize_val(ElementTypes);
-  LLVMTypeRef *Temp = alloc_temp(ElementTypes);
+  mlsize_t Length = Wosize_val(ElementTypes);
+  LLVMTypeRef *Temp = from_val_array(ElementTypes);
   LLVMTypeRef Type = LLVMStructTypeInContext(Context_val(C), Temp, Length, 1);
   free(Temp);
-  CAMLreturn(to_val(Type));
+  return to_val(Type);
 }
 
 /* llcontext -> string -> lltype */
 value llvm_named_struct_type(value C, value Name) {
   return 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) {
-  CAMLparam1(ElementTypes);
-  unsigned Length = Wosize_val(ElementTypes);
-  LLVMTypeRef *Temp = alloc_temp(ElementTypes);
+  mlsize_t Length = Wosize_val(ElementTypes);
+  LLVMTypeRef *Temp = from_val_array(ElementTypes);
   LLVMStructSetBody(Type_val(Ty), Temp, Length, Bool_val(Packed));
-  CAMLreturn(Val_unit);
+  return Val_unit;
 }
 
 /* lltype -> string option */
 value llvm_struct_name(value Ty) {
   const char *CStr = LLVMGetStructName(Type_val(Ty));
   size_t Len;
   if (!CStr)
     return Val_none;

 /* llcontext -> string -> llvalue */
 value llvm_mdstring(value C, value S) {
   return to_val(LLVMMDStringInContext(Context_val(C), String_val(S),
                                       caml_string_length(S)));
 }
 
 /* llcontext -> llvalue array -> llvalue */
 value llvm_mdnode(value C, value ElementVals) {
-  unsigned Length = Wosize_val(ElementVals);
-  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  mlsize_t Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = from_val_array(ElementVals);
   LLVMValueRef Value = LLVMMDNodeInContext(Context_val(C), Temp, Length);
   free(Temp);
   return to_val(Value);
 }
 
 /* llcontext -> llvalue */
 value llvm_mdnull(value C) { return to_val(NULL); }
 

 /* llcontext -> string -> llvalue */
 value llvm_const_stringz(value Context, value Str) {
   return 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) {
-  unsigned Length = Wosize_val(ElementVals);
-  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  mlsize_t Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = from_val_array(ElementVals);
   LLVMValueRef Value = LLVMConstArray(Type_val(ElementTy), Temp, Length);
   free(Temp);
   return to_val(Value);
 }
 
 /* llcontext -> llvalue array -> llvalue */
 value llvm_const_struct(value C, value ElementVals) {
-  unsigned Length = Wosize_val(ElementVals);
-  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  mlsize_t Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = from_val_array(ElementVals);
   LLVMValueRef Value =
       LLVMConstStructInContext(Context_val(C), Temp, Length, 0);
   free(Temp);
   return to_val(Value);
 }
 
 /* lltype -> llvalue array -> llvalue */
 value llvm_const_named_struct(value Ty, value ElementVals) {
-  unsigned Length = Wosize_val(ElementVals);
-  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  mlsize_t Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = from_val_array(ElementVals);
   LLVMValueRef Value =
       LLVMConstNamedStruct(Type_val(Ty), (LLVMValueRef *)Temp, Length);
   free(Temp);
   return to_val(Value);
 }
 
 /* llcontext -> llvalue array -> llvalue */
 value llvm_const_packed_struct(value C, value ElementVals) {
-  unsigned Length = Wosize_val(ElementVals);
-  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  mlsize_t Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = from_val_array(ElementVals);
   LLVMValueRef Value =
       LLVMConstStructInContext(Context_val(C), Temp, Length, 1);
   free(Temp);
   return to_val(Value);
 }
 
 /* llvalue array -> llvalue */
 value llvm_const_vector(value ElementVals) {
-  unsigned Length = Wosize_val(ElementVals);
-  LLVMValueRef *Temp = alloc_temp(ElementVals);
+  mlsize_t Length = Wosize_val(ElementVals);
+  LLVMValueRef *Temp = from_val_array(ElementVals);
   LLVMValueRef Value = LLVMConstVector(Temp, Length);
   free(Temp);
   return to_val(Value);
 }
 
 /* llvalue -> string option */
 value llvm_string_of_const(value C) {
   size_t Len;

 /* llvalue -> llvalue -> llvalue */
 value llvm_const_ashr(value LHS, value RHS) {
   LLVMValueRef Value = LLVMConstAShr(Value_val(LHS), Value_val(RHS));
   return to_val(Value);
 }
 
 /* lltype -> llvalue -> llvalue array -> llvalue */
 value llvm_const_gep(value Ty, value ConstantVal, value Indices) {
-  unsigned Length = Wosize_val(Indices);
-  LLVMValueRef *Temp = alloc_temp(Indices);
+  mlsize_t Length = Wosize_val(Indices);
+  LLVMValueRef *Temp = from_val_array(Indices);
   LLVMValueRef Value =
       LLVMConstGEP2(Type_val(Ty), Value_val(ConstantVal), Temp, Length);
   free(Temp);
   return to_val(Value);
 }
 
 /* lltype -> llvalue -> llvalue array -> llvalue */
 value llvm_const_in_bounds_gep(value Ty, value ConstantVal, value Indices) {
-  unsigned Length = Wosize_val(Indices);
-  LLVMValueRef *Temp = alloc_temp(Indices);
+  mlsize_t Length = Wosize_val(Indices);
+  LLVMValueRef *Temp = from_val_array(Indices);
   LLVMValueRef Value =
       LLVMConstInBoundsGEP2(Type_val(Ty), Value_val(ConstantVal), Temp, Length);
   free(Temp);
   return to_val(Value);
 }
 
 /* llvalue -> lltype -> llvalue */
 value llvm_const_trunc(value CV, value T) {

 /* llvalue -> llvalue */
 value llvm_param_parent(value Value) {
   LLVMValueRef Parent = LLVMGetParamParent(Value_val(Value));
   return to_val(Parent);
 }
 
 /*--... Operations on basic blocks .........................................--*/
 
-/* llbasicblock -> llvalue */
-value llvm_value_of_block(value BB) {
-  return to_val(LLVMBasicBlockAsValue(BasicBlock_val(BB)));
-}
-
-/* llvalue -> bool */
-value llvm_value_is_block(value Val) {
-  return Val_bool(LLVMValueIsBasicBlock(Value_val(Val)));
-}
-
-/* llbasicblock -> llvalue */
-value llvm_block_of_value(value Val) {
-  return to_val(LLVMValueAsBasicBlock(Value_val(Val)));
-}
+DEFINE_ITERATORS(block, BasicBlock, Value_val, LLVMBasicBlockRef,
+                 BasicBlock_val, LLVMGetBasicBlockParent)
 
-/* llbasicblock -> llvalue */
-value llvm_block_parent(value BB) {
-  return to_val(LLVMGetBasicBlockParent(BasicBlock_val(BB)));
+/* llbasicblock -> llvalue option */
+value llvm_block_terminator(value Block) {
+  return ptr_to_option(LLVMGetBasicBlockTerminator(BasicBlock_val(Block)));
 }
 
 /* llvalue -> llbasicblock array */
 value llvm_basic_blocks(value Fn) {
   unsigned Length = LLVMCountBasicBlocks(Value_val(Fn));
   value MLArray = caml_alloc_tuple_uninit(Length);
   LLVMGetBasicBlocks(Value_val(Fn), (LLVMBasicBlockRef *)Op_val(MLArray));
   for (unsigned I = 0; I < Length; ++I) {
     Field(MLArray, I) = to_val((LLVMBasicBlockRef)Field(MLArray, I));
   }
   return MLArray;
 }
 
-/* llvalue -> llbasicblock */
-value llvm_entry_block(value Val) {
-  LLVMBasicBlockRef BB = LLVMGetEntryBasicBlock(Value_val(Val));
-  return to_val(BB);
-}
-
-DEFINE_ITERATORS(block, BasicBlock, Value_val, LLVMBasicBlockRef,
-                 BasicBlock_val, LLVMGetBasicBlockParent)
-
-/* llbasicblock -> llvalue option */
-value llvm_block_terminator(value Block) {
-  return ptr_to_option(LLVMGetBasicBlockTerminator(BasicBlock_val(Block)));
-}
-
 /* llbasicblock -> unit */
 value llvm_delete_block(value BB) {
   LLVMDeleteBasicBlock(BasicBlock_val(BB));
   return Val_unit;
 }
 
 /* llbasicblock -> unit */
 value llvm_remove_block(value BB) {

 }
 
 /* llcontext -> string -> llbasicblock -> llbasicblock */
 value llvm_insert_block(value Context, value Name, value BB) {
   return to_val(LLVMInsertBasicBlockInContext(
       Context_val(Context), BasicBlock_val(BB), String_val(Name)));
 }
 
+/* llbasicblock -> llvalue */
+value llvm_value_of_block(value BB) {
+  return to_val(LLVMBasicBlockAsValue(BasicBlock_val(BB)));
+}
+
+/* llvalue -> bool */
+value llvm_value_is_block(value Val) {
+  return Val_bool(LLVMValueIsBasicBlock(Value_val(Val)));
+}
+
+/* llbasicblock -> llvalue */
+value llvm_block_of_value(value Val) {
+  return to_val(LLVMValueAsBasicBlock(Value_val(Val)));
+}
+
+/* llbasicblock -> llvalue */
+value llvm_block_parent(value BB) {
+  return to_val(LLVMGetBasicBlockParent(BasicBlock_val(BB)));
+}
+
+/* llvalue -> llbasicblock */
+value llvm_entry_block(value Val) {
+  LLVMBasicBlockRef BB = LLVMGetEntryBasicBlock(Value_val(Val));
+  return to_val(BB);
+}
+
 /*--... Operations on instructions .........................................--*/
 
 /* llvalue -> llbasicblock */
 value llvm_instr_parent(value Inst) {
   LLVMBasicBlockRef BB = LLVMGetInstructionParent(Value_val(Inst));
   return to_val(BB);
 }
 
if (Tag_val(Pos) == 0) {
     LLVMValueRef I = Value_val(Field(Pos, 0));
     LLVMPositionBuilderBefore(Builder_val(B), I);
   }
   return Val_unit;
 }
 
 /* llbuilder -> llbasicblock */
 value llvm_insertion_block(value B) {
-  CAMLparam1(B);
   LLVMBasicBlockRef InsertBlock = LLVMGetInsertBlock(Builder_val(B));
   if (!InsertBlock)
     caml_raise_not_found();
-  CAMLreturn(to_val(InsertBlock));
+  return to_val(InsertBlock);
 }
 
 /* llvalue -> string -> llbuilder -> unit */
 value llvm_insert_into_builder(value I, value Name, value B) {
   LLVMInsertIntoBuilderWithName(Builder_val(B), Value_val(I), String_val(Name));
   return Val_unit;
 }
 

 
 /* llvalue -> llbuilder -> llvalue */
 value llvm_build_ret(value Val, value B) {
   return to_val(LLVMBuildRet(Builder_val(B), Value_val(Val)));
 }
 
 /* llvalue array -> llbuilder -> llvalue */
 value llvm_build_aggregate_ret(value RetVals, value B) {
-  unsigned Length = Wosize_val(RetVals);
-  LLVMValueRef *Temp = alloc_temp(RetVals);
+  mlsize_t Length = Wosize_val(RetVals);
+  LLVMValueRef *Temp = from_val_array(RetVals);
   LLVMValueRef Value = LLVMBuildAggregateRet(Builder_val(B), Temp, Length);
   free(Temp);
   return to_val(Value);
 }
 
 /* llbasicblock -> llbuilder -> llvalue */
 value llvm_build_br(value BB, value B) {
   return to_val(LLVMBuildBr(Builder_val(B), BasicBlock_val(BB)));
value llvm_add_destination(value IndirectBr, value Dest) {
   LLVMAddDestination(Value_val(IndirectBr), BasicBlock_val(Dest));
   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) {
-  unsigned Length = Wosize_val(Args);
-  LLVMValueRef *Temp = alloc_temp(Args);
+  mlsize_t Length = Wosize_val(Args);
+  LLVMValueRef *Temp = from_val_array(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);
   return to_val(Value);
 }
 
 /* lltype -> llvalue -> llvalue array -> llbasicblock -> llbasicblock ->

 value llvm_build_atomicrmw_bytecode(value *argv, int argn) {
   return llvm_build_atomicrmw_native(argv[0], argv[1], argv[2], argv[3],
                                      argv[4], argv[5], argv[6]);
 }
 
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
 value llvm_build_gep(value Ty, value Pointer, value Indices, value Name,
                      value B) {
-  unsigned Length = Wosize_val(Indices);
-  LLVMValueRef *Temp = alloc_temp(Indices);
+  mlsize_t Length = Wosize_val(Indices);
+  LLVMValueRef *Temp = from_val_array(Indices);
   LLVMValueRef Value =
       LLVMBuildGEP2(Builder_val(B), Type_val(Ty), Value_val(Pointer), Temp,
                     Length, String_val(Name));
   free(Temp);
   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) {
-  unsigned Length = Wosize_val(Indices);
-  LLVMValueRef *Temp = alloc_temp(Indices);
+  mlsize_t Length = Wosize_val(Indices);
+  LLVMValueRef *Temp = from_val_array(Indices);
   LLVMValueRef Value =
       LLVMBuildInBoundsGEP2(Builder_val(B), Type_val(Ty), Value_val(Pointer),
                             Temp, Length, String_val(Name));
   free(Temp);
   return to_val(Value);
 }
 
 /* lltype -> llvalue -> int -> string -> llbuilder -> llvalue */

 
 /* lltype -> string -> llbuilder -> value */
 value llvm_build_empty_phi(value Type, value Name, value B) {
   return to_val(LLVMBuildPhi(Builder_val(B), Type_val(Type), String_val(Name)));
 }
 
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
 value llvm_build_call(value FnTy, value Fn, value Params, value Name, value B) {
-  unsigned Length = Wosize_val(Params);
-  LLVMValueRef *Temp = alloc_temp(Params);
+  mlsize_t Length = Wosize_val(Params);
+  LLVMValueRef *Temp = from_val_array(Params);
   LLVMValueRef Value =
       LLVMBuildCall2(Builder_val(B), Type_val(FnTy), Value_val(Fn), Temp,
                      Length, String_val(Name));
   free(Temp);
   return to_val(Value);
 }
 
 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */