[OCaml] Add OCaml APIs for LLVMGetModuleDataLayout and LLVMABISizeOfType

[jberdine]

Summary

This patch adds a shim around LLVMABISizeOfType to the OCaml API. To
make this usable, a shim around LLVMGetModuleDataLayout and a minimal
implementation of the DataLayout type is also added.

[whitequark]

There is already an Llvm_target.DataLayout.t, we don't need to wrap it the second time.

[jberdine]

Thanks, don't know why I overlooked that.

bindings/ocaml/llvm/llvm.ml

 (*===-- llvm/llvm.ml - LLVM OCaml Interface -------------------------------===*
  *
  *                     The LLVM Compiler Infrastructure
  *
  * This file is distributed under the University of Illinois Open Source
  * License. See LICENSE.TXT for details.
  *
  *===----------------------------------------------------------------------===*)
 
 
 type llcontext
 type llmodule
+type lldatalayout
 type lltype
 type llvalue
 type lluse
 type llbasicblock
 type llbuilder
 type llattrkind
 type llattribute
 type llmemorybuffer
external set_data_layout: string -> llmodule -> unit
                         = "llvm_set_data_layout"
 external dump_module : llmodule -> unit = "llvm_dump_module"
 external print_module : string -> llmodule -> unit = "llvm_print_module"
 external string_of_llmodule : llmodule -> string = "llvm_string_of_llmodule"
 external set_module_inline_asm : llmodule -> string -> unit
                                = "llvm_set_module_inline_asm"
 external module_context : llmodule -> llcontext = "LLVMGetModuleContext"
 
+(*===-- Data Layout -------------------------------------------------------===*)
+external module_data_layout : llmodule -> lldatalayout
+                            = "llvm_module_data_layout"
+
+external type_alloc_size : lldatalayout -> lltype -> int64
+                         = "llvm_type_alloc_size"
+
 (*===-- Types -------------------------------------------------------------===*)
 external classify_type : lltype -> TypeKind.t = "llvm_classify_type"
 external type_context : lltype -> llcontext = "llvm_type_context"
 external type_is_sized : lltype -> bool = "llvm_type_is_sized"
 external dump_type : lltype -> unit = "llvm_dump_type"
 external string_of_lltype : lltype -> string = "llvm_string_of_lltype"
 
 (*--... Operations on integer types ........................................--*)

bindings/ocaml/llvm/llvm.mli

 (** The top-level container for all LLVM global data. See the
     [llvm::LLVMContext] class. *)
 type llcontext
 
 (** The top-level container for all other LLVM Intermediate Representation (IR)
     objects. See the [llvm::Module] class. *)
 type llmodule
 
+(** A parsed version of the target data layout string. See the
+    [llvm::DataLayout] class. *)
+type lldatalayout
+
 (** Each value in the LLVM IR has a type, an instance of [lltype]. See the
     [llvm::Type] class. *)
 type lltype
 
 (** Any value in the LLVM IR. Functions, instructions, global variables,
     constants, and much more are all [llvalues]. See the [llvm::Value] class.
     This type covers a wide range of subclasses. *)
 type llvalue
(** [set_module_inline_asm m asm] sets the inline assembler for the module. See
     the method [llvm::Module::setModuleInlineAsm]. *)
 val set_module_inline_asm : llmodule -> string -> unit
 
 (** [module_context m] returns the context of the specified module.
     See the method [llvm::Module::getContext] *)
 val module_context : llmodule -> llcontext
 
 
+(** {6 Data Layout} *)
+
+(** Obtain the data layout for a module.
+    See the method [llvm::Module::getDataLayout]. *)
+val module_data_layout : llmodule -> lldatalayout
+
+(** Computes the ABI size of a type in bytes for a target.
+    See the method [llvm::DataLayout::getTypeAllocSize]. *)
+val type_alloc_size : lldatalayout -> lltype -> int64
+
+
 (** {6 Types} *)
 
 (** [classify_type ty] returns the {!TypeKind.t} corresponding to the type [ty].
     See the method [llvm::Type::getTypeID]. *)
 val classify_type : lltype -> TypeKind.t
 
 (** [type_is_sized ty] returns whether the type has a size or not.
     If it doesn't then it is not safe to call the [DataLayout::] methods on it.

bindings/ocaml/llvm/llvm_ocaml.c

 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include "llvm-c/Core.h"
 #include "llvm-c/Support.h"
+#include "llvm-c/Target.h"
 #include "llvm/Config/llvm-config.h"
 #include "caml/alloc.h"
 #include "caml/custom.h"
 #include "caml/memory.h"
 #include "caml/fail.h"
 #include "caml/callback.h"
 
 value llvm_string_of_message(char* Message) {

 }
 
 /* llmodule -> string -> unit */
 CAMLprim value llvm_set_module_inline_asm(LLVMModuleRef M, value Asm) {
   LLVMSetModuleInlineAsm(M, String_val(Asm));
   return Val_unit;
 }
 
+/*===-- Data Layout -------------------------------------------------------===*/
+
+/* llmodule -> lldatalayout */
+CAMLprim LLVMTargetDataRef llvm_module_data_layout(LLVMModuleRef M) {
+  return LLVMGetModuleDataLayout(M);
+}
+
+/* lldatalayout -> lltype -> int64 */
+CAMLprim value llvm_type_alloc_size(LLVMTargetDataRef TD, LLVMTypeRef Ty) {
+  return caml_copy_int64(LLVMABISizeOfType(TD, Ty));
+}
+
+
 /*===-- Types -------------------------------------------------------------===*/
 
 /* lltype -> TypeKind.t */
 CAMLprim value llvm_classify_type(LLVMTypeRef Ty) {
   return Val_int(LLVMGetTypeKind(Ty));
 }
 
 CAMLprim value llvm_type_is_sized(LLVMTypeRef Ty) {