[OCaml] Reinstate data_layout

[jketema]

Summary

Expose LLVMCreateTargetMachineData as data_layout

Similar to r263530. From that commit: "LLVMGetTargetDataLayout was removed from the C API, and then TargetMachine.TargetData was removed. Later, LLVMCreateTargetMachineData was added to the C API"

The original version of this function used CAMLparam and friends as the only function in target_llvm.c It's omitted here, which may be incorrect.

[whitequark]

LGTM. Thanks!

llvm/trunk/bindings/ocaml/target/llvm_target.ml

module TargetMachine = struct
   external target : t -> Target.t
                   = "llvm_targetmachine_target"
   external triple : t -> string
                   = "llvm_targetmachine_triple"
   external cpu : t -> string
                = "llvm_targetmachine_cpu"
   external features : t -> string
                     = "llvm_targetmachine_features"
+  external data_layout : t -> DataLayout.t
+                       = "llvm_targetmachine_data_layout"
   external add_analysis_passes : [< Llvm.PassManager.any ] Llvm.PassManager.t -> t -> unit
                                = "llvm_targetmachine_add_analysis_passes"
   external set_verbose_asm : bool -> t -> unit
                            = "llvm_targetmachine_set_verbose_asm"
   external emit_to_file : Llvm.llmodule -> CodeGenFileType.t -> string ->
                           t -> unit
                         = "llvm_targetmachine_emit_to_file"
   external emit_to_memory_buffer : Llvm.llmodule -> CodeGenFileType.t ->
                                    t -> Llvm.llmemorybuffer
                                  = "llvm_targetmachine_emit_to_memory_buffer"
 end

llvm/trunk/bindings/ocaml/target/llvm_target.mli

module TargetMachine : sig
   (** Returns the triple used while creating this target machine. See
       [llvm::TargetMachine::getTriple]. *)
   val triple : t -> string
 
   (** Returns the CPU used while creating this target machine. See
       [llvm::TargetMachine::getCPU]. *)
   val cpu : t -> string
 
+  (** Returns the data layout of this target machine. *)
+  val data_layout : t -> DataLayout.t
+
   (** Returns the feature string used while creating this target machine. See
       [llvm::TargetMachine::getFeatureString]. *)
   val features : t -> string
 
   (** Adds the target-specific analysis passes to the pass manager.
       See [llvm::TargetMachine::addAnalysisPasses]. *)
   val add_analysis_passes : [< Llvm.PassManager.any ] Llvm.PassManager.t -> t -> unit
 

llvm/trunk/bindings/ocaml/target/target_ocaml.c

 }
 
 /* TargetMachine.t -> string */
 CAMLprim value llvm_targetmachine_features(value Machine) {
   return llvm_string_of_message(LLVMGetTargetMachineFeatureString(
                                 TargetMachine_val(Machine)));
 }
 
+/* TargetMachine.t -> DataLayout.t */
+CAMLprim value llvm_targetmachine_data_layout(value Machine) {
+  return llvm_alloc_data_layout(LLVMCreateTargetDataLayout(
+                                TargetMachine_val(Machine)));
+}
+
 /* bool -> TargetMachine.t -> unit */
 CAMLprim value llvm_targetmachine_set_verbose_asm(value Verb, value Machine) {
   LLVMSetTargetMachineAsmVerbosity(TargetMachine_val(Machine), Bool_val(Verb));
   return Val_unit;
 }
 
 /* Llvm.llmodule -> CodeGenFileType.t -> string -> TargetMachine.t -> unit */
 CAMLprim value llvm_targetmachine_emit_to_file(LLVMModuleRef Module,

llvm/trunk/test/Bindings/OCaml/target.ml

 (*===-- Target Machine ----------------------------------------------------===*)
 
 let test_target_machine () =
   let module TM = TargetMachine in
   assert_equal (TM.target machine) target;
   assert_equal (TM.triple machine) (Target.default_triple ());
   assert_equal (TM.cpu machine) "";
   assert_equal (TM.features machine) "";
+  ignore (TM.data_layout machine);
   TM.set_verbose_asm true machine;
   let pm = PassManager.create () in
   TM.add_analysis_passes pm machine
 
 
 (*===-- Code Emission -----------------------------------------------------===*)
 
 let test_code_emission () =