Add the Instruction::clone function to llvm-c, and export it to the ocaml bindings

[pollux]

Summary

Export Instruction::clone() in the OCaml bindings.
Instructions can then be cloned using
"let new_i = instr_clone instr in [...]"

Instruction has no parent, and operands of the instruction must be updated (using the existing set_operand).

Tested on llvm 3.5, using some more (OCaml) code to clone an entire function.

[whitequark]

Could you add tests for this function? test/Bindings/Ocaml/vmcore.ml
I would add the instruction with different name and arguments and verify its existence with filecheck.

[pollux]

Here is an updated patch, with a test added to vmcore.ml

[whitequark]

LGTM

[whitequark]

r220007/r220008

bindings/ocaml/llvm/llvm.ml

external instr_succ : llvalue -> (llbasicblock, llvalue) llpos
                      = "llvm_instr_succ"
 external instr_end : llbasicblock -> (llbasicblock, llvalue) llrev_pos
                      = "llvm_instr_end"
 external instr_pred : llvalue -> (llbasicblock, llvalue) llrev_pos
                      = "llvm_instr_pred"
 
 external instr_opcode : llvalue -> Opcode.t = "llvm_instr_get_opcode"
 external icmp_predicate : llvalue -> Icmp.t option = "llvm_instr_icmp_predicate"
+external instr_clone : llvalue -> llvalue = "llvm_instr_clone"
 
 let rec iter_instrs_range f i e =
   if i = e then () else
   match i with
   | At_end _ -> raise (Invalid_argument "Invalid instruction range.")
   | Before i ->
       f i;
       iter_instrs_range f (instr_succ i) e

bindings/ocaml/llvm/llvm.mli

 (** [inst_opcode i] returns the [Opcode.t] corresponding to instruction [i],
     or [Opcode.Invalid] if [i] is not an instruction. *)
 val instr_opcode : llvalue -> Opcode.t
 
 (** [icmp_predicate i] returns the [Icmp.t] corresponding to an [icmp]
     instruction [i]. *)
 val icmp_predicate : llvalue -> Icmp.t option
 
+(** [inst_clone i] returns a copy of instruction [i],
+    The instruction has no parent, and no name.
+    See the method [llvm::Instruction::clone]. *)
+val instr_clone : llvalue -> llvalue
+
 
 (** {7 Operations on call sites} *)
 
 (** [instruction_call_conv ci] is the calling convention for the call or invoke
     instruction [ci], which may be one of the values from the module
     {!CallConv}. See the method [llvm::CallInst::getCallingConv] and
     [llvm::InvokeInst::getCallingConv]. *)
 val instruction_call_conv: llvalue -> int

bindings/ocaml/llvm/llvm_ocaml.c

CAMLprim value llvm_instr_icmp_predicate(LLVMValueRef Val) {
   if (x) {
     value Option = alloc(1, 0);
     Field(Option, 0) = Val_int(x - LLVMIntEQ);
     CAMLreturn(Option);
   }
   CAMLreturn(Val_int(0));
 }
 
+/* llvalue -> llvalue */
+CAMLprim LLVMValueRef llvm_instr_clone(LLVMValueRef Inst) {
+  if (!LLVMIsAInstruction(Inst))
+      failwith("Not an instruction");
+  return LLVMInstructionClone(Inst);
+}
+
 
 /*--... Operations on call sites ...........................................--*/
 
 /* llvalue -> int */
 CAMLprim value llvm_instruction_call_conv(LLVMValueRef Inst) {
   return Val_int(LLVMGetInstructionCallConv(Inst));
 }
 

include/llvm-c/Core.h

  * This is only valid for instructions that correspond to llvm::ICmpInst
  * or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
  *
  * @see llvm::ICmpInst::getPredicate()
  */
 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst);
 
 /**
+ * Create a copy of 'this' instruction that is identical in all ways
+ * except the following:
+ *   * The instruction has no parent
+ *   * The instruction has no name
+ *
+ * @see llvm::Instruction::clone()
+ */
+LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst);
+
+/**
  * @defgroup LLVMCCoreValueInstructionCall Call Sites and Invocations
  *
  * Functions in this group apply to instructions that refer to call
  * sites and invocations. These correspond to C++ types in the
  * llvm::CallInst class tree.
  *
  * @{
  */

lib/IR/Core.cpp

 }
 
 LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst) {
   if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
     return map_to_llvmopcode(C->getOpcode());
   return (LLVMOpcode)0;
 }
 
+LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst) {
+  if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
+    return wrap(C->clone());
+  return nullptr;
+}
+
 /*--.. Call and invoke instructions ........................................--*/
 
 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
   Value *V = unwrap(Instr);
   if (CallInst *CI = dyn_cast<CallInst>(V))
     return CI->getCallingConv();
   if (InvokeInst *II = dyn_cast<InvokeInst>(V))
     return II->getCallingConv();

test/Bindings/Ocaml/vmcore.ml

begin group "iteration";
     
     let lf s x = s ^ "->" ^ value_name x in
     insist ("->One->Two" = fold_left_instrs lf "" bb);
     
     let rf x s = value_name x ^ "<-" ^ s in
     insist ("One<-Two<-" = fold_right_instrs rf bb "");
     
     dispose_module m
+  end;
+  
+  group "clone instr";
+  begin
+    (* CHECK: %clone = add i32 %0, 2
+     *)
+    let fty = function_type void_type [| i32_type |] in
+    let fn = define_function "BuilderParent" fty m in
+    let bb = entry_block fn in
+    let b = builder_at_end context bb in
+    let p = param fn 0 in
+    let sum = build_add p p "sum" b in
+    let y = const_int i32_type 2 in
+    let clone = instr_clone sum in
+    set_operand clone 0 p;
+    set_operand clone 1 y;
+    insert_into_builder clone "clone" b;
+    ignore (build_ret_void b)
   end
 
 
 (*===-- Builder -----------------------------------------------------------===*)
 
 let test_builder () =
   let (++) x f = f x; x in