Silence warnings in OCaml bindings

[jketema]

Summary

• LLVMDisposeMessage lives in llvm-c/Core.h, include this file where necessary
• LLVMAddTargetData has been removed, follow suit in the bindings

[jketema]

Unbreak the related target test by removing add_to_pass_manager test

[whitequark]

LGTM

bindings/ocaml/analysis/analysis_ocaml.c

 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
 |* Note that these functions intentionally take liberties with the CAMLparamX *|
 |* macros, since most of the parameters are not GC heap objects.              *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
+#include "llvm-c/Core.h"
 #include "llvm-c/Analysis.h"
 #include "caml/alloc.h"
 #include "caml/mlvalues.h"
 #include "caml/memory.h"
 
 /* Llvm.llmodule -> string option */
 CAMLprim value llvm_verify_module(LLVMModuleRef M) {
   CAMLparam0();

bindings/ocaml/executionengine/executionengine_ocaml.c

 |*                                                                            *|
 |* Note that these functions intentionally take liberties with the CAMLparamX *|
 |* macros, since most of the parameters are not GC heap objects.              *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include <string.h>
 #include <assert.h>
+#include "llvm-c/Core.h"
 #include "llvm-c/ExecutionEngine.h"
 #include "llvm-c/Target.h"
 #include "caml/alloc.h"
 #include "caml/custom.h"
 #include "caml/fail.h"
 #include "caml/memory.h"
 #include "caml/callback.h"
 

bindings/ocaml/target/llvm_target.ml

 
 let () = Callback.register_exception "Llvm_target.Error" (Error "")
 
 module DataLayout = struct
   type t
 
   external of_string : string -> t = "llvm_datalayout_of_string"
   external as_string : t -> string = "llvm_datalayout_as_string"
-  external add_to_pass_manager : [<Llvm.PassManager.any]
-                                 Llvm.PassManager.t -> t -> unit
-                               = "llvm_datalayout_add_to_pass_manager"
   external byte_order : t -> Endian.t = "llvm_datalayout_byte_order"
   external pointer_size : t -> int = "llvm_datalayout_pointer_size"
   external intptr_type : Llvm.llcontext -> t -> Llvm.lltype
                        = "llvm_datalayout_intptr_type"
   external qualified_pointer_size : int -> t -> int
                                   = "llvm_datalayout_qualified_pointer_size"
   external qualified_intptr_type : Llvm.llcontext -> int -> t -> Llvm.lltype
                                  = "llvm_datalayout_qualified_intptr_type"

bindings/ocaml/target/llvm_target.mli

module DataLayout : sig
   (** [of_string rep] parses the data layout string representation [rep].
       See the constructor [llvm::DataLayout::DataLayout]. *)
   val of_string : string -> t
 
   (** [as_string dl] is the string representation of the data layout [dl].
       See the method [llvm::DataLayout::getStringRepresentation]. *)
   val as_string : t -> string
 
-  (** [add_to_pass_manager pm dl] adds the data layout [dl] to
-      the pass manager [pm].
-      See the method [llvm::PassManagerBase::add]. *)
-  val add_to_pass_manager : [<Llvm.PassManager.any] Llvm.PassManager.t ->
-                            t -> unit
-
   (** Returns the byte order of a target, either [Endian.Big] or
       [Endian.Little].
       See the method [llvm::DataLayout::isLittleEndian]. *)
   val byte_order : t -> Endian.t
 
   (** Returns the pointer size in bytes for a target.
       See the method [llvm::DataLayout::getPointerSize]. *)
   val pointer_size : t -> int

bindings/ocaml/target/target_ocaml.c

 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
 |* are by and large transparent wrappers to the corresponding C functions.    *|
 |*                                                                            *|
 |* Note that these functions intentionally take liberties with the CAMLparamX *|
 |* macros, since most of the parameters are not GC heap objects.              *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
+#include "llvm-c/Core.h"
 #include "llvm-c/Target.h"
 #include "llvm-c/TargetMachine.h"
 #include "caml/alloc.h"
 #include "caml/fail.h"
 #include "caml/memory.h"
 #include "caml/custom.h"
 #include "caml/callback.h"
 

 /* DataLayout.t -> string */
 CAMLprim value llvm_datalayout_as_string(value TD) {
   char *StringRep = LLVMCopyStringRepOfTargetData(DataLayout_val(TD));
   value Copy = copy_string(StringRep);
   LLVMDisposeMessage(StringRep);
   return Copy;
 }
 
-/* [<Llvm.PassManager.any] Llvm.PassManager.t -> DataLayout.t -> unit */
-CAMLprim value llvm_datalayout_add_to_pass_manager(LLVMPassManagerRef PM,
-                                                   value DL) {
-  LLVMAddTargetData(DataLayout_val(DL), PM);
-  return Val_unit;
-}
-
 /* DataLayout.t -> Endian.t */
 CAMLprim value llvm_datalayout_byte_order(value DL) {
   return Val_int(LLVMByteOrder(DataLayout_val(DL)));
 }
 
 /* DataLayout.t -> int */
 CAMLprim value llvm_datalayout_pointer_size(value DL) {
   return Val_int(LLVMPointerSize(DataLayout_val(DL)));

test/Bindings/OCaml/target.ml

let test_target_data () =
   assert_equal (DL.qualified_intptr_type context 0 dl) i32_type;
   assert_equal (DL.size_in_bits sty dl) (Int64.of_int 96);
   assert_equal (DL.store_size sty dl) (Int64.of_int 12);
   assert_equal (DL.abi_size sty dl) (Int64.of_int 12);
   assert_equal (DL.stack_align sty dl) 4;
   assert_equal (DL.preferred_align sty dl) 8;
   assert_equal (DL.preferred_align_of_global (declare_global sty "g" m) dl) 8;
   assert_equal (DL.element_at_offset sty (Int64.of_int 1) dl) 0;
-  assert_equal (DL.offset_of_element sty 1 dl) (Int64.of_int 4);
-
-  let pm = PassManager.create () in
-  ignore (DL.add_to_pass_manager pm dl)
+  assert_equal (DL.offset_of_element sty 1 dl) (Int64.of_int 4)
 
 
 (*===-- Target ------------------------------------------------------------===*)
 
 let test_target () =
   let module T = Target in
   ignore (T.succ target);
   ignore (T.name target);