[llvm-c] Remove C API functions that are incompatible with opaque pointers

[nikic]

Summary

These deprecated functions are incompatible with opaque pointers, and have replacements that accept an explicit type. Drop them now as a final warning to consumers of the C API to migrate their code (while LLVMGetElementType still exists as a temporary workaround).

[arsenm]

Are there not any C API tests?

[nikic]

In D135271#3837069, @arsenm wrote:

Are there not any C API tests?

There are, but the tests have already been migrated to use opaque pointers.

As a side note, I've created https://discourse.llvm.org/t/rfc-remove-the-go-bindings/65725 to drop the Go bindings, which are clearly unmaintained (still no support for opaque pointers).

[aeubanks]

apologies, but can we delay this? I've migrated Google internally to use opaque pointers with clang (after fixing various miscompiles), but we still have non-clang LLVM API users that are using these. I'm in the process of migrating them off legacy APIs (or dropping them altogether) but it'll take some time

[nikic]

In D135271#3837537, @aeubanks wrote:

apologies, but can we delay this? I've migrated Google internally to use opaque pointers with clang (after fixing various miscompiles), but we still have non-clang LLVM API users that are using these. I'm in the process of migrating them off legacy APIs (or dropping them altogether) but it'll take some time

Sure, no particular hurry here. Let me know when you're ready.

[nikic]

Rebase

[nikic]

llvm/bindings/ocaml/llvm/llvm.ml

666

Looks like we missed this one in D135524, because it didn't have a 2 variant yet. Guess we should add the type argument here rather than drop it.

cc @alan

[nikic]

Rebase. This is now down to the C API removals only, and no longer requires changes to other bindings.

[aeubanks]

I've cleaned up our internal uses, thanks for waiting

llvm/bindings/go/llvm/ir.go

func ConstFCmp(pred FloatPredicate, lhs, rhs Value) (v Value) {
   v.C = C.LLVMConstFCmp(C.LLVMRealPredicate(pred), lhs.C, rhs.C)
   return
 }
 
 func ConstShl(lhs, rhs Value) (v Value)  { v.C = C.LLVMConstShl(lhs.C, rhs.C); return }
 func ConstLShr(lhs, rhs Value) (v Value) { v.C = C.LLVMConstLShr(lhs.C, rhs.C); return }
 func ConstAShr(lhs, rhs Value) (v Value) { v.C = C.LLVMConstAShr(lhs.C, rhs.C); return }
 
-func ConstGEP(v Value, indices []Value) (rv Value) {
-  ptr, nvals := llvmValueRefs(indices)
-  rv.C = C.LLVMConstGEP(v.C, ptr, nvals)
-  return
-}
-func ConstInBoundsGEP(v Value, indices []Value) (rv Value) {
-  ptr, nvals := llvmValueRefs(indices)
-  rv.C = C.LLVMConstInBoundsGEP(v.C, ptr, nvals)
-  return
-}
 func ConstTrunc(v Value, t Type) (rv Value)         { rv.C = C.LLVMConstTrunc(v.C, t.C); return }
 func ConstSExt(v Value, t Type) (rv Value)          { rv.C = C.LLVMConstSExt(v.C, t.C); return }
 func ConstZExt(v Value, t Type) (rv Value)          { rv.C = C.LLVMConstZExt(v.C, t.C); return }
 func ConstFPTrunc(v Value, t Type) (rv Value)       { rv.C = C.LLVMConstFPTrunc(v.C, t.C); return }
 func ConstFPExt(v Value, t Type) (rv Value)         { rv.C = C.LLVMConstFPExt(v.C, t.C); return }
 func ConstUIToFP(v Value, t Type) (rv Value)        { rv.C = C.LLVMConstUIToFP(v.C, t.C); return }
 func ConstSIToFP(v Value, t Type) (rv Value)        { rv.C = C.LLVMConstSIToFP(v.C, t.C); return }
 func ConstFPToUI(v Value, t Type) (rv Value)        { rv.C = C.LLVMConstFPToUI(v.C, t.C); return }

 }
 func (v Value) CmpXchgFailureOrdering() AtomicOrdering {
   return AtomicOrdering(C.LLVMGetCmpXchgFailureOrdering(v.C))
 }
 func (v Value) SetCmpXchgFailureOrdering(ordering AtomicOrdering) {
   C.LLVMSetCmpXchgFailureOrdering(v.C, C.LLVMAtomicOrdering(ordering))
 }
 
-// Operations on aliases
-func AddAlias(m Module, t Type, aliasee Value, name string) (v Value) {
-  cname := C.CString(name)
-  defer C.free(unsafe.Pointer(cname))
-  v.C = C.LLVMAddAlias(m.C, t.C, aliasee.C, cname)
-  return
-}
-
 // Operations on comdat
 func (m Module) Comdat(name string) (c Comdat) {
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   c.C = C.LLVMGetOrInsertComdat(m.C, cname)
   return
 }
 

 func (b Builder) CreateSwitch(v Value, elseb BasicBlock, numCases int) (rv Value) {
   rv.C = C.LLVMBuildSwitch(b.C, v.C, elseb.C, C.unsigned(numCases))
   return
 }
 func (b Builder) CreateIndirectBr(addr Value, numDests int) (rv Value) {
   rv.C = C.LLVMBuildIndirectBr(b.C, addr.C, C.unsigned(numDests))
   return
 }
-func (b Builder) CreateInvoke(fn Value, args []Value, then, catch BasicBlock, name string) (rv Value) {
-  cname := C.CString(name)
-  defer C.free(unsafe.Pointer(cname))
-  ptr, nvals := llvmValueRefs(args)
-  rv.C = C.LLVMBuildInvoke(b.C, fn.C, ptr, nvals, then.C, catch.C, cname)
-  return
-}
 func (b Builder) CreateUnreachable() (rv Value) { rv.C = C.LLVMBuildUnreachable(b.C); return }
 
 // Add a case to the switch instruction
 func (v Value) AddCase(on Value, dest BasicBlock) { C.LLVMAddCase(v.C, on.C, dest.C) }
 
 // Add a destination to the indirectbr instruction
 func (v Value) AddDest(dest BasicBlock) { C.LLVMAddDestination(v.C, dest.C) }
 
func (b Builder) CreateArrayAlloca(t Type, val Value, name string) (v Value) {
   defer C.free(unsafe.Pointer(cname))
   v.C = C.LLVMBuildArrayAlloca(b.C, t.C, val.C, cname)
   return
 }
 func (b Builder) CreateFree(p Value) (v Value) {
   v.C = C.LLVMBuildFree(b.C, p.C)
   return
 }
-func (b Builder) CreateLoad(p Value, name string) (v Value) {
-  cname := C.CString(name)
-  defer C.free(unsafe.Pointer(cname))
-  v.C = C.LLVMBuildLoad(b.C, p.C, cname)
-  return
-}
 func (b Builder) CreateStore(val Value, p Value) (v Value) {
   v.C = C.LLVMBuildStore(b.C, val.C, p.C)
   return
 }
-func (b Builder) CreateGEP(p Value, indices []Value, name string) (v Value) {
-  cname := C.CString(name)
-  defer C.free(unsafe.Pointer(cname))
-  ptr, nvals := llvmValueRefs(indices)
-  v.C = C.LLVMBuildGEP(b.C, p.C, ptr, nvals, cname)
-  return
-}
-func (b Builder) CreateInBoundsGEP(p Value, indices []Value, name string) (v Value) {
-  cname := C.CString(name)
-  defer C.free(unsafe.Pointer(cname))
-  ptr, nvals := llvmValueRefs(indices)
-  v.C = C.LLVMBuildInBoundsGEP(b.C, p.C, ptr, nvals, cname)
-  return
-}
-func (b Builder) CreateStructGEP(p Value, i int, name string) (v Value) {
-  cname := C.CString(name)
-  defer C.free(unsafe.Pointer(cname))
-  v.C = C.LLVMBuildStructGEP(b.C, p.C, C.unsigned(i), cname)
-  return
-}
 func (b Builder) CreateGlobalString(str, name string) (v Value) {
   cstr := C.CString(str)
   defer C.free(unsafe.Pointer(cstr))
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   v.C = C.LLVMBuildGlobalString(b.C, cstr, cname)
   return
 }
func (b Builder) CreateIsNull(val Value, name string) (v Value) {
   return
 }
 func (b Builder) CreateIsNotNull(val Value, name string) (v Value) {
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   v.C = C.LLVMBuildIsNotNull(b.C, val.C, cname)
   return
 }
-func (b Builder) CreatePtrDiff(lhs, rhs Value, name string) (v Value) {
-  cname := C.CString(name)
-  defer C.free(unsafe.Pointer(cname))
-  v.C = C.LLVMBuildPtrDiff(b.C, lhs.C, rhs.C, cname)
-  return
-}
 
 func (b Builder) CreateLandingPad(t Type, nclauses int, name string) (l Value) {
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   l.C = C.LLVMBuildLandingPad(b.C, t.C, nil, C.unsigned(nclauses), cname)
   return l
 }
 

llvm/bindings/ocaml/llvm/llvm.ml

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_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"
 external const_sitofp : llvalue -> lltype -> llvalue = "LLVMConstSIToFP"
 external const_fptoui : llvalue -> lltype -> llvalue = "LLVMConstFPToUI"

 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 ->
-                        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_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
-                    = "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 ->
-                             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_global_string : string -> string -> llbuilder -> llvalue
                              = "llvm_build_global_string"
 external build_global_stringptr  : string -> string -> llbuilder -> llvalue
                                  = "llvm_build_global_stringptr"
 

 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_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_freeze : llvalue -> string -> llbuilder -> llvalue
                       = "llvm_build_freeze"
 
 
 (*===-- Memory buffers ----------------------------------------------------===*)
 

llvm/bindings/ocaml/llvm/llvm.mli

(** [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
     [%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
 
 (** [build_landingpad ty persfn numclauses name b] creates an

 
 (** [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
     [%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
 
 (** [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
     [%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
-
 (** [build_in_bounds_gep2 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
 
-(** [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
     [%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
 
 (** [build_global_string str name b] creates a series of instructions that adds
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
-    [%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
 
 (** [build_select cond thenv elsev name b] creates a

 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
     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
 
 (** [build_freeze x name b] creates a

llvm/bindings/ocaml/llvm/llvm_ocaml.c

 }
 
 /* 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,
                             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),
-                              Wosize_val(Indices));
-}
-
 /* llvalue -> lltype -> is_signed:bool -> llvalue */
 LLVMValueRef llvm_const_intcast(LLVMValueRef CV, LLVMTypeRef T,
                                 value IsSigned) {
   return LLVMConstIntCast(CV, T, Bool_val(IsSigned));
 }
 
 /* lltype -> string -> string -> bool -> bool -> llvalue */
 LLVMValueRef llvm_const_inline_asm(LLVMTypeRef Ty, value Asm, value Constraints,

 /* 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,
                             value AddrSpace, LLVMValueRef Aliasee, value Name) {
   return LLVMAddAlias2(M, ValueTy, Int_val(AddrSpace), Aliasee,
                        String_val(Name));
 }
 
 /*--... Operations on functions ............................................--*/
 

 }
 
 /* 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) {
   return LLVMBuildInvoke2(Builder_val(B), FnTy, Fn,
                           (LLVMValueRef *)Op_val(Args), Wosize_val(Args),

 }
 
 /* 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) {
   return LLVMBuildLoad2(Builder_val(B), Ty, Pointer, String_val(Name));
 }
 
 /* llvalue -> llvalue -> llbuilder -> llvalue */
 LLVMValueRef llvm_build_store(LLVMValueRef Value, LLVMValueRef 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) {
   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) {
   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) {
   return LLVMBuildStructGEP2(Builder_val(B), Ty, Pointer, Int_val(Index),
                              String_val(Name));
 }
 
 /* string -> string -> llbuilder -> llvalue */
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) {
   return LLVMBuildCall2(Builder_val(B), FnTy, Fn,
                         (LLVMValueRef *)Op_val(Params), Wosize_val(Params),
                         String_val(Name));
 }
 

 }
 
 /* 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) {
   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/docs/ReleaseNotes.rst

 
 * The following functions for creating constant expressions have been removed,
   because the underlying constant expressions are no longer supported. Instead,
   an instruction should be created using the ``LLVMBuildXYZ`` APIs, which will
   constant fold the operands if possible and create an instruction otherwise:
 
   * ``LLVMConstFNeg``
 
+
+* The following deprecated functions have been removed, because they are
+  incompatible with opaque pointers. Use the new functions accepting a separate
+  function/element type instead.
+
+  * ``LLVMBuildLoad`` -> ``LLVMBuildLoad2``
+  * ``LLVMBuildCall`` -> ``LLVMBuildCall2``
+  * ``LLVMBuildInvoke`` -> ``LLVMBuildInvoke2``
+  * ``LLVMBuildGEP`` -> ``LLVMBuildGEP2``
+  * ``LLVMBuildInBoundsGEP`` -> ``LLVMBuildInBoundsGEP2``
+  * ``LLVMBuildStructGEP`` -> ``LLVMBuildStructGEP2``
+  * ``LLVMBuildPtrDiff`` -> ``LLVMBuildPtrDiff2``
+  * ``LLVMConstGEP`` -> ``LLVMConstGEP2``
+  * ``LLVMConstInBoundsGEP`` -> ``LLVMConstInBoundsGEP2``
+  * ``LLVMAddAlias`` -> ``LLVMAddAlias2``
+
 Changes to the Go bindings
 --------------------------
 
 
 Changes to the FastISel infrastructure
 --------------------------------------
 
 * ...

llvm/include/llvm-c/Core.h

 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
-                              LLVMValueRef *ConstantIndices,
-                              unsigned NumIndices),
-    "Use LLVMConstGEP2 instead to support opaque pointers");
 LLVMValueRef LLVMConstGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
                            LLVMValueRef *ConstantIndices, unsigned NumIndices);
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
-                                      LLVMValueRef *ConstantIndices,
-                                      unsigned NumIndices),
-    "Use LLVMConstInBoundsGEP2 instead to support opaque pointers");
 LLVMValueRef LLVMConstInBoundsGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
                                    LLVMValueRef *ConstantIndices,
                                    unsigned NumIndices);
 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);

  *
  * This group contains function that operate on global alias values.
  *
  * @see llvm::GlobalAlias
  *
  * @{
  */
 
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty,
-                              LLVMValueRef Aliasee, const char *Name),
-    "Use LLVMAddAlias2 instead to support opaque pointers");
 
 /**
  * Add a GlobalAlias with the given value type, address space and aliasee.
  *
  * @see llvm::GlobalAlias::create()
  */
 LLVMValueRef LLVMAddAlias2(LLVMModuleRef M, LLVMTypeRef ValueTy,
                            unsigned AddrSpace, LLVMValueRef Aliasee,
LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
                                    unsigned N);
 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
                              LLVMBasicBlockRef Else, unsigned NumCases);
 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
                                  unsigned NumDests);
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
-                                 LLVMValueRef *Args, unsigned NumArgs,
-                                 LLVMBasicBlockRef Then,
-                                 LLVMBasicBlockRef Catch, const char *Name),
-    "Use LLVMBuildInvoke2 instead to support opaque pointers");
 LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Fn,
                               LLVMValueRef *Args, unsigned NumArgs,
                               LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
                               const char *Name);
 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
 
 /* Exception Handling */
 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
LLVMValueRef LLVMBuildMemMove(LLVMBuilderRef B,
                               LLVMValueRef Dst, unsigned DstAlign,
                               LLVMValueRef Src, unsigned SrcAlign,
                               LLVMValueRef Size);
 
 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
                                   LLVMValueRef Val, const char *Name);
 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
-                               const char *Name),
-    "Use LLVMBuildLoad2 instead to support opaque pointers");
 LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef, LLVMTypeRef Ty,
                             LLVMValueRef PointerVal, const char *Name);
 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
-                              LLVMValueRef *Indices, unsigned NumIndices,
-                              const char *Name),
-    "Use LLVMBuildGEP2 instead to support opaque pointers");
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
-                                      LLVMValueRef *Indices,
-                                      unsigned NumIndices, const char *Name),
-    "Use LLVMBuildInBoundsGEP2 instead to support opaque pointers");
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
-                                    unsigned Idx, const char *Name),
-    "Use LLVMBuildStructGEP2 instead to support opaque pointers");
 LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
                            LLVMValueRef Pointer, LLVMValueRef *Indices,
                            unsigned NumIndices, const char *Name);
 LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
                                    LLVMValueRef Pointer, LLVMValueRef *Indices,
                                    unsigned NumIndices, const char *Name);
 LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
                                  LLVMValueRef Pointer, unsigned Idx,
LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
                            LLVMValueRef LHS, LLVMValueRef RHS,
                            const char *Name);
 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
                            LLVMValueRef LHS, LLVMValueRef RHS,
                            const char *Name);
 
 /* Miscellaneous instructions */
 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
-                               LLVMValueRef *Args, unsigned NumArgs,
-                               const char *Name),
-    "Use LLVMBuildCall2 instead to support opaque pointers");
 LLVMValueRef LLVMBuildCall2(LLVMBuilderRef, LLVMTypeRef, LLVMValueRef Fn,
                             LLVMValueRef *Args, unsigned NumArgs,
                             const char *Name);
 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
                              LLVMValueRef Then, LLVMValueRef Else,
                              const char *Name);
 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
                             const char *Name);
LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
                                   const char *Name);
 LLVMValueRef LLVMBuildFreeze(LLVMBuilderRef, LLVMValueRef Val,
                              const char *Name);
 
 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
                              const char *Name);
 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
                                 const char *Name);
-LLVM_ATTRIBUTE_C_DEPRECATED(
-    LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
-                                  LLVMValueRef RHS, const char *Name),
-    "Use LLVMBuildPtrDiff2 instead to support opaque pointers");
 LLVMValueRef LLVMBuildPtrDiff2(LLVMBuilderRef, LLVMTypeRef ElemTy,
                                LLVMValueRef LHS, LLVMValueRef RHS,
                                const char *Name);
 LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering ordering,
                             LLVMBool singleThread, const char *Name);
 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op,
                                 LLVMValueRef PTR, LLVMValueRef Val,
                                 LLVMAtomicOrdering ordering,

llvm/lib/IR/Core.cpp

return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant),
                                     unwrap<Constant>(RHSConstant)));
 }
 
 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
   return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant),
                                     unwrap<Constant>(RHSConstant)));
 }
 
-LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
-                          LLVMValueRef *ConstantIndices, unsigned NumIndices) {
-  ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
-                               NumIndices);
-  Constant *Val = unwrap<Constant>(ConstantVal);
-  Type *Ty = Val->getType()->getScalarType()->getNonOpaquePointerElementType();
-  return wrap(ConstantExpr::getGetElementPtr(Ty, Val, IdxList));
-}
-
 LLVMValueRef LLVMConstGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
                            LLVMValueRef *ConstantIndices, unsigned NumIndices) {
   ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
                                NumIndices);
   Constant *Val = unwrap<Constant>(ConstantVal);
   return wrap(ConstantExpr::getGetElementPtr(unwrap(Ty), Val, IdxList));
 }
 
-LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
-                                  LLVMValueRef *ConstantIndices,
-                                  unsigned NumIndices) {
-  ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
-                               NumIndices);
-  Constant *Val = unwrap<Constant>(ConstantVal);
-  Type *Ty = Val->getType()->getScalarType()->getNonOpaquePointerElementType();
-  return wrap(ConstantExpr::getInBoundsGetElementPtr(Ty, Val, IdxList));
-}
-
 LLVMValueRef LLVMConstInBoundsGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
                                    LLVMValueRef *ConstantIndices,
                                    unsigned NumIndices) {
   ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
                                NumIndices);
   Constant *Val = unwrap<Constant>(ConstantVal);
   return wrap(ConstantExpr::getInBoundsGetElementPtr(unwrap(Ty), Val, IdxList));
 }

 }
 
 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit) {
   unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit);
 }
 
 /*--.. Operations on aliases ......................................--*/
 
-LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
-                          const char *Name) {
-  auto *PTy = cast<PointerType>(unwrap(Ty));
-  return wrap(GlobalAlias::create(PTy->getNonOpaquePointerElementType(),
-                                  PTy->getAddressSpace(),
-                                  GlobalValue::ExternalLinkage, Name,
-                                  unwrap<Constant>(Aliasee), unwrap(M)));
-}
-
 LLVMValueRef LLVMAddAlias2(LLVMModuleRef M, LLVMTypeRef ValueTy,
                            unsigned AddrSpace, LLVMValueRef Aliasee,
                            const char *Name) {
   return wrap(GlobalAlias::create(unwrap(ValueTy), AddrSpace,
                                   GlobalValue::ExternalLinkage, Name,
                                   unwrap<Constant>(Aliasee), unwrap(M)));
 }
 
LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V,
   return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
 }
 
 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
                                  unsigned NumDests) {
   return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests));
 }
 
-LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
-                             LLVMValueRef *Args, unsigned NumArgs,
-                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
-                             const char *Name) {
-  Value *V = unwrap(Fn);
-  FunctionType *FnT =
-      cast<FunctionType>(V->getType()->getNonOpaquePointerElementType());
-
-  return wrap(
-      unwrap(B)->CreateInvoke(FnT, unwrap(Fn), unwrap(Then), unwrap(Catch),
-                              makeArrayRef(unwrap(Args), NumArgs), Name));
-}
-
 LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
                               LLVMValueRef *Args, unsigned NumArgs,
                               LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
                               const char *Name) {
   return wrap(unwrap(B)->CreateInvoke(
       unwrap<FunctionType>(Ty), unwrap(Fn), unwrap(Then), unwrap(Catch),
       makeArrayRef(unwrap(Args), NumArgs), Name));
 }
LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name));
 }
 
 LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) {
   return wrap(unwrap(B)->Insert(
      CallInst::CreateFree(unwrap(PointerVal), unwrap(B)->GetInsertBlock())));
 }
 
-LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal,
-                           const char *Name) {
-  Value *V = unwrap(PointerVal);
-  PointerType *Ty = cast<PointerType>(V->getType());
-
-  return wrap(
-      unwrap(B)->CreateLoad(Ty->getNonOpaquePointerElementType(), V, Name));
-}
-
 LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef B, LLVMTypeRef Ty,
                             LLVMValueRef PointerVal, const char *Name) {
   return wrap(unwrap(B)->CreateLoad(unwrap(Ty), unwrap(PointerVal), Name));
 }
 
 LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
                             LLVMValueRef PointerVal) {
   return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal)));
LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering Ordering,
                             LLVMBool isSingleThread, const char *Name) {
   return wrap(
     unwrap(B)->CreateFence(mapFromLLVMOrdering(Ordering),
                            isSingleThread ? SyncScope::SingleThread
                                           : SyncScope::System,
                            Name));
 }
 
-LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
-                          LLVMValueRef *Indices, unsigned NumIndices,
-                          const char *Name) {
-  ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
-  Value *Val = unwrap(Pointer);
-  Type *Ty = Val->getType()->getScalarType()->getNonOpaquePointerElementType();
-  return wrap(unwrap(B)->CreateGEP(Ty, Val, IdxList, Name));
-}
-
 LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
                            LLVMValueRef Pointer, LLVMValueRef *Indices,
                            unsigned NumIndices, const char *Name) {
   ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
   return wrap(unwrap(B)->CreateGEP(unwrap(Ty), unwrap(Pointer), IdxList, Name));
 }
 
-LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
-                                  LLVMValueRef *Indices, unsigned NumIndices,
-                                  const char *Name) {
-  ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
-  Value *Val = unwrap(Pointer);
-  Type *Ty = Val->getType()->getScalarType()->getNonOpaquePointerElementType();
-  return wrap(unwrap(B)->CreateInBoundsGEP(Ty, Val, IdxList, Name));
-}
-
 LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
                                    LLVMValueRef Pointer, LLVMValueRef *Indices,
                                    unsigned NumIndices, const char *Name) {
   ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
   return wrap(
       unwrap(B)->CreateInBoundsGEP(unwrap(Ty), unwrap(Pointer), IdxList, Name));
 }
 
-LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
-                                unsigned Idx, const char *Name) {
-  Value *Val = unwrap(Pointer);
-  Type *Ty = Val->getType()->getScalarType()->getNonOpaquePointerElementType();
-  return wrap(unwrap(B)->CreateStructGEP(Ty, Val, Idx, Name));
-}
-
 LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
                                  LLVMValueRef Pointer, unsigned Idx,
                                  const char *Name) {
   return wrap(
       unwrap(B)->CreateStructGEP(unwrap(Ty), unwrap(Pointer), Idx, Name));
 }
 
 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,

 }
 
 /*--.. Miscellaneous instructions ..........................................--*/
 
 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
   return wrap(unwrap(B)->CreatePHI(unwrap(Ty), 0, Name));
 }
 
-LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
-                           LLVMValueRef *Args, unsigned NumArgs,
-                           const char *Name) {
-  Value *V = unwrap(Fn);
-  FunctionType *FnT =
-      cast<FunctionType>(V->getType()->getNonOpaquePointerElementType());
-
-  return wrap(unwrap(B)->CreateCall(FnT, unwrap(Fn),
-                                    makeArrayRef(unwrap(Args), NumArgs), Name));
-}
-
 LLVMValueRef LLVMBuildCall2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
                             LLVMValueRef *Args, unsigned NumArgs,
                             const char *Name) {
   FunctionType *FTy = unwrap<FunctionType>(Ty);
   return wrap(unwrap(B)->CreateCall(FTy, unwrap(Fn),
                                     makeArrayRef(unwrap(Args), NumArgs), Name));
 }
 
LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val,
   return wrap(unwrap(B)->CreateIsNull(unwrap(Val), Name));
 }
 
 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val,
                                 const char *Name) {
   return wrap(unwrap(B)->CreateIsNotNull(unwrap(Val), Name));
 }
 
-LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS,
-                              LLVMValueRef RHS, const char *Name) {
-  Value *L = unwrap(LHS);
-  Type *ElemTy = L->getType()->getNonOpaquePointerElementType();
-  return wrap(unwrap(B)->CreatePtrDiff(ElemTy, L, unwrap(RHS), Name));
-}
-
 LLVMValueRef LLVMBuildPtrDiff2(LLVMBuilderRef B, LLVMTypeRef ElemTy,
                                LLVMValueRef LHS, LLVMValueRef RHS,
                                const char *Name) {
   return wrap(unwrap(B)->CreatePtrDiff(unwrap(ElemTy), unwrap(LHS),
                                        unwrap(RHS), Name));
 }
 
 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,