[llvm-ocaml] Replace all typed pointer functions with opaque pointer functions

[alan]

Consistently use the name [sp] for address space

[alan]

Run clang-format on changes

llvm/bindings/ocaml/llvm/llvm.ml

 external is_packed : lltype -> bool = "llvm_is_packed"
 external is_opaque : lltype -> bool = "llvm_is_opaque"
 external is_literal : lltype -> bool = "llvm_is_literal"
 
 (*--... Operations on pointer, vector, and array types .....................--*)
 
 external subtypes : lltype -> lltype array = "llvm_subtypes"
 external array_type : lltype -> int -> lltype = "llvm_array_type"
-external pointer_type : lltype -> lltype = "llvm_pointer_type"
-external qualified_pointer_type : lltype -> int -> lltype
+external pointer_type : llcontext -> lltype = "llvm_pointer_type"
+external qualified_pointer_type : llcontext -> int -> lltype
                                 = "llvm_qualified_pointer_type"
-external pointer_type_in_context : llcontext -> int -> lltype
-                                 = "llvm_pointer_type_in_context"
 external vector_type : lltype -> int -> lltype = "llvm_vector_type"
 
 external element_type : lltype -> lltype = "LLVMGetElementType"
 external array_length : lltype -> int = "llvm_array_length"
 external address_space : lltype -> int = "llvm_address_space"
 external vector_size : lltype -> int = "llvm_vector_size"
 
 (*--... Operations on other types ..........................................--*)

 external const_xor : llvalue -> llvalue -> llvalue = "LLVMConstXor"
 external const_icmp : Icmp.t -> llvalue -> llvalue -> llvalue
                     = "llvm_const_icmp"
 external const_fcmp : Fcmp.t -> llvalue -> llvalue -> llvalue
                     = "llvm_const_fcmp"
 external const_shl : llvalue -> llvalue -> llvalue = "LLVMConstShl"
 external const_lshr : llvalue -> llvalue -> llvalue = "LLVMConstLShr"
 external const_ashr : llvalue -> llvalue -> llvalue = "LLVMConstAShr"
-external const_gep : llvalue -> llvalue array -> llvalue = "llvm_const_gep"
-external const_gep2 : lltype -> llvalue -> llvalue array -> llvalue
-                    = "llvm_const_gep2"
+external const_gep : lltype -> llvalue -> llvalue array -> llvalue
+                    = "llvm_const_gep"
 external const_in_bounds_gep : llvalue -> llvalue array -> llvalue
                             = "llvm_const_in_bounds_gep"
 external const_trunc : llvalue -> lltype -> llvalue = "LLVMConstTrunc"
 external const_sext : llvalue -> lltype -> llvalue = "LLVMConstSExt"
 external const_zext : llvalue -> lltype -> llvalue = "LLVMConstZExt"
 external const_fptrunc : llvalue -> lltype -> llvalue = "LLVMConstFPTrunc"
 external const_fpext : llvalue -> lltype -> llvalue = "LLVMConstFPExt"
 external const_uitofp : llvalue -> lltype -> llvalue = "LLVMConstUIToFP"
let rec fold_right_global_range f i e init =
   match i with
   | At_start _ -> raise (Invalid_argument "Invalid global variable range.")
   | After bb -> fold_right_global_range f (global_pred bb) e (f bb init)
 
 let fold_right_globals f m init =
   fold_right_global_range f (global_end m) (At_start m) init
 
 (*--... Operations on aliases ..............................................--*)
-external add_alias : llmodule -> lltype -> llvalue -> string -> llvalue
+external add_alias : llmodule -> lltype -> int -> llvalue -> string -> llvalue
                    = "llvm_add_alias"
 
-external add_alias2 : llmodule -> lltype -> int -> llvalue -> string -> llvalue
-                    = "llvm_add_alias2"
-
 (*--... Operations on functions ............................................--*)
 external declare_function : string -> lltype -> llmodule -> llvalue
                           = "llvm_declare_function"
 external define_function : string -> lltype -> llmodule -> llvalue
                          = "llvm_define_function"
 external lookup_function : string -> llmodule -> llvalue option
                          = "llvm_lookup_function"
 external delete_function : llvalue -> unit = "llvm_delete_function"

 external add_case : llvalue -> llvalue -> llbasicblock -> unit
                   = "llvm_add_case"
 external switch_default_dest : llvalue -> llbasicblock =
     "LLVMGetSwitchDefaultDest"
 external build_indirect_br : llvalue -> int -> llbuilder -> llvalue
                            = "llvm_build_indirect_br"
 external add_destination : llvalue -> llbasicblock -> unit
                          = "llvm_add_destination"
-external build_invoke : llvalue -> llvalue array -> llbasicblock ->
+external build_invoke : lltype -> llvalue -> llvalue array -> llbasicblock ->
                         llbasicblock -> string -> llbuilder -> llvalue
                       = "llvm_build_invoke_bc" "llvm_build_invoke_nat"
-external build_invoke2 : lltype -> llvalue -> llvalue array -> llbasicblock ->
-                         llbasicblock -> string -> llbuilder -> llvalue
-                      = "llvm_build_invoke2_bc" "llvm_build_invoke2_nat"
 external build_landingpad : lltype -> llvalue -> int -> string -> llbuilder ->
                             llvalue = "llvm_build_landingpad"
 external is_cleanup : llvalue -> bool = "llvm_is_cleanup"
 external set_cleanup : llvalue -> bool -> unit = "llvm_set_cleanup"
 external add_clause : llvalue -> llvalue -> unit = "llvm_add_clause"
 external build_resume : llvalue -> llbuilder -> llvalue = "llvm_build_resume"
 external build_unreachable : llbuilder -> llvalue = "llvm_build_unreachable"
 

 external build_not : llvalue -> string -> llbuilder -> llvalue
                    = "llvm_build_not"
 
 (*--... Memory .............................................................--*)
 external build_alloca : lltype -> string -> llbuilder -> llvalue
                       = "llvm_build_alloca"
 external build_array_alloca : lltype -> llvalue -> string -> llbuilder ->
                               llvalue = "llvm_build_array_alloca"
-external build_load : llvalue -> string -> llbuilder -> llvalue
+external build_load : lltype -> llvalue -> string -> llbuilder -> llvalue
                     = "llvm_build_load"
-external build_load2 : lltype -> llvalue -> string -> llbuilder -> llvalue
-                     = "llvm_build_load2"
 external build_store : llvalue -> llvalue -> llbuilder -> llvalue
                      = "llvm_build_store"
 external build_atomicrmw : AtomicRMWBinOp.t -> llvalue -> llvalue ->
                            AtomicOrdering.t -> bool -> string -> llbuilder ->
                            llvalue
                          = "llvm_build_atomicrmw_bytecode"
                            "llvm_build_atomicrmw_native"
-external build_gep : llvalue -> llvalue array -> string -> llbuilder -> llvalue
-                   = "llvm_build_gep"
-external build_gep2 : lltype -> llvalue -> llvalue array -> string -> llbuilder
-                    -> llvalue = "llvm_build_gep2"
-external build_in_bounds_gep : llvalue -> llvalue array -> string ->
+external build_gep : lltype -> llvalue -> llvalue array -> string -> llbuilder
+                   -> llvalue = "llvm_build_gep"
+external build_in_bounds_gep : lltype -> llvalue -> llvalue array -> string ->
                              llbuilder -> llvalue = "llvm_build_in_bounds_gep"
-external build_in_bounds_gep2 : lltype -> llvalue -> llvalue array -> string ->
-                              llbuilder -> llvalue = "llvm_build_in_bounds_gep2"
-external build_struct_gep : llvalue -> int -> string -> llbuilder -> llvalue
-                         = "llvm_build_struct_gep"
-external build_struct_gep2 : lltype -> llvalue -> int -> string -> llbuilder ->
-                           llvalue = "llvm_build_struct_gep2"
+external build_struct_gep : lltype -> llvalue -> int -> string -> llbuilder ->
+                          llvalue = "llvm_build_struct_gep"
 
 external build_global_string : string -> string -> llbuilder -> llvalue
                              = "llvm_build_global_string"
 external build_global_stringptr  : string -> string -> llbuilder -> llvalue
                                  = "llvm_build_global_stringptr"
 
 (*--... Casts ..............................................................--*)
 external build_trunc : llvalue -> lltype -> string -> llbuilder -> llvalue

 external build_fcmp : Fcmp.t -> llvalue -> llvalue -> string ->
                       llbuilder -> llvalue = "llvm_build_fcmp"
 
 (*--... Miscellaneous instructions .........................................--*)
 external build_phi : (llvalue * llbasicblock) list -> string -> llbuilder ->
                      llvalue = "llvm_build_phi"
 external build_empty_phi : lltype -> string -> llbuilder -> llvalue
                          = "llvm_build_empty_phi"
-external build_call : llvalue -> llvalue array -> string -> llbuilder -> llvalue
-                    = "llvm_build_call"
-external build_call2 : lltype -> llvalue -> llvalue array -> string ->
-                       llbuilder -> llvalue = "llvm_build_call2"
+external build_call : lltype -> llvalue -> llvalue array -> string ->
+                      llbuilder -> llvalue = "llvm_build_call"
 external build_select : llvalue -> llvalue -> llvalue -> string -> llbuilder ->
                         llvalue = "llvm_build_select"
 external build_va_arg : llvalue -> lltype -> string -> llbuilder -> llvalue
                       = "llvm_build_va_arg"
 external build_extractelement : llvalue -> llvalue -> string -> llbuilder ->
                                 llvalue = "llvm_build_extractelement"
 external build_insertelement : llvalue -> llvalue -> llvalue -> string ->
                                llbuilder -> llvalue = "llvm_build_insertelement"
 external build_shufflevector : llvalue -> llvalue -> llvalue -> string ->
                                llbuilder -> llvalue = "llvm_build_shufflevector"
 external build_extractvalue : llvalue -> int -> string -> llbuilder -> llvalue
                             = "llvm_build_extractvalue"
 external build_insertvalue : llvalue -> llvalue -> int -> string -> llbuilder ->
                              llvalue = "llvm_build_insertvalue"
 
 external build_is_null : llvalue -> string -> llbuilder -> llvalue
                        = "llvm_build_is_null"
 external build_is_not_null : llvalue -> string -> llbuilder -> llvalue
                            = "llvm_build_is_not_null"
-external build_ptrdiff : llvalue -> llvalue -> string -> llbuilder -> llvalue
-                       = "llvm_build_ptrdiff"
-external build_ptrdiff2 : lltype -> llvalue -> llvalue -> string -> llbuilder ->
-                          llvalue = "llvm_build_ptrdiff2"
+external build_ptrdiff : lltype -> llvalue -> llvalue -> string -> llbuilder ->
+                         llvalue = "llvm_build_ptrdiff"
 external build_freeze : llvalue -> string -> llbuilder -> llvalue
                       = "llvm_build_freeze"
 
 
 (*===-- Memory buffers ----------------------------------------------------===*)
 
 module MemoryBuffer = struct
   external of_file : string -> llmemorybuffer = "llvm_memorybuffer_of_file"

llvm/bindings/ocaml/llvm/llvm.mli

 
 (** [subtypes ty] returns [ty]'s subtypes *)
 val subtypes : lltype -> lltype array
 
 (** [array_type ty n] returns the array type containing [n] elements of type
     [ty]. See the method [llvm::ArrayType::get]. *)
 val array_type : lltype -> int -> lltype
 
-(** [pointer_type ty] returns the pointer type referencing objects of type
-    [ty] in the default address space (0).
+(** [pointer_type context] returns the pointer type in the default
+    address space (0).
     See the method [llvm::PointerType::getUnqual]. *)
-val pointer_type : lltype -> lltype
+val pointer_type : llcontext -> lltype
 
-(** [qualified_pointer_type ty as] returns the pointer type referencing objects
-    of type [ty] in address space [as].
+(** [qualified_pointer_type context sp] returns the pointer type referencing
+    objects in address space [sp].
     See the method [llvm::PointerType::get]. *)
-val qualified_pointer_type : lltype -> int -> lltype
-
-(** [pointer_type_in_context context as] returns the opaque pointer type
-    referencing objects in address space [as].
-    See the method [llvm::PointerType::get]. *)
-val pointer_type_in_context : llcontext -> int -> lltype
+val qualified_pointer_type : llcontext -> int -> lltype
 
 (** [vector_type ty n] returns the array type containing [n] elements of the
     primitive type [ty]. See the method [llvm::ArrayType::get]. *)
 val vector_type : lltype -> int -> lltype
 
 (** [element_type ty] returns the element type of the pointer, vector, or array
     type [ty]. See the method [llvm::SequentialType::get]. *)
 val element_type : lltype -> lltype
(** [const_lshr c1 c2] returns the constant integer [c1] right-shifted by the
     See the method [llvm::ConstantExpr::getLShr]. *)
 val const_lshr : llvalue -> llvalue -> llvalue
 
 (** [const_ashr c1 c2] returns the constant integer [c1] right-shifted by the
     constant integer [c2] with sign extension.
     See the method [llvm::ConstantExpr::getAShr]. *)
 val const_ashr : llvalue -> llvalue -> llvalue
 
-(** [const_gep pc indices] returns the constant [getElementPtr] of [pc] with the
-    constant integers indices from the array [indices].
-    See the method [llvm::ConstantExpr::getGetElementPtr]. *)
-val const_gep : llvalue -> llvalue array -> llvalue
-
-(** [const_gep2 srcty pc indices] returns the constant [getElementPtr] of [pc]
+(** [const_gep srcty pc indices] returns the constant [getElementPtr] of [pc]
     with source element type [srcty] and the constant integers indices from the
     array [indices].
     See the method [llvm::ConstantExpr::getGetElementPtr]. *)
-val const_gep2 : lltype -> llvalue -> llvalue array -> llvalue
+val const_gep : lltype -> llvalue -> llvalue array -> llvalue
 
 (** [const_in_bounds_gep pc indices] returns the constant [getElementPtr] of [pc]
     with the constant integers indices from the array [indices].
     See the method [llvm::ConstantExpr::getInBoundsGetElementPtr]. *)
 val const_in_bounds_gep : llvalue -> llvalue array -> llvalue
 
 (** [const_trunc c ty] returns the constant truncation of integer constant [c]
     to the smaller integer type [ty].

 (** [set_externally_initialized c gv] sets the global variable [gv] to be
     externally initialized if [c] is [true] and not otherwise.
     See the method [llvm::GlobalVariable::setExternallyInitialized]. *)
 val set_externally_initialized : bool -> llvalue -> unit
 
 
 (** {7 Operations on aliases} *)
 
-(** [add_alias m t a n] inserts an alias in the module [m] with the type [t] and
-    the aliasee [a] with the name [n].
+(** [add_alias m vt sp a n] inserts an alias in the module [m] with the value
+    type [vt] the address space [sp] the aliasee [a] with the name [n].
     See the constructor for [llvm::GlobalAlias]. *)
-val add_alias : llmodule -> lltype -> llvalue -> string -> llvalue
-
-(** [add_alias m vt as a n] inserts an alias in the module [m] with the value
-    type [vt] the address space [as] the aliasee [a] with the name [n].
-    See the constructor for [llvm::GlobalAlias]. *)
-val add_alias2 : llmodule -> lltype -> int -> llvalue -> string -> llvalue
+val add_alias : llmodule -> lltype -> int -> llvalue -> string -> llvalue
 
 (** {7 Operations on functions} *)
 
 (** [declare_function name ty m] returns a new function of type [ty] and
     with name [name] in module [m]. If such a function already exists,
     it is returned. If the type of the existing function differs, then a bitcast
     to [ty] is returned. *)
 val declare_function : string -> lltype -> llmodule -> llvalue
(** [build_indirect_br addr count b] creates a
     See the method [llvm::LLVMBuilder::CreateIndirectBr]. *)
 val build_indirect_br : llvalue -> int -> llbuilder -> llvalue
 
 (** [add_destination br bb] adds the basic block [bb] as a possible branch
     location for the indirectbr instruction [br].
     See the method [llvm::IndirectBrInst::addDestination]. **)
 val add_destination : llvalue -> llbasicblock -> unit
 
-(** [build_invoke fn args tobb unwindbb name b] creates an
-    [%name = invoke %fn(args) to %tobb unwind %unwindbb]
-    instruction at the position specified by the instruction builder [b].
-    See the method [llvm::LLVMBuilder::CreateInvoke]. *)
-val build_invoke : llvalue -> llvalue array -> llbasicblock ->
-                        llbasicblock -> string -> llbuilder -> llvalue
-
-(** [build_invoke2 fnty fn args tobb unwindbb name b] creates an
+(** [build_invoke fnty fn args tobb unwindbb name b] creates an
     [%name = invoke %fn(args) to %tobb unwind %unwindbb]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateInvoke]. *)
-val build_invoke2 : lltype -> llvalue -> llvalue array -> llbasicblock ->
-                        llbasicblock -> string -> llbuilder -> llvalue
+val build_invoke : lltype -> llvalue -> llvalue array -> llbasicblock ->
 
 (** [build_landingpad ty persfn numclauses name b] creates an
     [landingpad]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateLandingPad]. *)
 val build_landingpad : lltype -> llvalue -> int -> string -> llbuilder ->
                          llvalue
 

 
 (** [build_array_alloca ty n name b] creates a
     [%name = alloca %ty, %n]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateAlloca]. *)
 val build_array_alloca : lltype -> llvalue -> string -> llbuilder ->
                               llvalue
 
-(** [build_load v name b] creates a
-    [%name = load %v]
-    instruction at the position specified by the instruction builder [b].
-    See the method [llvm::LLVMBuilder::CreateLoad]. *)
-val build_load : llvalue -> string -> llbuilder -> llvalue
-
-(** [build_load2 ty v name b] creates a
+(** [build_load ty v name b] creates a
     [%name = load %ty, %v]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateLoad]. *)
-val build_load2 : lltype -> llvalue -> string -> llbuilder -> llvalue
+val build_load : lltype -> llvalue -> string -> llbuilder -> llvalue
 
 (** [build_store v p b] creates a
     [store %v, %p]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateStore]. *)
 val build_store : llvalue -> llvalue -> llbuilder -> llvalue
 
 (** [build_atomicrmw op ptr val o st b] creates an [atomicrmw] instruction with
     operation [op] performed on pointer [ptr] and value [val] with ordering [o]
     and singlethread flag set to [st] at the position specified by
     the instruction builder [b].
     See the method [llvm::IRBuilder::CreateAtomicRMW]. *)
 val build_atomicrmw : AtomicRMWBinOp.t -> llvalue -> llvalue ->
                       AtomicOrdering.t -> bool -> string -> llbuilder -> llvalue
 
-(** [build_gep p indices name b] creates a
-    [%name = getelementptr %p, indices...]
-    instruction at the position specified by the instruction builder [b].
-    See the method [llvm::LLVMBuilder::CreateGetElementPtr]. *)
-val build_gep : llvalue -> llvalue array -> string -> llbuilder -> llvalue
-
-(** [build_gep2 srcty p indices name b] creates a
+(** [build_gep srcty p indices name b] creates a
     [%name = getelementptr srcty, %p, indices...]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateGetElementPtr]. *)
-val build_gep2 : lltype -> llvalue -> llvalue array -> string -> llbuilder ->
-                       llvalue
-
-(** [build_in_bounds_gep p indices name b] creates a
-    [%name = gelementptr inbounds %p, indices...]
-    instruction at the position specified by the instruction builder [b].
-    See the method [llvm::LLVMBuilder::CreateInBoundsGetElementPtr]. *)
-val build_in_bounds_gep : llvalue -> llvalue array -> string -> llbuilder ->
-                               llvalue
+val build_gep : lltype -> llvalue -> llvalue array -> string -> llbuilder ->
 
-(** [build_in_bounds_gep2 srcty p indices name b] creates a
+(** [build_in_bounds_gep srcty p indices name b] creates a
     [%name = gelementptr inbounds srcty, %p, indices...]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateInBoundsGetElementPtr]. *)
-val build_in_bounds_gep2 : lltype -> llvalue -> llvalue array -> string ->
-                                llbuilder -> llvalue
+val build_in_bounds_gep : lltype -> llvalue -> llvalue array -> string ->
 
-(** [build_struct_gep p idx name b] creates a
-    [%name = getelementptr %p, 0, idx]
-    instruction at the position specified by the instruction builder [b].
-    See the method [llvm::LLVMBuilder::CreateStructGetElementPtr]. *)
-val build_struct_gep : llvalue -> int -> string -> llbuilder ->
-                            llvalue
-
-(** [build_struct_gep2 srcty p idx name b] creates a
+(** [build_struct_gep srcty p idx name b] creates a
     [%name = getelementptr srcty, %p, 0, idx]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateStructGetElementPtr]. *)
-val build_struct_gep2 : lltype -> llvalue -> int -> string -> llbuilder ->
-                            llvalue
+val build_struct_gep : lltype -> llvalue -> int -> string -> llbuilder ->
 
 (** [build_global_string str name b] creates a series of instructions that adds
     a global string at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateGlobalString]. *)
 val build_global_string : string -> string -> llbuilder -> llvalue
 
 (** [build_global_stringptr str name b] creates a series of instructions that
     adds a global string pointer at the position specified by the instruction
val build_phi : (llvalue * llbasicblock) list -> string -> llbuilder ->
                      llvalue
 
 (** [build_empty_phi ty name b] creates a
     [%name = phi %ty] instruction at the position specified by
     the instruction builder [b]. [ty] is the type of the instruction.
     See the method [llvm::LLVMBuilder::CreatePHI]. *)
 val build_empty_phi : lltype -> string -> llbuilder -> llvalue
 
-(** [build_call fn args name b] creates a
+(** [build_call fnty fn args name b] creates a
     [%name = call %fn(args...)]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateCall]. *)
-val build_call : llvalue -> llvalue array -> string -> llbuilder -> llvalue
-
-(** [build_call2 fnty fn args name b] creates a
-    [%name = call %fn(args...)]
-    instruction at the position specified by the instruction builder [b].
-    See the method [llvm::LLVMBuilder::CreateCall]. *)
-val build_call2 : lltype -> llvalue -> llvalue array -> string -> llbuilder ->
-                        llvalue
+val build_call : lltype -> llvalue -> llvalue array -> string -> llbuilder ->
 
 (** [build_select cond thenv elsev name b] creates a
     [%name = select %cond, %thenv, %elsev]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateSelect]. *)
 val build_select : llvalue -> llvalue -> llvalue -> string -> llbuilder ->
                         llvalue
 

 val build_is_null : llvalue -> string -> llbuilder -> llvalue
 
 (** [build_is_not_null val name b] creates a
     [%name = icmp ne %val, null]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateIsNotNull]. *)
 val build_is_not_null : llvalue -> string -> llbuilder -> llvalue
 
-(** [build_ptrdiff lhs rhs name b] creates a series of instructions that measure
-    the difference between two pointer values at the position specified by the
-    instruction builder [b].
-    See the method [llvm::LLVMBuilder::CreatePtrDiff]. *)
-val build_ptrdiff : llvalue -> llvalue -> string -> llbuilder -> llvalue
-
-(** [build_ptrdiff2 elemty lhs rhs name b] creates a series of instructions
+(** [build_ptrdiff elemty lhs rhs name b] creates a series of instructions
     that measure the difference between two pointer values in multiples of
     [elemty] at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreatePtrDiff]. *)
-val build_ptrdiff2 : lltype -> llvalue -> llvalue -> string -> llbuilder ->
-                     llvalue
+val build_ptrdiff : lltype -> llvalue -> llvalue -> string -> llbuilder ->
 
 (** [build_freeze x name b] creates a
     [%name = freeze %x]
     instruction at the position specified by the instruction builder [b].
     See the method [llvm::LLVMBuilder::CreateFreeze]. *)
 val build_freeze : llvalue -> string -> llbuilder -> llvalue
 
 

llvm/bindings/ocaml/llvm/llvm_ocaml.c

value llvm_subtypes(LLVMTypeRef Ty) {
   return Arr;
 }
 
 /* lltype -> int -> lltype */
 LLVMTypeRef llvm_array_type(LLVMTypeRef ElementTy, value Count) {
   return LLVMArrayType(ElementTy, Int_val(Count));
 }
 
-/* lltype -> lltype */
-LLVMTypeRef llvm_pointer_type(LLVMTypeRef ElementTy) {
-  return LLVMPointerType(ElementTy, 0);
-}
-
-/* lltype -> int -> lltype */
-LLVMTypeRef llvm_qualified_pointer_type(LLVMTypeRef ElementTy,
-                                        value AddressSpace) {
-  return LLVMPointerType(ElementTy, Int_val(AddressSpace));
+/* llcontext -> lltype */
+LLVMTypeRef llvm_pointer_type(LLVMContextRef C, value AddressSpace) {
+  return LLVMPointerTypeInContext(C, 0);
 }
 
 /* llcontext -> int -> lltype */
-LLVMTypeRef llvm_pointer_type_in_context(LLVMContextRef C, value AddressSpace) {
+LLVMTypeRef llvm_qualified_pointer_type(LLVMContextRef C, value AddressSpace) {
   return LLVMPointerTypeInContext(C, Int_val(AddressSpace));
 }
 
 /* lltype -> int -> lltype */
 LLVMTypeRef llvm_vector_type(LLVMTypeRef ElementTy, value Count) {
   return LLVMVectorType(ElementTy, Int_val(Count));
 }
 

 }
 
 /* Fcmp.t -> llvalue -> llvalue -> llvalue */
 LLVMValueRef llvm_const_fcmp(value Pred, LLVMValueRef LHSConstant,
                              LLVMValueRef RHSConstant) {
   return LLVMConstFCmp(Int_val(Pred), LHSConstant, RHSConstant);
 }
 
-/* llvalue -> llvalue array -> llvalue */
-LLVMValueRef llvm_const_gep(LLVMValueRef ConstantVal, value Indices) {
-  return LLVMConstGEP(ConstantVal, (LLVMValueRef *)Op_val(Indices),
-                      Wosize_val(Indices));
-}
-
 /* lltype -> llvalue -> llvalue array -> llvalue */
-LLVMValueRef llvm_const_gep2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
+LLVMValueRef llvm_const_gep(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
                             value Indices) {
   return LLVMConstGEP2(Ty, ConstantVal, (LLVMValueRef *)Op_val(Indices),
                        Wosize_val(Indices));
 }
 
 /* llvalue -> llvalue array -> llvalue */
 LLVMValueRef llvm_const_in_bounds_gep(LLVMValueRef ConstantVal, value Indices) {
   return LLVMConstInBoundsGEP(ConstantVal, (LLVMValueRef *)Op_val(Indices),

 /* bool -> llvalue -> unit */
 value llvm_set_global_constant(value Flag, LLVMValueRef GlobalVar) {
   LLVMSetGlobalConstant(GlobalVar, Bool_val(Flag));
   return Val_unit;
 }
 
 /*--... Operations on aliases ..............................................--*/
 
-LLVMValueRef llvm_add_alias(LLVMModuleRef M, LLVMTypeRef Ty,
-                            LLVMValueRef Aliasee, value Name) {
-  return LLVMAddAlias(M, Ty, Aliasee, String_val(Name));
-}
-
-LLVMValueRef llvm_add_alias2(LLVMModuleRef M, LLVMTypeRef ValueTy,
+LLVMValueRef llvm_add_alias(LLVMModuleRef M, LLVMTypeRef ValueTy,
                             value AddrSpace, LLVMValueRef Aliasee, value Name) {
   return LLVMAddAlias2(M, ValueTy, Int_val(AddrSpace), Aliasee,
                        String_val(Name));
 }
 
 /*--... Operations on functions ............................................--*/
 
 DEFINE_ITERATORS(function, Function, LLVMModuleRef, LLVMValueRef,

 }
 
 /* llvalue -> llvalue -> llbasicblock -> unit */
 value llvm_add_destination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) {
   LLVMAddDestination(IndirectBr, Dest);
   return Val_unit;
 }
 
-/* llvalue -> llvalue array -> llbasicblock -> llbasicblock -> string ->
-   llbuilder -> llvalue */
-LLVMValueRef llvm_build_invoke_nat(LLVMValueRef Fn, value Args,
-                                   LLVMBasicBlockRef Then,
-                                   LLVMBasicBlockRef Catch, value Name,
-                                   value B) {
-  return LLVMBuildInvoke(Builder_val(B), Fn, (LLVMValueRef *)Op_val(Args),
-                         Wosize_val(Args), Then, Catch, String_val(Name));
-}
-
-/* llvalue -> llvalue array -> llbasicblock -> llbasicblock -> string ->
-   llbuilder -> llvalue */
-LLVMValueRef llvm_build_invoke_bc(value Args[], int NumArgs) {
-  return llvm_build_invoke_nat((LLVMValueRef)Args[0], Args[1],
-                               (LLVMBasicBlockRef)Args[2],
-                               (LLVMBasicBlockRef)Args[3], Args[4], Args[5]);
-}
-
 /* lltype -> llvalue -> llvalue array -> llbasicblock -> llbasicblock ->
    string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_invoke2_nat(LLVMTypeRef FnTy, LLVMValueRef Fn,
-                                    value Args, LLVMBasicBlockRef Then,
-                                    LLVMBasicBlockRef Catch, value Name,
-                                    value B) {
+LLVMValueRef llvm_build_invoke_nat(LLVMTypeRef FnTy, LLVMValueRef Fn,
   return LLVMBuildInvoke2(Builder_val(B), FnTy, Fn,
                           (LLVMValueRef *)Op_val(Args), Wosize_val(Args),
                           Then, Catch, String_val(Name));
 }
 
 /* lltype -> llvalue -> llvalue array -> llbasicblock -> llbasicblock ->
    string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_invoke2_bc(value Args[], int NumArgs) {
-  return llvm_build_invoke2_nat((LLVMTypeRef)Args[0], (LLVMValueRef)Args[1],
-                                Args[2], (LLVMBasicBlockRef)Args[3],
+LLVMValueRef llvm_build_invoke_bc(value Args[], int NumArgs) {
+  return llvm_build_invoke_nat((LLVMTypeRef)Args[0], (LLVMValueRef)Args[1],
                                (LLVMBasicBlockRef)Args[4], Args[5], Args[6]);
 }
 
 /* lltype -> llvalue -> int -> string -> llbuilder -> llvalue */
 LLVMValueRef llvm_build_landingpad(LLVMTypeRef Ty, LLVMValueRef PersFn,
                                    value NumClauses, value Name, value B) {
   return LLVMBuildLandingPad(Builder_val(B), Ty, PersFn, Int_val(NumClauses),
                              String_val(Name));

 }
 
 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
 LLVMValueRef llvm_build_array_alloca(LLVMTypeRef Ty, LLVMValueRef Size,
                                      value Name, value B) {
   return LLVMBuildArrayAlloca(Builder_val(B), Ty, Size, String_val(Name));
 }
 
-/* llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_load(LLVMValueRef Pointer, value Name, value B) {
-  return LLVMBuildLoad(Builder_val(B), Pointer, String_val(Name));
-}
-
 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_load2(LLVMTypeRef Ty, LLVMValueRef Pointer, value Name,
-                              value B) {
+LLVMValueRef llvm_build_load(LLVMTypeRef Ty, LLVMValueRef Pointer, value Name,
   return LLVMBuildLoad2(Builder_val(B), Ty, Pointer, String_val(Name));
 }
 
 /* llvalue -> llvalue -> llbuilder -> llvalue */
 LLVMValueRef llvm_build_store(LLVMValueRef Value, LLVMValueRef Pointer,
                               value B) {
   return LLVMBuildStore(Builder_val(B), Value, Pointer);
 }

 }
 
 LLVMValueRef llvm_build_atomicrmw_bytecode(value *argv, int argn) {
   return llvm_build_atomicrmw_native(argv[0], (LLVMValueRef)argv[1],
                                      (LLVMValueRef)argv[2], argv[3], argv[4],
                                      argv[5], argv[6]);
 }
 
-/* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_gep(LLVMValueRef Pointer, value Indices, value Name,
-                            value B) {
-  return LLVMBuildGEP(Builder_val(B), Pointer, (LLVMValueRef *)Op_val(Indices),
-                      Wosize_val(Indices), String_val(Name));
-}
-
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_gep2(LLVMTypeRef Ty, LLVMValueRef Pointer,
-                             value Indices, value Name, value B) {
+LLVMValueRef llvm_build_gep(LLVMTypeRef Ty, LLVMValueRef Pointer, value Indices,
+                            value Name, value B) {
   return LLVMBuildGEP2(Builder_val(B), Ty, Pointer,
                        (LLVMValueRef *)Op_val(Indices), Wosize_val(Indices),
                        String_val(Name));
 }
 
-/* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_in_bounds_gep(LLVMValueRef Pointer, value Indices,
-                                      value Name, value B) {
-  return LLVMBuildInBoundsGEP(Builder_val(B), Pointer,
-                              (LLVMValueRef *)Op_val(Indices),
-                              Wosize_val(Indices), String_val(Name));
-}
-
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_in_bounds_gep2(LLVMTypeRef Ty, LLVMValueRef Pointer,
-                                       value Indices, value Name, value B) {
+LLVMValueRef llvm_build_in_bounds_gep(LLVMTypeRef Ty, LLVMValueRef Pointer,
   return LLVMBuildInBoundsGEP2(Builder_val(B), Ty, Pointer,
                                (LLVMValueRef *)Op_val(Indices),
                                Wosize_val(Indices), String_val(Name));
 }
 
-/* llvalue -> int -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_struct_gep(LLVMValueRef Pointer, value Index,
-                                   value Name, value B) {
-  return LLVMBuildStructGEP(Builder_val(B), Pointer, Int_val(Index),
-                            String_val(Name));
-}
-
 /* lltype -> llvalue -> int -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_struct_gep2(LLVMTypeRef Ty, LLVMValueRef Pointer,
-                                    value Index, value Name, value B) {
+LLVMValueRef llvm_build_struct_gep(LLVMTypeRef Ty, LLVMValueRef Pointer,
   return LLVMBuildStructGEP2(Builder_val(B), Ty, Pointer, Int_val(Index),
                              String_val(Name));
 }
 
 /* string -> string -> llbuilder -> llvalue */
 LLVMValueRef llvm_build_global_string(value Str, value Name, value B) {
   return LLVMBuildGlobalString(Builder_val(B), String_val(Str),
                                String_val(Name));
LLVMValueRef llvm_build_phi(value Incoming, value Name, value B) {
   return PhiNode;
 }
 
 /* lltype -> string -> llbuilder -> value */
 LLVMValueRef llvm_build_empty_phi(LLVMTypeRef Type, value Name, value B) {
   return LLVMBuildPhi(Builder_val(B), Type, String_val(Name));
 }
 
-/* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_call(LLVMValueRef Fn, value Params, value Name,
-                             value B) {
-  return LLVMBuildCall(Builder_val(B), Fn, (LLVMValueRef *)Op_val(Params),
-                       Wosize_val(Params), String_val(Name));
-}
-
 /* lltype -> llvalue -> llvalue array -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_call2(LLVMTypeRef FnTy, LLVMValueRef Fn, value Params,
-                              value Name, value B) {
+LLVMValueRef llvm_build_call(LLVMTypeRef FnTy, LLVMValueRef Fn, value Params,
   return LLVMBuildCall2(Builder_val(B), FnTy, Fn,
                         (LLVMValueRef *)Op_val(Params), Wosize_val(Params),
                         String_val(Name));
 }
 
 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 LLVMValueRef llvm_build_select(LLVMValueRef If, LLVMValueRef Then,
                                LLVMValueRef Else, value Name, value B) {

 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 LLVMValueRef llvm_build_is_not_null(LLVMValueRef Val, value Name, value B) {
   return LLVMBuildIsNotNull(Builder_val(B), Val, String_val(Name));
 }
 
 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_ptrdiff(LLVMValueRef LHS, LLVMValueRef RHS, value Name,
-                                value B) {
-  return LLVMBuildPtrDiff(Builder_val(B), LHS, RHS, String_val(Name));
-}
-
-/* llvalue -> llvalue -> string -> llbuilder -> llvalue */
-LLVMValueRef llvm_build_ptrdiff2(LLVMTypeRef ElemTy, LLVMValueRef LHS,
-                                 LLVMValueRef RHS, value Name, value B) {
+LLVMValueRef llvm_build_ptrdiff(LLVMTypeRef ElemTy, LLVMValueRef LHS,
   return LLVMBuildPtrDiff2(Builder_val(B), ElemTy, LHS, RHS, String_val(Name));
 }
 
 /* llvalue -> string -> llbuilder -> llvalue */
 LLVMValueRef llvm_build_freeze(LLVMValueRef X, value Name, value B) {
   return LLVMBuildFreeze(Builder_val(B), X, String_val(Name));
 }
 

llvm/test/Bindings/OCaml/core.ml

 
 let test_contained_types () =
   let ar = struct_type context [| i32_type; i8_type |] in
   insist (i32_type = (Array.get (subtypes ar)) 0);
   insist (i8_type = (Array.get (subtypes ar)) 1)
 
 (*===-- Pointer types  ----------------------------------------------------===*)
 let test_pointer_types () =
-  insist (address_space (pointer_type_in_context context 0) = 0);
-  insist (address_space (pointer_type_in_context context 1) = 1)
+  insist (address_space (pointer_type context) = 0);
+  insist (address_space (qualified_pointer_type context 0) = 0);
+  insist (address_space (qualified_pointer_type context 1) = 1)
 
 (*===-- Conversion --------------------------------------------------------===*)
 
 let test_conversion () =
   insist ("i32" = (string_of_lltype i32_type));
   let c = const_int i32_type 42 in
   insist ("i32 42" = (string_of_llvalue c))
 
let test_constants () =
    *)
   group "all ones";
   let c = const_all_ones i64_type in
   ignore (define_global "const_all_ones" c m);
 
   group "pointer null"; begin
     (* CHECK: const_pointer_null = global ptr null
      *)
-    let c = const_pointer_null (pointer_type i64_type) in
+    let c = const_pointer_null (pointer_type context) in
     ignore (define_global "const_pointer_null" c m);
   end;
 
   (* CHECK: const_undef{{.*}}undef
    *)
   group "undef";
   let c = undef i1_type in
   ignore (define_global "const_undef" c m);
let test_constants () =
    * CHECK: @const_nsw_mul = global i64 mul nsw
    * CHECK: @const_nuw_mul = global i64 mul nuw
    * CHECK: @const_and = global i64 and
    * CHECK: @const_or = global i64 or
    * CHECK: @const_xor = global i64 xor
    * CHECK: @const_icmp = global i1 icmp sle
    * CHECK: @const_fcmp = global i1 fcmp ole
    *)
-  let void_ptr = pointer_type i8_type in
+  let void_ptr = pointer_type context in
   let five = const_int i64_type 5 in
   let ffive = const_uitofp five double_type in
   let foldbomb_gv = define_global "FoldBomb" (const_null i8_type) m in
   let foldbomb = const_ptrtoint foldbomb_gv i64_type in
   let ffoldbomb = const_uitofp foldbomb double_type in
   ignore (define_global "const_neg" (const_neg foldbomb) m);
   ignore (define_global "const_nsw_neg" (const_nsw_neg foldbomb) m);
   ignore (define_global "const_nuw_neg" (const_nuw_neg foldbomb) m);
let test_constants () =
   ignore (define_global "const_zext" (const_zext foldbomb i128_type) m);
   ignore (define_global "const_fptrunc" (const_fptrunc ffoldbomb float_type) m);
   ignore (define_global "const_fpext" (const_fpext ffoldbomb fp128_type) m);
   ignore (define_global "const_uitofp" (const_uitofp foldbomb double_type) m);
   ignore (define_global "const_sitofp" (const_sitofp foldbomb double_type) m);
   ignore (define_global "const_fptoui" (const_fptoui ffoldbomb i32_type) m);
   ignore (define_global "const_fptosi" (const_fptosi ffoldbomb i32_type) m);
   ignore (define_global "const_ptrtoint" (const_ptrtoint
-    (const_gep2 i8_type (const_null (pointer_type i8_type))
-                [| const_int i32_type 1 |])
+    (const_gep i8_type (const_null (pointer_type context))
     i32_type) m);
   ignore (define_global "const_inttoptr" (const_inttoptr (const_add foldbomb five)
                                                   void_ptr) m);
   ignore (define_global "const_bitcast" (const_bitcast ffoldbomb i64_type) m);
   ignore (define_global "const_intcast"
           (const_intcast foldbomb i128_type ~is_signed:false) m);
 
   group "misc constants";
   (* CHECK: const_size_of{{.*}}getelementptr{{.*}}null
    * CHECK: const_gep{{.*}}getelementptr
    * CHECK: const_select{{.*}}select
    * CHECK: const_extractelement{{.*}}extractelement
    * CHECK: const_insertelement{{.*}}insertelement
    * CHECK: const_shufflevector = global <4 x i32> <i32 0, i32 1, i32 1, i32 0>
    *)
-  ignore (define_global "const_size_of" (size_of (pointer_type i8_type)) m);
-  ignore (define_global "const_gep" (const_gep2 i8_type foldbomb_gv [| five |])
+  ignore (define_global "const_size_of" (size_of (pointer_type context)) m);
+  ignore (define_global "const_gep" (const_gep i8_type foldbomb_gv [| five |])
           m);
   ignore (define_global "const_select" (const_select
     (const_icmp Icmp.Sle foldbomb five)
     (const_int i8_type (-1))
     (const_int i8_type 0)) m);
   let zero = const_int i32_type 0 in
   let one  = const_int i32_type 1 in
   ignore (define_global "const_extractelement" (const_extractelement
ignore (const_inline_asm
       ""
       "{cx},{ax},{di},~{dirflag},~{fpsr},~{flags},~{edi},~{ecx}"
       true
       false)
   end;
 
   group "recursive struct"; begin
       let nsty = named_struct_type context "rec" in
-      let pty = pointer_type nsty in
+      let pty = pointer_type context in
       struct_set_body nsty [| i32_type; pty |] false;
       let elts = [| const_int i32_type 4; const_pointer_null pty |] in
       let grec_init = const_named_struct nsty elts in
       ignore (define_global "grec" grec_init m);
       ignore (string_of_lltype nsty);
   end
 
 
let test_global_variables () =
 
   group "declarations"; begin
     (* CHECK: @GVar01 = external global i32
      * CHECK: @QGVar01 = external addrspace(3) global i32
      *)
     insist (None == lookup_global "GVar01" m);
     let g = declare_global i32_type "GVar01" m in
     insist (is_declaration g);
-    insist (pointer_type float_type ==
+    insist (pointer_type context ==
               type_of (declare_global float_type "GVar01" m));
     insist (g == declare_global i32_type "GVar01" m);
     insist (match lookup_global "GVar01" m with Some x -> x = g
                                               | None -> false);
 
     insist (None == lookup_global "QGVar01" m);
     let g = declare_qualified_global i32_type "QGVar01" 3 m in
     insist (is_declaration g);
-    insist (qualified_pointer_type float_type 3 ==
+    insist (qualified_pointer_type context 3 ==
               type_of (declare_qualified_global float_type "QGVar01" 3 m));
     insist (g == declare_qualified_global i32_type "QGVar01" 3 m);
     insist (match lookup_global "QGVar01" m with Some x -> x = g
                                               | None -> false);
   end;
 
   group "definitions"; begin
     (* CHECK: @GVar02 = global i32 42

 let test_users () =
   let ty = function_type i32_type [| i32_type; i32_type |] in
   let fn = define_function "user_function" ty m in
   let b = builder_at_end context (entry_block fn) in
 
   let p1 = param fn 0 in
   let p2 = param fn 1 in
   let a3 = build_alloca i32_type "user_alloca" b in
-  let p3 = build_load2 i32_type a3 "user_load" b in
+  let p3 = build_load i32_type a3 "user_load" b in
   let i = build_add p1 p2 "sum" b in
 
   insist ((num_operands i) = 2);
   insist ((operand i 0) = p1);
   insist ((operand i 1) = p2);
 
   set_operand i 1 p3;
   insist ((operand i 1) != p2);
   insist ((operand i 1) = p3);
 
   ignore (build_unreachable b)
 
 
 (*===-- Aliases -----------------------------------------------------------===*)
 
 let test_aliases () =
   (* CHECK: @alias = alias i32, ptr @aliasee
    *)
   let forty_two32 = const_int i32_type 42 in
   let v = define_global "aliasee" forty_two32 m in
-  ignore (add_alias2 m i32_type 0 v "alias")
+  ignore (add_alias m i32_type 0 v "alias")
 
 
 (*===-- Functions ---------------------------------------------------------===*)
 
 let test_functions () =
   let ty = function_type i32_type [| i32_type; i64_type |] in
   let ty2 = function_type i8_type [| i8_type; i64_type |] in
 
   (* CHECK: declare i32 @Fn1(i32, i64)
    *)
   begin group "declare";
     insist (None = lookup_function "Fn1" m);
     let fn = declare_function "Fn1" ty m in
-    insist (pointer_type ty = type_of fn);
+    insist (pointer_type context = type_of fn);
     insist (is_declaration fn);
     insist (0 = Array.length (basic_blocks fn));
-    insist (pointer_type ty2 == type_of (declare_function "Fn1" ty2 m));
+    insist (pointer_type context == type_of (declare_function "Fn1" ty2 m));
     insist (fn == declare_function "Fn1" ty m);
     insist (None <> lookup_function "Fn1" m);
     insist (match lookup_function "Fn1" m with Some x -> x = fn
                                              | None -> false);
     insist (m == global_parent fn)
   end;
 
   (* CHECK-NOWHERE-NOT: Fn2
begin
     add_function_attr fn nounwind AttrIndex.Function;
     add_function_attr fn zeroext AttrIndex.Return;
 
     (* CHECK: define zeroext i32 @X7(i32 signext %P1, i32 %P2)
      *)
   end;
 
   group "casts"; begin
-    let void_ptr = pointer_type i8_type in
+    let void_ptr = pointer_type context in
 
     (* CHECK-DAG: %build_trunc = trunc i32 %P1 to i8
      * CHECK-DAG: %build_trunc2 = trunc i32 %P1 to i8
      * CHECK-DAG: %build_trunc3 = trunc i32 %P1 to i8
      * CHECK-DAG: %build_zext = zext i8 %build_trunc to i32
      * CHECK-DAG: %build_zext2 = zext i8 %build_trunc to i32
      * CHECK-DAG: %build_sext = sext i32 %build_zext to i64
      * CHECK-DAG: %build_sext2 = sext i32 %build_zext to i64
group "casts"; begin
     let inst35 = build_fptrunc inst32 float_type "build_fptrunc" atentry in
     ignore(build_fpext inst35 double_type "build_fpext" atentry);
     let inst37 = build_inttoptr p1 void_ptr "build_inttoptr" atentry in
     let inst38 = build_ptrtoint inst37 i64_type "build_ptrtoint" atentry in
     ignore(build_bitcast inst38 double_type "build_bitcast" atentry);
     ignore(build_zext_or_bitcast inst38 double_type "build_bitcast2" atentry);
     ignore(build_sext_or_bitcast inst38 double_type "build_bitcast3" atentry);
     ignore(build_trunc_or_bitcast inst38 double_type "build_bitcast4" atentry);
-    ignore(build_pointercast inst37 (pointer_type i16_type) "build_pointercast" atentry);
+    ignore(build_pointercast inst37 (pointer_type context) "build_pointercast" atentry);
 
     ignore(build_zext_or_bitcast inst28 i32_type "build_zext2" atentry);
     ignore(build_sext_or_bitcast inst29 i64_type "build_sext2" atentry);
     ignore(build_trunc_or_bitcast p1 i8_type "build_trunc2" atentry);
     ignore(build_pointercast inst37 i64_type "build_ptrtoint2" atentry);
     ignore(build_intcast inst29 i64_type "build_sext3" atentry);
     ignore(build_intcast p1 i8_type "build_trunc3" atentry);
     ignore(build_fpcast inst35 double_type "build_fpext2" atentry);
group "comparisons"; begin
     let c = build_fcmp Fcmp.False f1 f2 "build_fcmp_false" atentry in
     (* insist (Some Fcmp.False = fcmp_predicate c); *)
     insist (None = icmp_predicate c);
 
     let c = build_fcmp Fcmp.True  f2 f1 "build_fcmp_true" atentry in
     (* insist (Some Fcmp.True = fcmp_predicate c); *)
     insist (None = icmp_predicate c);
 
-    let g0 = declare_global (pointer_type i8_type) "g0" m in
-    let g1 = declare_global (pointer_type i8_type) "g1" m in
-    let p0 = build_load2 (pointer_type i8_type) g0 "X0" atentry in
-    let p1 = build_load2 (pointer_type i8_type) g1 "X1" atentry in
+    let g0 = declare_global (pointer_type context) "g0" m in
+    let g1 = declare_global (pointer_type context) "g1" m in
+    let p0 = build_load (pointer_type context) g0 "X0" atentry in
+    let p1 = build_load (pointer_type context) g1 "X1" atentry in
     ignore (build_is_null p0 "build_is_null" atentry);
     ignore (build_is_not_null p1 "build_is_not_null" atentry);
-    ignore (build_ptrdiff2 i8_type p1 p0 "build_ptrdiff" atentry);
+    ignore (build_ptrdiff i8_type p1 p0 "build_ptrdiff" atentry);
   end;
 
   group "miscellaneous"; begin
     (* CHECK: %build_call = tail call cc63 zeroext i32 @{{.*}}(i32 signext %P2, i32 %P1)
      * CHECK: %build_select = select i1 %build_icmp, i32 %P1, i32 %P2
      * CHECK: %build_va_arg = va_arg ptr null, i32
      * CHECK: %build_extractelement = extractelement <4 x i32> %Vec1, i32 %P2
      * CHECK: %build_insertelement = insertelement <4 x i32> %Vec1, i32 %P1, i32 %P2
      * CHECK: %build_shufflevector = shufflevector <4 x i32> %Vec1, <4 x i32> %Vec2, <4 x i32> <i32 1, i32 1, i32 0, i32 0>
      * CHECK: %build_insertvalue0 = insertvalue{{.*}}%bl, i32 1, 0
      * CHECK: %build_extractvalue = extractvalue{{.*}}%build_insertvalue1, 1
      *)
-    let ci = build_call2 fty fn [| p2; p1 |] "build_call" atentry in
+    let ci = build_call fty fn [| p2; p1 |] "build_call" atentry in
     insist (CallConv.c = instruction_call_conv ci);
     set_instruction_call_conv 63 ci;
     insist (63 = instruction_call_conv ci);
     insist (not (is_tail_call ci));
     set_tail_call true ci;
     insist (is_tail_call ci);
 
     let signext  = create_enum_attr context "signext" 0L in
group "miscellaneous"; begin
     remove_string_call_site_attr ci "no-sse" (AttrIndex.Param 1);
     insist ((call_site_attrs ci (AttrIndex.Param 1)) = [||]);
     add_call_site_attr ci noreturn AttrIndex.Function;
     add_call_site_attr ci zeroext AttrIndex.Return;
 
     let inst46 = build_icmp Icmp.Eq p1 p2 "build_icmp" atentry in
     ignore (build_select inst46 p1 p2 "build_select" atentry);
     ignore (build_va_arg
-      (const_null (pointer_type (pointer_type i8_type)))
+      (const_null (pointer_type context))
       i32_type "build_va_arg" atentry);
 
     (* Set up some vector vregs. *)
     let one  = const_int i32_type 1 in
     let zero = const_int i32_type 0 in
     let t1 = const_vector [| one; zero; one; zero |] in
     let t2 = const_vector [| zero; one; zero; one |] in
     let t3 = const_vector [| one; one; zero; zero |] in
     let vec1 = build_insertelement t1 p1 p2 "Vec1" atentry in
     let vec2 = build_insertelement t2 p1 p2 "Vec2" atentry in
     let sty = struct_type context [| i32_type; i8_type |] in
 
     ignore (build_extractelement vec1 p2 "build_extractelement" atentry);
     ignore (build_insertelement vec1 p1 p2 "build_insertelement" atentry);
     ignore (build_shufflevector vec1 vec2 t3 "build_shufflevector" atentry);
 
     let p = build_alloca sty "ba" atentry in
-    let agg = build_load2 sty p "bl" atentry in
+    let agg = build_load sty p "bl" atentry in
     let agg0 = build_insertvalue agg (const_int i32_type 1) 0
                  "build_insertvalue0" atentry in
     let agg1 = build_insertvalue agg0 (const_int i8_type 2) 1
                  "build_insertvalue1" atentry in
     ignore (build_extractvalue agg1 1 "build_extractvalue" atentry)
   end;
 
   group "metadata"; begin
group "ret"; begin
     (* CHECK: ret{{.*}}P1
      *)
     let ret = build_ret p1 atentry in
     position_before ret atentry
   end;
 
   (* see test/Feature/exception.ll *)
   let bblpad = append_block context "Bblpad" fn in
-  let rt = struct_type context [| pointer_type i8_type; i32_type |] in
+  let rt = struct_type context [| pointer_type context; i32_type |] in
   let ft = var_arg_function_type i32_type  [||] in
   let personality = declare_function "__gxx_personality_v0" ft m in
-  let ztic = declare_global (pointer_type i8_type) "_ZTIc" m in
-  let ztid = declare_global (pointer_type i8_type) "_ZTId" m in
-  let ztipkc = declare_global (pointer_type i8_type) "_ZTIPKc" m in
+  let ztic = declare_global (pointer_type context) "_ZTIc" m in
+  let ztid = declare_global (pointer_type context) "_ZTId" m in
+  let ztipkc = declare_global (pointer_type context) "_ZTIPKc" m in
   begin
       set_global_constant true ztic;
       set_global_constant true ztid;
       set_global_constant true ztipkc;
       let lp = build_landingpad rt personality 0 "lpad"
        (builder_at_end context bblpad) in begin
            set_cleanup lp true;
            add_clause lp ztic;
-           insist((pointer_type (pointer_type i8_type)) = type_of ztid);
-           let ety = pointer_type (pointer_type i8_type) in
+           insist((pointer_type context) = type_of ztid);
+           let ety = pointer_type context in
            add_clause lp (const_array ety [| ztipkc; ztid |]);
            ignore (build_resume lp (builder_at_end context bblpad));
       end;
       (* CHECK: landingpad
        * CHECK: cleanup
        * CHECK: catch{{.*}}ptr{{.*}}@_ZTIc
        * CHECK: filter{{.*}}@_ZTIPKc{{.*}}@_ZTId
        * CHECK: resume
let test_builder () =
   end;
 
   group "malloc/free"; begin
       (* CHECK: call{{.*}}@malloc(i32 ptrtoint
        * CHECK: call{{.*}}@free(ptr
        * CHECK: call{{.*}}@malloc(i32 %
        *)
       let bb1 = append_block context "MallocBlock1" fn in
-      let m1 = (build_malloc (pointer_type i32_type) "m1"
+      let m1 = (build_malloc (pointer_type context) "m1"
       (builder_at_end context bb1)) in
       ignore (build_free m1 (builder_at_end context bb1));
       ignore (build_array_malloc i32_type p1 "m2" (builder_at_end context bb1));
       ignore (build_unreachable (builder_at_end context bb1));
   end;
 
   group "indirectbr"; begin
     (* CHECK: indirectbr ptr blockaddress(@X7, %IBRBlock2), [label %IBRBlock2, label %IBRBlock3]
let test_builder () =
   end;
 
   group "invoke"; begin
     (* CHECK: build_invoke{{.*}}invoke{{.*}}P1{{.*}}P2
      * CHECK: to{{.*}}Bb04{{.*}}unwind{{.*}}Bblpad
      *)
     let bb04 = append_block context "Bb04" fn in
     let b = builder_at_end context bb04 in
-    ignore (build_invoke2 fty fn [| p1; p2 |] bb04 bblpad "build_invoke" b)
+    ignore (build_invoke fty fn [| p1; p2 |] bb04 bblpad "build_invoke" b)
   end;
 
   group "unreachable"; begin
     (* CHECK: unreachable
      *)
     let bb06 = append_block context "Bb06" fn in
     let b = builder_at_end context bb06 in
     ignore (build_unreachable b)
group "memory"; begin
      * CHECK: %build_gep = getelementptr i32, ptr %build_array_alloca, i32 %P2
      * CHECK: %build_in_bounds_gep = getelementptr inbounds i32, ptr %build_array_alloca, i32 %P2
      * CHECK: %build_struct_gep = getelementptr inbounds{{.*}}%build_alloca2, i32 0, i32 1
      * CHECK: %build_atomicrmw = atomicrmw xchg ptr %p, i8 42 seq_cst
      *)
     let alloca = build_alloca i32_type "build_alloca" b in
     let array_alloca = build_array_alloca i32_type p2 "build_array_alloca" b in
 
-    let load = build_load2 i32_type array_alloca "build_load" b in
+    let load = build_load i32_type array_alloca "build_load" b in
     ignore(set_alignment 4 load);
     ignore(set_volatile true load);
     insist(true = is_volatile load);
     insist(4 = alignment load);
 
     let store = build_store p2 alloca b in
     ignore(set_volatile true store);
     ignore(set_alignment 4 store);
     insist(true = is_volatile store);
     insist(4 = alignment store);
-    ignore(build_gep2 i32_type array_alloca [| p2 |] "build_gep" b);
-    ignore(build_in_bounds_gep2 i32_type array_alloca [| p2 |]
+    ignore(build_gep i32_type array_alloca [| p2 |] "build_gep" b);
+    ignore(build_in_bounds_gep i32_type array_alloca [| p2 |]
            "build_in_bounds_gep" b);
 
     let sty = struct_type context [| i32_type; i8_type |] in
     let alloca2 = build_alloca sty "build_alloca2" b in
-    ignore(build_struct_gep2 sty alloca2 1 "build_struct_gep" b);
+    ignore(build_struct_gep sty alloca2 1 "build_struct_gep" b);
 
     let p = build_alloca i8_type "p" b in
     ignore(build_atomicrmw AtomicRMWBinOp.Xchg p (const_int i8_type 42)
               AtomicOrdering.SequentiallyConsistent false "build_atomicrmw"
               b);
 
     ignore(build_unreachable b)
   end;
 
   group "string"; begin
     let bb09 = append_block context "Bb09" fn in
     let b = builder_at_end context bb09 in
-    let p = build_alloca (pointer_type i8_type) "p" b in
+    let p = build_alloca (pointer_type context) "p" b in
     (* build_global_string is emitted above.
      * CHECK: store{{.*}}build_global_string1{{.*}}p
      * *)
     ignore (build_global_string "stringval" "build_global_string" b);
     let g = build_global_stringptr "stringval" "build_global_string1" b in
     ignore (build_store g p b);
     ignore(build_unreachable b);
   end;

llvm/test/Bindings/OCaml/debuginfo.ml

let _ =
     in
     let file_of_f_di = Llvm_debuginfo.di_scope_get_file ~scope:f_di in
     let file_of_scope = Llvm_debuginfo.di_scope_get_file ~scope in
     insist
       ( match (file_of_f_di, file_of_scope) with
       | Some file_of_f_di', Some file_of_scope' ->
           file_of_f_di' = file_di && file_of_scope' = file_di
       | _ -> false );
-    let foocall = Llvm.build_call2 fty foodecl [| arg0 |] "" builder in
+    let foocall = Llvm.build_call fty foodecl [| arg0 |] "" builder in
     let foocall_loc =
       Llvm_debuginfo.dibuild_create_debug_location context ~line:10 ~column:12
         ~scope
     in
     Llvm_debuginfo.instr_set_debug_loc foocall (Some foocall_loc);
     insist
       ( match Llvm_debuginfo.instr_get_debug_loc foocall with
       | Some foocall_loc' -> foocall_loc' = foocall_loc

llvm/test/Bindings/OCaml/executionengine.ml

 let bomb msg =
   prerr_endline msg;
   exit 2
 
 let define_getglobal m pg =
   let fty = function_type i32_type [||] in
   let fn = define_function "getglobal" fty m in
   let b = builder_at_end (global_context ()) (entry_block fn) in
-  let g = build_call2 fty pg [||] "" b in
+  let g = build_call fty pg [||] "" b in
   ignore (build_ret g b);
   fn
 
 let define_plus m =
   let fn = define_function "plus" (function_type i32_type [| i32_type;
                                                              i32_type |]) m in
   let b = builder_at_end (global_context ()) (entry_block fn) in
   let add = build_add (param fn 0) (param fn 1) "sum" b in

llvm/test/Bindings/OCaml/ipo.ml

 let test_transforms () =
   let (++) x f = f x; x in
 
   let fty = function_type i8_type [| |] in
   let fn = define_function "fn" fty m in
   let fn2 = define_function "fn2" fty m in begin
       ignore (build_ret (const_int i8_type 4) (builder_at_end context (entry_block fn)));
       let b = builder_at_end context  (entry_block fn2) in
-      ignore (build_ret (build_call2 fty fn [| |] "" b) b);
+      ignore (build_ret (build_call fty fn [| |] "" b) b);
   end;
 
   ignore (PassManager.create ()
            ++ add_constant_merge
            ++ add_dead_arg_elimination
            ++ add_function_attrs
            ++ add_function_inlining
            ++ add_always_inliner