[llvm][ocaml] Replace deprecated C functions in OCaml bindings

[alan]

Summary

See https://reviews.llvm.org/D135271.

[alan]

Replace const_element with aggregate_element

[alan]

Update commit message and refine doc comment

[nikic]

LGTM, thanks!

[alan]

I don't have commit permissions to the LLVM repo, so if you need this patch for your own patch, you can commit it yourself.

[alan]

llvm/bindings/ocaml/llvm/llvm_ocaml.c

997

@nikic I realized that I forgot to update this comment with the new OCaml type signature in this patch. (An lltype should be added as the first argument.) I still have that pending patch where I rewrite the bindings to not use naked pointers, and when I rebased that patch after this one was merged, I fixed the comment here to have the right OCaml type. Because that patch rewrites the bindings, I had taken the opportunity to fix a bunch of "small" mistakes that I found in the bindings (e.g. wrong OCaml type signatures in C comments). Is it okay for me to be fixing these kinds of mistakes in that big patch? Or should I make another patch to fix these small mistakes?

llvm/bindings/ocaml/llvm/llvm.ml

 external const_struct : llcontext -> llvalue array -> llvalue
                       = "llvm_const_struct"
 external const_named_struct : lltype -> llvalue array -> llvalue
                       = "llvm_const_named_struct"
 external const_packed_struct : llcontext -> llvalue array -> llvalue
                              = "llvm_const_packed_struct"
 external const_vector : llvalue array -> llvalue = "llvm_const_vector"
 external string_of_const : llvalue -> string option = "llvm_string_of_const"
-external const_element : llvalue -> int -> llvalue = "llvm_const_element"
+external aggregate_element : llvalue -> int -> llvalue option
+                           = "llvm_aggregate_element"
 
 (*--... Constant expressions ...............................................--*)
 external align_of : lltype -> llvalue = "LLVMAlignOf"
 external size_of : lltype -> llvalue = "LLVMSizeOf"
 external const_neg : llvalue -> llvalue = "LLVMConstNeg"
 external const_nsw_neg : llvalue -> llvalue = "LLVMConstNSWNeg"
 external const_nuw_neg : llvalue -> llvalue = "LLVMConstNUWNeg"
 external const_not : llvalue -> llvalue = "LLVMConstNot"
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 : lltype -> llvalue -> llvalue array -> llvalue
                     = "llvm_const_gep"
-external const_in_bounds_gep : llvalue -> llvalue array -> llvalue
+external const_in_bounds_gep : lltype -> 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"

llvm/bindings/ocaml/llvm/llvm.mli

(** [const_vector elts] returns the vector constant of type
     [vector_type (type_of elts.(0)) (Array.length elts)] and containing the
     values [elts]. See the method [llvm::ConstantVector::get]. *)
 val const_vector : llvalue array -> llvalue
 
 (** [string_of_const c] returns [Some str] if [c] is a string constant,
     or [None] if this is not a string constant. *)
 val string_of_const : llvalue -> string option
 
-(** [const_element c] returns a constant for a specified index's element.
-    See the method ConstantDataSequential::getElementAsConstant. *)
-val const_element : llvalue -> int -> llvalue
+(** [aggregate_element c idx] returns [Some elt] where [elt] is the element of
+    constant aggregate [c] at the specified index [idx], or [None] if [idx] is
+    out of range or it's not possible to determine the element.
+    See the method [llvm::Constant::getAggregateElement]. *)
+val aggregate_element : llvalue -> int -> llvalue option
 
 
 (** {7 Constant expressions} *)
 
 (** [align_of ty] returns the alignof constant for the type [ty]. This is
     equivalent to [const_ptrtoint (const_gep (const_null (pointer_type {i8,ty}))
     (const_int i32_type 0) (const_int i32_type 1)) i32_type], but considerably
     more readable.  See the method [llvm::ConstantExpr::getAlignOf]. *)

 val const_ashr : llvalue -> llvalue -> llvalue
 
 (** [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_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].
+(** [const_in_bounds_gep ty 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
+val const_in_bounds_gep : lltype -> llvalue -> llvalue array -> llvalue
 
 (** [const_trunc c ty] returns the constant truncation of integer constant [c]
     to the smaller integer type [ty].
     See the method [llvm::ConstantExpr::getTrunc]. *)
 val const_trunc : llvalue -> lltype -> llvalue
 
 (** [const_sext c ty] returns the constant sign extension of integer constant
     [c] to the larger integer type [ty].

llvm/bindings/ocaml/llvm/llvm_ocaml.c

value llvm_string_of_const(LLVMValueRef Const) {
   size_t Len;
   const char *CStr;
   if (!LLVMIsAConstantDataSequential(Const) || !LLVMIsConstantString(Const))
     return Val_none;
   CStr = LLVMGetAsString(Const, &Len);
   return cstr_to_string_option(CStr, Len);
 }
 
-/* llvalue -> int -> llvalue */
-LLVMValueRef llvm_const_element(LLVMValueRef Const, value N) {
-  return LLVMGetElementAsConstant(Const, Int_val(N));
+/* llvalue -> int -> llvalue option */
+value llvm_aggregate_element(LLVMValueRef Const, value N) {
+  return ptr_to_option(LLVMGetAggregateElement(Const, Int_val(N)));
 }
 
 /*--... Constant expressions ...............................................--*/
 
 /* Icmp.t -> llvalue -> llvalue -> llvalue */
 LLVMValueRef llvm_const_icmp(value Pred, LLVMValueRef LHSConstant,
                              LLVMValueRef RHSConstant) {
   return LLVMConstICmp(Int_val(Pred) + LLVMIntEQ, LHSConstant, RHSConstant);
 }
 
 /* Fcmp.t -> llvalue -> llvalue -> llvalue */
 LLVMValueRef llvm_const_fcmp(value Pred, LLVMValueRef LHSConstant,
                              LLVMValueRef RHSConstant) {
   return LLVMConstFCmp(Int_val(Pred), LHSConstant, RHSConstant);
 }
 
 /* lltype -> llvalue -> llvalue array -> llvalue */
 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),
+LLVMValueRef llvm_const_in_bounds_gep(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
+                                      value Indices) {
+  return LLVMConstInBoundsGEP2(Ty, 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));
 }
 

llvm/test/Bindings/OCaml/core.ml

let test_constants () =
   let four = const_int i32_type 4 in
 
   (* CHECK: const_array{{.*}}[i32 3, i32 4]
    *)
   group "array";
   let c = const_array i32_type [| three; four |] in
   ignore (define_global "const_array" c m);
   insist ((array_type i32_type 2) = (type_of c));
-  insist (three = (const_element c 0));
-  insist (four = (const_element c 1));
+  insist (Some three = (aggregate_element c 0));
+  insist (Some four = (aggregate_element c 1));
+  insist (None = (aggregate_element c 2));
 
   (* CHECK: const_vector{{.*}}<i16 1, i16 2{{.*}}>
    *)
   group "vector";
   let c = const_vector [| one; two; one; two;
                           one; two; one; two |] in
   ignore (define_global "const_vector" c m);
   insist ((vector_type i16_type 8) = (type_of c));