Home | History | Annotate | Download | only in llvm 
      1 /*===-- llvm_ocaml.c - LLVM OCaml Glue --------------------------*- C++ -*-===*\
      2 |*                                                                            *|
      3 |*                     The LLVM Compiler Infrastructure                       *|
      4 |*                                                                            *|
      5 |* This file is distributed under the University of Illinois Open Source      *|
      6 |* License. See LICENSE.TXT for details.                                      *|
      7 |*                                                                            *|
      8 |*===----------------------------------------------------------------------===*|
      9 |*                                                                            *|
     10 |* This file glues LLVM's OCaml interface to its C interface. These functions *|
     11 |* are by and large transparent wrappers to the corresponding C functions.    *|
     12 |*                                                                            *|
     13 |* Note that these functions intentionally take liberties with the CAMLparamX *|
     14 |* macros, since most of the parameters are not GC heap objects.              *|
     15 |*                                                                            *|
     16 \*===----------------------------------------------------------------------===*/
     17 
     18 #include "llvm-c/Core.h"
     19 #include "caml/alloc.h"
     20 #include "caml/custom.h"
     21 #include "caml/memory.h"
     22 #include "caml/fail.h"
     23 #include "caml/callback.h"
     24 #include <assert.h>
     25 #include <stdlib.h>
     26 #include <string.h>
     27 
     28 
     29 /* Can't use the recommended caml_named_value mechanism for backwards
     30    compatibility reasons. This is largely equivalent. */
     31 static value llvm_ioerror_exn;
     32 
     33 CAMLprim value llvm_register_core_exns(value IoError) {
     34   llvm_ioerror_exn = Field(IoError, 0);
     35   register_global_root(&llvm_ioerror_exn);
     36 
     37   return Val_unit;
     38 }
     39 
     40 static void llvm_raise(value Prototype, char *Message) {
     41   CAMLparam1(Prototype);
     42   CAMLlocal1(CamlMessage);
     43 
     44   CamlMessage = copy_string(Message);
     45   LLVMDisposeMessage(Message);
     46 
     47   raise_with_arg(Prototype, CamlMessage);
     48   abort(); /* NOTREACHED */
     49 #ifdef CAMLnoreturn
     50   CAMLnoreturn; /* Silences warnings, but is missing in some versions. */
     51 #endif
     52 }
     53 
     54 static value llvm_fatal_error_handler;
     55 
     56 static void llvm_fatal_error_trampoline(const char *Reason) {
     57   callback(llvm_fatal_error_handler, copy_string(Reason));
     58 }
     59 
     60 CAMLprim value llvm_install_fatal_error_handler(value Handler) {
     61   LLVMInstallFatalErrorHandler(llvm_fatal_error_trampoline);
     62   llvm_fatal_error_handler = Handler;
     63   caml_register_global_root(&llvm_fatal_error_handler);
     64   return Val_unit;
     65 }
     66 
     67 CAMLprim value llvm_reset_fatal_error_handler(value Unit) {
     68   caml_remove_global_root(&llvm_fatal_error_handler);
     69   LLVMResetFatalErrorHandler();
     70   return Val_unit;
     71 }
     72 
     73 CAMLprim value llvm_enable_pretty_stacktrace(value Unit) {
     74   LLVMEnablePrettyStackTrace();
     75   return Val_unit;
     76 }
     77 
     78 static value alloc_variant(int tag, void *Value) {
     79   value Iter = alloc_small(1, tag);
     80   Field(Iter, 0) = Val_op(Value);
     81   return Iter;
     82 }
     83 
     84 /* Macro to convert the C first/next/last/prev idiom to the Ocaml llpos/
     85    llrev_pos idiom. */
     86 #define DEFINE_ITERATORS(camlname, cname, pty, cty, pfun) \
     87   /* llmodule -> ('a, 'b) llpos */                        \
     88   CAMLprim value llvm_##camlname##_begin(pty Mom) {       \
     89     cty First = LLVMGetFirst##cname(Mom);                 \
     90     if (First)                                            \
     91       return alloc_variant(1, First);                     \
     92     return alloc_variant(0, Mom);                         \
     93   }                                                       \
     94                                                           \
     95   /* llvalue -> ('a, 'b) llpos */                         \
     96   CAMLprim value llvm_##camlname##_succ(cty Kid) {        \
     97     cty Next = LLVMGetNext##cname(Kid);                   \
     98     if (Next)                                             \
     99       return alloc_variant(1, Next);                      \
    100     return alloc_variant(0, pfun(Kid));                   \
    101   }                                                       \
    102                                                           \
    103   /* llmodule -> ('a, 'b) llrev_pos */                    \
    104   CAMLprim value llvm_##camlname##_end(pty Mom) {         \
    105     cty Last = LLVMGetLast##cname(Mom);                   \
    106     if (Last)                                             \
    107       return alloc_variant(1, Last);                      \
    108     return alloc_variant(0, Mom);                         \
    109   }                                                       \
    110                                                           \
    111   /* llvalue -> ('a, 'b) llrev_pos */                     \
    112   CAMLprim value llvm_##camlname##_pred(cty Kid) {        \
    113     cty Prev = LLVMGetPrevious##cname(Kid);               \
    114     if (Prev)                                             \
    115       return alloc_variant(1, Prev);                      \
    116     return alloc_variant(0, pfun(Kid));                   \
    117   }
    118 
    119 
    120 /*===-- Contexts ----------------------------------------------------------===*/
    121 
    122 /* unit -> llcontext */
    123 CAMLprim LLVMContextRef llvm_create_context(value Unit) {
    124   return LLVMContextCreate();
    125 }
    126 
    127 /* llcontext -> unit */
    128 CAMLprim value llvm_dispose_context(LLVMContextRef C) {
    129   LLVMContextDispose(C);
    130   return Val_unit;
    131 }
    132 
    133 /* unit -> llcontext */
    134 CAMLprim LLVMContextRef llvm_global_context(value Unit) {
    135   return LLVMGetGlobalContext();
    136 }
    137 
    138 /* llcontext -> string -> int */
    139 CAMLprim value llvm_mdkind_id(LLVMContextRef C, value Name) {
    140   unsigned MDKindID = LLVMGetMDKindIDInContext(C, String_val(Name),
    141                                                caml_string_length(Name));
    142   return Val_int(MDKindID);
    143 }
    144 
    145 /*===-- Modules -----------------------------------------------------------===*/
    146 
    147 /* llcontext -> string -> llmodule */
    148 CAMLprim LLVMModuleRef llvm_create_module(LLVMContextRef C, value ModuleID) {
    149   return LLVMModuleCreateWithNameInContext(String_val(ModuleID), C);
    150 }
    151 
    152 /* llmodule -> unit */
    153 CAMLprim value llvm_dispose_module(LLVMModuleRef M) {
    154   LLVMDisposeModule(M);
    155   return Val_unit;
    156 }
    157 
    158 /* llmodule -> string */
    159 CAMLprim value llvm_target_triple(LLVMModuleRef M) {
    160   return copy_string(LLVMGetTarget(M));
    161 }
    162 
    163 /* string -> llmodule -> unit */
    164 CAMLprim value llvm_set_target_triple(value Trip, LLVMModuleRef M) {
    165   LLVMSetTarget(M, String_val(Trip));
    166   return Val_unit;
    167 }
    168 
    169 /* llmodule -> string */
    170 CAMLprim value llvm_data_layout(LLVMModuleRef M) {
    171   return copy_string(LLVMGetDataLayout(M));
    172 }
    173 
    174 /* string -> llmodule -> unit */
    175 CAMLprim value llvm_set_data_layout(value Layout, LLVMModuleRef M) {
    176   LLVMSetDataLayout(M, String_val(Layout));
    177   return Val_unit;
    178 }
    179 
    180 /* llmodule -> unit */
    181 CAMLprim value llvm_dump_module(LLVMModuleRef M) {
    182   LLVMDumpModule(M);
    183   return Val_unit;
    184 }
    185 
    186 /* string -> llmodule -> unit */
    187 CAMLprim value llvm_print_module(value Filename, LLVMModuleRef M) {
    188   char* Message;
    189   if(LLVMPrintModuleToFile(M, String_val(Filename), &Message)) {
    190     llvm_raise(llvm_ioerror_exn, Message);
    191   }
    192 
    193   return Val_unit;
    194 }
    195 
    196 /* llmodule -> string */
    197 CAMLprim value llvm_string_of_llmodule(LLVMModuleRef M) {
    198   char* ModuleCStr;
    199   ModuleCStr = LLVMPrintModuleToString(M);
    200 
    201   value ModuleStr = caml_copy_string(ModuleCStr);
    202   LLVMDisposeMessage(ModuleCStr);
    203 
    204   return ModuleStr;
    205 }
    206 
    207 /* llmodule -> string -> unit */
    208 CAMLprim value llvm_set_module_inline_asm(LLVMModuleRef M, value Asm) {
    209   LLVMSetModuleInlineAsm(M, String_val(Asm));
    210   return Val_unit;
    211 }
    212 
    213 /*===-- Types -------------------------------------------------------------===*/
    214 
    215 /* lltype -> TypeKind.t */
    216 CAMLprim value llvm_classify_type(LLVMTypeRef Ty) {
    217   return Val_int(LLVMGetTypeKind(Ty));
    218 }
    219 
    220 CAMLprim value llvm_type_is_sized(LLVMTypeRef Ty) {
    221     return Val_bool(LLVMTypeIsSized(Ty));
    222 }
    223 
    224 /* lltype -> llcontext */
    225 CAMLprim LLVMContextRef llvm_type_context(LLVMTypeRef Ty) {
    226   return LLVMGetTypeContext(Ty);
    227 }
    228 
    229 /* lltype -> unit */
    230 CAMLprim value llvm_dump_type(LLVMTypeRef Val) {
    231   LLVMDumpType(Val);
    232   return Val_unit;
    233 }
    234 
    235 /* lltype -> string */
    236 CAMLprim value llvm_string_of_lltype(LLVMTypeRef M) {
    237   char* TypeCStr;
    238   TypeCStr = LLVMPrintTypeToString(M);
    239 
    240   value TypeStr = caml_copy_string(TypeCStr);
    241   LLVMDisposeMessage(TypeCStr);
    242 
    243   return TypeStr;
    244 }
    245 
    246 /*--... Operations on integer types ........................................--*/
    247 
    248 /* llcontext -> lltype */
    249 CAMLprim LLVMTypeRef llvm_i1_type (LLVMContextRef Context) {
    250   return LLVMInt1TypeInContext(Context);
    251 }
    252 
    253 /* llcontext -> lltype */
    254 CAMLprim LLVMTypeRef llvm_i8_type (LLVMContextRef Context) {
    255   return LLVMInt8TypeInContext(Context);
    256 }
    257 
    258 /* llcontext -> lltype */
    259 CAMLprim LLVMTypeRef llvm_i16_type (LLVMContextRef Context) {
    260   return LLVMInt16TypeInContext(Context);
    261 }
    262 
    263 /* llcontext -> lltype */
    264 CAMLprim LLVMTypeRef llvm_i32_type (LLVMContextRef Context) {
    265   return LLVMInt32TypeInContext(Context);
    266 }
    267 
    268 /* llcontext -> lltype */
    269 CAMLprim LLVMTypeRef llvm_i64_type (LLVMContextRef Context) {
    270   return LLVMInt64TypeInContext(Context);
    271 }
    272 
    273 /* llcontext -> int -> lltype */
    274 CAMLprim LLVMTypeRef llvm_integer_type(LLVMContextRef Context, value Width) {
    275   return LLVMIntTypeInContext(Context, Int_val(Width));
    276 }
    277 
    278 /* lltype -> int */
    279 CAMLprim value llvm_integer_bitwidth(LLVMTypeRef IntegerTy) {
    280   return Val_int(LLVMGetIntTypeWidth(IntegerTy));
    281 }
    282 
    283 /*--... Operations on real types ...........................................--*/
    284 
    285 /* llcontext -> lltype */
    286 CAMLprim LLVMTypeRef llvm_float_type(LLVMContextRef Context) {
    287   return LLVMFloatTypeInContext(Context);
    288 }
    289 
    290 /* llcontext -> lltype */
    291 CAMLprim LLVMTypeRef llvm_double_type(LLVMContextRef Context) {
    292   return LLVMDoubleTypeInContext(Context);
    293 }
    294 
    295 /* llcontext -> lltype */
    296 CAMLprim LLVMTypeRef llvm_x86fp80_type(LLVMContextRef Context) {
    297   return LLVMX86FP80TypeInContext(Context);
    298 }
    299 
    300 /* llcontext -> lltype */
    301 CAMLprim LLVMTypeRef llvm_fp128_type(LLVMContextRef Context) {
    302   return LLVMFP128TypeInContext(Context);
    303 }
    304 
    305 /* llcontext -> lltype */
    306 CAMLprim LLVMTypeRef llvm_ppc_fp128_type(LLVMContextRef Context) {
    307   return LLVMPPCFP128TypeInContext(Context);
    308 }
    309 
    310 /*--... Operations on function types .......................................--*/
    311 
    312 /* lltype -> lltype array -> lltype */
    313 CAMLprim LLVMTypeRef llvm_function_type(LLVMTypeRef RetTy, value ParamTys) {
    314   return LLVMFunctionType(RetTy, (LLVMTypeRef *) ParamTys,
    315                           Wosize_val(ParamTys), 0);
    316 }
    317 
    318 /* lltype -> lltype array -> lltype */
    319 CAMLprim LLVMTypeRef llvm_var_arg_function_type(LLVMTypeRef RetTy,
    320                                                 value ParamTys) {
    321   return LLVMFunctionType(RetTy, (LLVMTypeRef *) ParamTys,
    322                           Wosize_val(ParamTys), 1);
    323 }
    324 
    325 /* lltype -> bool */
    326 CAMLprim value llvm_is_var_arg(LLVMTypeRef FunTy) {
    327   return Val_bool(LLVMIsFunctionVarArg(FunTy));
    328 }
    329 
    330 /* lltype -> lltype array */
    331 CAMLprim value llvm_param_types(LLVMTypeRef FunTy) {
    332   value Tys = alloc(LLVMCountParamTypes(FunTy), 0);
    333   LLVMGetParamTypes(FunTy, (LLVMTypeRef *) Tys);
    334   return Tys;
    335 }
    336 
    337 /*--... Operations on struct types .........................................--*/
    338 
    339 /* llcontext -> lltype array -> lltype */
    340 CAMLprim LLVMTypeRef llvm_struct_type(LLVMContextRef C, value ElementTypes) {
    341   return LLVMStructTypeInContext(C, (LLVMTypeRef *) ElementTypes,
    342                                  Wosize_val(ElementTypes), 0);
    343 }
    344 
    345 /* llcontext -> lltype array -> lltype */
    346 CAMLprim LLVMTypeRef llvm_packed_struct_type(LLVMContextRef C,
    347                                              value ElementTypes) {
    348   return LLVMStructTypeInContext(C, (LLVMTypeRef *) ElementTypes,
    349                                  Wosize_val(ElementTypes), 1);
    350 }
    351 
    352 /* llcontext -> string -> lltype */
    353 CAMLprim LLVMTypeRef llvm_named_struct_type(LLVMContextRef C,
    354                                             value Name) {
    355   return LLVMStructCreateNamed(C, String_val(Name));
    356 }
    357 
    358 CAMLprim value llvm_struct_set_body(LLVMTypeRef Ty,
    359                                     value ElementTypes,
    360                                     value Packed) {
    361   LLVMStructSetBody(Ty, (LLVMTypeRef *) ElementTypes,
    362                     Wosize_val(ElementTypes), Bool_val(Packed));
    363   return Val_unit;
    364 }
    365 
    366 /* lltype -> string option */
    367 CAMLprim value llvm_struct_name(LLVMTypeRef Ty)
    368 {
    369   CAMLparam0();
    370   const char *C = LLVMGetStructName(Ty);
    371   if (C) {
    372     CAMLlocal1(result);
    373     result = caml_alloc_small(1, 0);
    374     Store_field(result, 0, caml_copy_string(C));
    375     CAMLreturn(result);
    376   }
    377   CAMLreturn(Val_int(0));
    378 }
    379 
    380 /* lltype -> lltype array */
    381 CAMLprim value llvm_struct_element_types(LLVMTypeRef StructTy) {
    382   value Tys = alloc(LLVMCountStructElementTypes(StructTy), 0);
    383   LLVMGetStructElementTypes(StructTy, (LLVMTypeRef *) Tys);
    384   return Tys;
    385 }
    386 
    387 /* lltype -> bool */
    388 CAMLprim value llvm_is_packed(LLVMTypeRef StructTy) {
    389   return Val_bool(LLVMIsPackedStruct(StructTy));
    390 }
    391 
    392 /* lltype -> bool */
    393 CAMLprim value llvm_is_opaque(LLVMTypeRef StructTy) {
    394   return Val_bool(LLVMIsOpaqueStruct(StructTy));
    395 }
    396 
    397 /*--... Operations on array, pointer, and vector types .....................--*/
    398 
    399 /* lltype -> int -> lltype */
    400 CAMLprim LLVMTypeRef llvm_array_type(LLVMTypeRef ElementTy, value Count) {
    401   return LLVMArrayType(ElementTy, Int_val(Count));
    402 }
    403 
    404 /* lltype -> lltype */
    405 CAMLprim LLVMTypeRef llvm_pointer_type(LLVMTypeRef ElementTy) {
    406   return LLVMPointerType(ElementTy, 0);
    407 }
    408 
    409 /* lltype -> int -> lltype */
    410 CAMLprim LLVMTypeRef llvm_qualified_pointer_type(LLVMTypeRef ElementTy,
    411                                                  value AddressSpace) {
    412   return LLVMPointerType(ElementTy, Int_val(AddressSpace));
    413 }
    414 
    415 /* lltype -> int -> lltype */
    416 CAMLprim LLVMTypeRef llvm_vector_type(LLVMTypeRef ElementTy, value Count) {
    417   return LLVMVectorType(ElementTy, Int_val(Count));
    418 }
    419 
    420 /* lltype -> int */
    421 CAMLprim value llvm_array_length(LLVMTypeRef ArrayTy) {
    422   return Val_int(LLVMGetArrayLength(ArrayTy));
    423 }
    424 
    425 /* lltype -> int */
    426 CAMLprim value llvm_address_space(LLVMTypeRef PtrTy) {
    427   return Val_int(LLVMGetPointerAddressSpace(PtrTy));
    428 }
    429 
    430 /* lltype -> int */
    431 CAMLprim value llvm_vector_size(LLVMTypeRef VectorTy) {
    432   return Val_int(LLVMGetVectorSize(VectorTy));
    433 }
    434 
    435 /*--... Operations on other types ..........................................--*/
    436 
    437 /* llcontext -> lltype */
    438 CAMLprim LLVMTypeRef llvm_void_type (LLVMContextRef Context) {
    439   return LLVMVoidTypeInContext(Context);
    440 }
    441 
    442 /* llcontext -> lltype */
    443 CAMLprim LLVMTypeRef llvm_label_type(LLVMContextRef Context) {
    444   return LLVMLabelTypeInContext(Context);
    445 }
    446 
    447 /* llcontext -> lltype */
    448 CAMLprim LLVMTypeRef llvm_x86_mmx_type(LLVMContextRef Context) {
    449   return LLVMX86MMXTypeInContext(Context);
    450 }
    451 
    452 CAMLprim value llvm_type_by_name(LLVMModuleRef M, value Name)
    453 {
    454   CAMLparam1(Name);
    455   LLVMTypeRef Ty = LLVMGetTypeByName(M, String_val(Name));
    456   if (Ty) {
    457     value Option = alloc(1, 0);
    458     Field(Option, 0) = (value) Ty;
    459     CAMLreturn(Option);
    460   }
    461   CAMLreturn(Val_int(0));
    462 }
    463 
    464 /*===-- VALUES ------------------------------------------------------------===*/
    465 
    466 /* llvalue -> lltype */
    467 CAMLprim LLVMTypeRef llvm_type_of(LLVMValueRef Val) {
    468   return LLVMTypeOf(Val);
    469 }
    470 
    471 /* keep in sync with ValueKind.t */
    472 enum ValueKind {
    473   NullValue=0,
    474   Argument,
    475   BasicBlock,
    476   InlineAsm,
    477   MDNode,
    478   MDString,
    479   BlockAddress,
    480   ConstantAggregateZero,
    481   ConstantArray,
    482   ConstantDataArray,
    483   ConstantDataVector,
    484   ConstantExpr,
    485   ConstantFP,
    486   ConstantInt,
    487   ConstantPointerNull,
    488   ConstantStruct,
    489   ConstantVector,
    490   Function,
    491   GlobalAlias,
    492   GlobalVariable,
    493   UndefValue,
    494   Instruction
    495 };
    496 
    497 /* llvalue -> ValueKind.t */
    498 #define DEFINE_CASE(Val, Kind) \
    499     do {if (LLVMIsA##Kind(Val)) CAMLreturn(Val_int(Kind));} while(0)
    500 
    501 CAMLprim value llvm_classify_value(LLVMValueRef Val) {
    502   CAMLparam0();
    503   if (!Val)
    504     CAMLreturn(Val_int(NullValue));
    505   if (LLVMIsAConstant(Val)) {
    506     DEFINE_CASE(Val, BlockAddress);
    507     DEFINE_CASE(Val, ConstantAggregateZero);
    508     DEFINE_CASE(Val, ConstantArray);
    509     DEFINE_CASE(Val, ConstantDataArray);
    510     DEFINE_CASE(Val, ConstantDataVector);
    511     DEFINE_CASE(Val, ConstantExpr);
    512     DEFINE_CASE(Val, ConstantFP);
    513     DEFINE_CASE(Val, ConstantInt);
    514     DEFINE_CASE(Val, ConstantPointerNull);
    515     DEFINE_CASE(Val, ConstantStruct);
    516     DEFINE_CASE(Val, ConstantVector);
    517   }
    518   if (LLVMIsAInstruction(Val)) {
    519     CAMLlocal1(result);
    520     result = caml_alloc_small(1, 0);
    521     Store_field(result, 0, Val_int(LLVMGetInstructionOpcode(Val)));
    522     CAMLreturn(result);
    523   }
    524   if (LLVMIsAGlobalValue(Val)) {
    525     DEFINE_CASE(Val, Function);
    526     DEFINE_CASE(Val, GlobalAlias);
    527     DEFINE_CASE(Val, GlobalVariable);
    528   }
    529   DEFINE_CASE(Val, Argument);
    530   DEFINE_CASE(Val, BasicBlock);
    531   DEFINE_CASE(Val, InlineAsm);
    532   DEFINE_CASE(Val, MDNode);
    533   DEFINE_CASE(Val, MDString);
    534   DEFINE_CASE(Val, UndefValue);
    535   failwith("Unknown Value class");
    536 }
    537 
    538 /* llvalue -> string */
    539 CAMLprim value llvm_value_name(LLVMValueRef Val) {
    540   return copy_string(LLVMGetValueName(Val));
    541 }
    542 
    543 /* string -> llvalue -> unit */
    544 CAMLprim value llvm_set_value_name(value Name, LLVMValueRef Val) {
    545   LLVMSetValueName(Val, String_val(Name));
    546   return Val_unit;
    547 }
    548 
    549 /* llvalue -> unit */
    550 CAMLprim value llvm_dump_value(LLVMValueRef Val) {
    551   LLVMDumpValue(Val);
    552   return Val_unit;
    553 }
    554 
    555 /* llvalue -> string */
    556 CAMLprim value llvm_string_of_llvalue(LLVMValueRef M) {
    557   char* ValueCStr;
    558   ValueCStr = LLVMPrintValueToString(M);
    559 
    560   value ValueStr = caml_copy_string(ValueCStr);
    561   LLVMDisposeMessage(ValueCStr);
    562 
    563   return ValueStr;
    564 }
    565 
    566 /* llvalue -> llvalue -> unit */
    567 CAMLprim value llvm_replace_all_uses_with(LLVMValueRef OldVal,
    568                                           LLVMValueRef NewVal) {
    569   LLVMReplaceAllUsesWith(OldVal, NewVal);
    570   return Val_unit;
    571 }
    572 
    573 /*--... Operations on users ................................................--*/
    574 
    575 /* llvalue -> int -> llvalue */
    576 CAMLprim LLVMValueRef llvm_operand(LLVMValueRef V, value I) {
    577   return LLVMGetOperand(V, Int_val(I));
    578 }
    579 
    580 /* llvalue -> int -> llvalue -> unit */
    581 CAMLprim value llvm_set_operand(LLVMValueRef U, value I, LLVMValueRef V) {
    582   LLVMSetOperand(U, Int_val(I), V);
    583   return Val_unit;
    584 }
    585 
    586 /* llvalue -> int */
    587 CAMLprim value llvm_num_operands(LLVMValueRef V) {
    588   return Val_int(LLVMGetNumOperands(V));
    589 }
    590 
    591 /*--... Operations on constants of (mostly) any type .......................--*/
    592 
    593 /* llvalue -> bool */
    594 CAMLprim value llvm_is_constant(LLVMValueRef Val) {
    595   return Val_bool(LLVMIsConstant(Val));
    596 }
    597 
    598 /* llvalue -> bool */
    599 CAMLprim value llvm_is_null(LLVMValueRef Val) {
    600   return Val_bool(LLVMIsNull(Val));
    601 }
    602 
    603 /* llvalue -> bool */
    604 CAMLprim value llvm_is_undef(LLVMValueRef Val) {
    605   return Val_bool(LLVMIsUndef(Val));
    606 }
    607 
    608 /* llvalue -> Opcode.t */
    609 CAMLprim value llvm_constexpr_get_opcode(LLVMValueRef Val) {
    610   return LLVMIsAConstantExpr(Val) ?
    611       Val_int(LLVMGetConstOpcode(Val)) : Val_int(0);
    612 }
    613 
    614 /*--... Operations on instructions .........................................--*/
    615 
    616 /* llvalue -> bool */
    617 CAMLprim value llvm_has_metadata(LLVMValueRef Val) {
    618   return Val_bool(LLVMHasMetadata(Val));
    619 }
    620 
    621 /* llvalue -> int -> llvalue option */
    622 CAMLprim value llvm_metadata(LLVMValueRef Val, value MDKindID) {
    623   CAMLparam1(MDKindID);
    624   LLVMValueRef MD;
    625   if ((MD = LLVMGetMetadata(Val, Int_val(MDKindID)))) {
    626     value Option = alloc(1, 0);
    627     Field(Option, 0) = (value) MD;
    628     CAMLreturn(Option);
    629   }
    630   CAMLreturn(Val_int(0));
    631 }
    632 
    633 /* llvalue -> int -> llvalue -> unit */
    634 CAMLprim value llvm_set_metadata(LLVMValueRef Val, value MDKindID,
    635                                  LLVMValueRef MD) {
    636   LLVMSetMetadata(Val, Int_val(MDKindID), MD);
    637   return Val_unit;
    638 }
    639 
    640 /* llvalue -> int -> unit */
    641 CAMLprim value llvm_clear_metadata(LLVMValueRef Val, value MDKindID) {
    642   LLVMSetMetadata(Val, Int_val(MDKindID), NULL);
    643   return Val_unit;
    644 }
    645 
    646 
    647 /*--... Operations on metadata .............................................--*/
    648 
    649 /* llcontext -> string -> llvalue */
    650 CAMLprim LLVMValueRef llvm_mdstring(LLVMContextRef C, value S) {
    651   return LLVMMDStringInContext(C, String_val(S), caml_string_length(S));
    652 }
    653 
    654 /* llcontext -> llvalue array -> llvalue */
    655 CAMLprim LLVMValueRef llvm_mdnode(LLVMContextRef C, value ElementVals) {
    656   return LLVMMDNodeInContext(C, (LLVMValueRef*) Op_val(ElementVals),
    657                              Wosize_val(ElementVals));
    658 }
    659 
    660 /* llvalue -> string option */
    661 CAMLprim value llvm_get_mdstring(LLVMValueRef V) {
    662   CAMLparam0();
    663   const char *S;
    664   unsigned Len;
    665 
    666   if ((S = LLVMGetMDString(V, &Len))) {
    667     CAMLlocal2(Option, Str);
    668 
    669     Str = caml_alloc_string(Len);
    670     memcpy(String_val(Str), S, Len);
    671     Option = alloc(1,0);
    672     Store_field(Option, 0, Str);
    673     CAMLreturn(Option);
    674   }
    675   CAMLreturn(Val_int(0));
    676 }
    677 
    678 /* llmodule -> string -> llvalue array */
    679 CAMLprim value llvm_get_namedmd(LLVMModuleRef M, value Name)
    680 {
    681   CAMLparam1(Name);
    682   CAMLlocal1(Nodes);
    683   Nodes = alloc(LLVMGetNamedMetadataNumOperands(M, String_val(Name)), 0);
    684   LLVMGetNamedMetadataOperands(M, String_val(Name), (LLVMValueRef *) Nodes);
    685   CAMLreturn(Nodes);
    686 }
    687 
    688 /* llmodule -> string -> llvalue -> unit */
    689 CAMLprim value llvm_append_namedmd(LLVMModuleRef M, value Name, LLVMValueRef Val) {
    690   LLVMAddNamedMetadataOperand(M, String_val(Name), Val);
    691   return Val_unit;
    692 }
    693 
    694 /*--... Operations on scalar constants .....................................--*/
    695 
    696 /* lltype -> int -> llvalue */
    697 CAMLprim LLVMValueRef llvm_const_int(LLVMTypeRef IntTy, value N) {
    698   return LLVMConstInt(IntTy, (long long) Int_val(N), 1);
    699 }
    700 
    701 /* lltype -> Int64.t -> bool -> llvalue */
    702 CAMLprim LLVMValueRef llvm_const_of_int64(LLVMTypeRef IntTy, value N,
    703                                           value SExt) {
    704   return LLVMConstInt(IntTy, Int64_val(N), Bool_val(SExt));
    705 }
    706 
    707 /* llvalue -> Int64.t */
    708 CAMLprim value llvm_int64_of_const(LLVMValueRef Const)
    709 {
    710   CAMLparam0();
    711   if (LLVMIsAConstantInt(Const) &&
    712       LLVMGetIntTypeWidth(LLVMTypeOf(Const)) <= 64) {
    713     value Option = alloc(1, 0);
    714     Field(Option, 0) = caml_copy_int64(LLVMConstIntGetSExtValue(Const));
    715     CAMLreturn(Option);
    716   }
    717   CAMLreturn(Val_int(0));
    718 }
    719 
    720 /* lltype -> string -> int -> llvalue */
    721 CAMLprim LLVMValueRef llvm_const_int_of_string(LLVMTypeRef IntTy, value S,
    722                                                value Radix) {
    723   return LLVMConstIntOfStringAndSize(IntTy, String_val(S), caml_string_length(S),
    724                                      Int_val(Radix));
    725 }
    726 
    727 /* lltype -> float -> llvalue */
    728 CAMLprim LLVMValueRef llvm_const_float(LLVMTypeRef RealTy, value N) {
    729   return LLVMConstReal(RealTy, Double_val(N));
    730 }
    731 
    732 /* lltype -> string -> llvalue */
    733 CAMLprim LLVMValueRef llvm_const_float_of_string(LLVMTypeRef RealTy, value S) {
    734   return LLVMConstRealOfStringAndSize(RealTy, String_val(S),
    735                                       caml_string_length(S));
    736 }
    737 
    738 /*--... Operations on composite constants ..................................--*/
    739 
    740 /* llcontext -> string -> llvalue */
    741 CAMLprim LLVMValueRef llvm_const_string(LLVMContextRef Context, value Str,
    742                                         value NullTerminate) {
    743   return LLVMConstStringInContext(Context, String_val(Str), string_length(Str),
    744                                   1);
    745 }
    746 
    747 /* llcontext -> string -> llvalue */
    748 CAMLprim LLVMValueRef llvm_const_stringz(LLVMContextRef Context, value Str,
    749                                          value NullTerminate) {
    750   return LLVMConstStringInContext(Context, String_val(Str), string_length(Str),
    751                                   0);
    752 }
    753 
    754 /* lltype -> llvalue array -> llvalue */
    755 CAMLprim LLVMValueRef llvm_const_array(LLVMTypeRef ElementTy,
    756                                                value ElementVals) {
    757   return LLVMConstArray(ElementTy, (LLVMValueRef*) Op_val(ElementVals),
    758                         Wosize_val(ElementVals));
    759 }
    760 
    761 /* llcontext -> llvalue array -> llvalue */
    762 CAMLprim LLVMValueRef llvm_const_struct(LLVMContextRef C, value ElementVals) {
    763   return LLVMConstStructInContext(C, (LLVMValueRef *) Op_val(ElementVals),
    764                                   Wosize_val(ElementVals), 0);
    765 }
    766 
    767 /* lltype -> llvalue array -> llvalue */
    768 CAMLprim LLVMValueRef llvm_const_named_struct(LLVMTypeRef Ty, value ElementVals) {
    769     return LLVMConstNamedStruct(Ty, (LLVMValueRef *) Op_val(ElementVals),  Wosize_val(ElementVals));
    770 }
    771 
    772 /* llcontext -> llvalue array -> llvalue */
    773 CAMLprim LLVMValueRef llvm_const_packed_struct(LLVMContextRef C,
    774                                                value ElementVals) {
    775   return LLVMConstStructInContext(C, (LLVMValueRef *) Op_val(ElementVals),
    776                                   Wosize_val(ElementVals), 1);
    777 }
    778 
    779 /* llvalue array -> llvalue */
    780 CAMLprim LLVMValueRef llvm_const_vector(value ElementVals) {
    781   return LLVMConstVector((LLVMValueRef*) Op_val(ElementVals),
    782                          Wosize_val(ElementVals));
    783 }
    784 
    785 /*--... Constant expressions ...............................................--*/
    786 
    787 /* Icmp.t -> llvalue -> llvalue -> llvalue */
    788 CAMLprim LLVMValueRef llvm_const_icmp(value Pred,
    789                                       LLVMValueRef LHSConstant,
    790                                       LLVMValueRef RHSConstant) {
    791   return LLVMConstICmp(Int_val(Pred) + LLVMIntEQ, LHSConstant, RHSConstant);
    792 }
    793 
    794 /* Fcmp.t -> llvalue -> llvalue -> llvalue */
    795 CAMLprim LLVMValueRef llvm_const_fcmp(value Pred,
    796                                       LLVMValueRef LHSConstant,
    797                                       LLVMValueRef RHSConstant) {
    798   return LLVMConstFCmp(Int_val(Pred), LHSConstant, RHSConstant);
    799 }
    800 
    801 /* llvalue -> llvalue array -> llvalue */
    802 CAMLprim LLVMValueRef llvm_const_gep(LLVMValueRef ConstantVal, value Indices) {
    803   return LLVMConstGEP(ConstantVal, (LLVMValueRef*) Op_val(Indices),
    804                       Wosize_val(Indices));
    805 }
    806 
    807 /* llvalue -> llvalue array -> llvalue */
    808 CAMLprim LLVMValueRef llvm_const_in_bounds_gep(LLVMValueRef ConstantVal,
    809                                                value Indices) {
    810   return LLVMConstInBoundsGEP(ConstantVal, (LLVMValueRef*) Op_val(Indices),
    811                               Wosize_val(Indices));
    812 }
    813 
    814 /* llvalue -> lltype -> is_signed:bool -> llvalue */
    815 CAMLprim LLVMValueRef llvm_const_intcast(LLVMValueRef CV, LLVMTypeRef T,
    816                                          value IsSigned) {
    817   return LLVMConstIntCast(CV, T, Bool_val(IsSigned));
    818 }
    819 
    820 /* llvalue -> int array -> llvalue */
    821 CAMLprim LLVMValueRef llvm_const_extractvalue(LLVMValueRef Aggregate,
    822                                               value Indices) {
    823   CAMLparam1(Indices);
    824   int size = Wosize_val(Indices);
    825   int i;
    826   LLVMValueRef result;
    827 
    828   unsigned* idxs = (unsigned*)malloc(size * sizeof(unsigned));
    829   for (i = 0; i < size; i++) {
    830     idxs[i] = Int_val(Field(Indices, i));
    831   }
    832 
    833   result = LLVMConstExtractValue(Aggregate, idxs, size);
    834   free(idxs);
    835   CAMLreturnT(LLVMValueRef, result);
    836 }
    837 
    838 /* llvalue -> llvalue -> int array -> llvalue */
    839 CAMLprim LLVMValueRef llvm_const_insertvalue(LLVMValueRef Aggregate,
    840                                              LLVMValueRef Val, value Indices) {
    841   CAMLparam1(Indices);
    842   int size = Wosize_val(Indices);
    843   int i;
    844   LLVMValueRef result;
    845 
    846   unsigned* idxs = (unsigned*)malloc(size * sizeof(unsigned));
    847   for (i = 0; i < size; i++) {
    848     idxs[i] = Int_val(Field(Indices, i));
    849   }
    850 
    851   result = LLVMConstInsertValue(Aggregate, Val, idxs, size);
    852   free(idxs);
    853   CAMLreturnT(LLVMValueRef, result);
    854 }
    855 
    856 /* lltype -> string -> string -> bool -> bool -> llvalue */
    857 CAMLprim LLVMValueRef llvm_const_inline_asm(LLVMTypeRef Ty, value Asm,
    858                                      value Constraints, value HasSideEffects,
    859                                      value IsAlignStack) {
    860   return LLVMConstInlineAsm(Ty, String_val(Asm), String_val(Constraints),
    861                             Bool_val(HasSideEffects), Bool_val(IsAlignStack));
    862 }
    863 
    864 /*--... Operations on global variables, functions, and aliases (globals) ...--*/
    865 
    866 /* llvalue -> bool */
    867 CAMLprim value llvm_is_declaration(LLVMValueRef Global) {
    868   return Val_bool(LLVMIsDeclaration(Global));
    869 }
    870 
    871 /* llvalue -> Linkage.t */
    872 CAMLprim value llvm_linkage(LLVMValueRef Global) {
    873   return Val_int(LLVMGetLinkage(Global));
    874 }
    875 
    876 /* Linkage.t -> llvalue -> unit */
    877 CAMLprim value llvm_set_linkage(value Linkage, LLVMValueRef Global) {
    878   LLVMSetLinkage(Global, Int_val(Linkage));
    879   return Val_unit;
    880 }
    881 
    882 /* llvalue -> string */
    883 CAMLprim value llvm_section(LLVMValueRef Global) {
    884   return copy_string(LLVMGetSection(Global));
    885 }
    886 
    887 /* string -> llvalue -> unit */
    888 CAMLprim value llvm_set_section(value Section, LLVMValueRef Global) {
    889   LLVMSetSection(Global, String_val(Section));
    890   return Val_unit;
    891 }
    892 
    893 /* llvalue -> Visibility.t */
    894 CAMLprim value llvm_visibility(LLVMValueRef Global) {
    895   return Val_int(LLVMGetVisibility(Global));
    896 }
    897 
    898 /* Visibility.t -> llvalue -> unit */
    899 CAMLprim value llvm_set_visibility(value Viz, LLVMValueRef Global) {
    900   LLVMSetVisibility(Global, Int_val(Viz));
    901   return Val_unit;
    902 }
    903 
    904 /* llvalue -> int */
    905 CAMLprim value llvm_alignment(LLVMValueRef Global) {
    906   return Val_int(LLVMGetAlignment(Global));
    907 }
    908 
    909 /* int -> llvalue -> unit */
    910 CAMLprim value llvm_set_alignment(value Bytes, LLVMValueRef Global) {
    911   LLVMSetAlignment(Global, Int_val(Bytes));
    912   return Val_unit;
    913 }
    914 
    915 /*--... Operations on uses .................................................--*/
    916 
    917 /* llvalue -> lluse option */
    918 CAMLprim value llvm_use_begin(LLVMValueRef Val) {
    919   CAMLparam0();
    920   LLVMUseRef First;
    921   if ((First = LLVMGetFirstUse(Val))) {
    922     value Option = alloc(1, 0);
    923     Field(Option, 0) = (value) First;
    924     CAMLreturn(Option);
    925   }
    926   CAMLreturn(Val_int(0));
    927 }
    928 
    929 /* lluse -> lluse option */
    930 CAMLprim value llvm_use_succ(LLVMUseRef U) {
    931   CAMLparam0();
    932   LLVMUseRef Next;
    933   if ((Next = LLVMGetNextUse(U))) {
    934     value Option = alloc(1, 0);
    935     Field(Option, 0) = (value) Next;
    936     CAMLreturn(Option);
    937   }
    938   CAMLreturn(Val_int(0));
    939 }
    940 
    941 /* lluse -> llvalue */
    942 CAMLprim LLVMValueRef llvm_user(LLVMUseRef UR) {
    943   return LLVMGetUser(UR);
    944 }
    945 
    946 /* lluse -> llvalue */
    947 CAMLprim LLVMValueRef llvm_used_value(LLVMUseRef UR) {
    948   return LLVMGetUsedValue(UR);
    949 }
    950 
    951 /*--... Operations on global variables .....................................--*/
    952 
    953 DEFINE_ITERATORS(global, Global, LLVMModuleRef, LLVMValueRef,
    954                  LLVMGetGlobalParent)
    955 
    956 /* lltype -> string -> llmodule -> llvalue */
    957 CAMLprim LLVMValueRef llvm_declare_global(LLVMTypeRef Ty, value Name,
    958                                           LLVMModuleRef M) {
    959   LLVMValueRef GlobalVar;
    960   if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
    961     if (LLVMGetElementType(LLVMTypeOf(GlobalVar)) != Ty)
    962       return LLVMConstBitCast(GlobalVar, LLVMPointerType(Ty, 0));
    963     return GlobalVar;
    964   }
    965   return LLVMAddGlobal(M, Ty, String_val(Name));
    966 }
    967 
    968 /* lltype -> string -> int -> llmodule -> llvalue */
    969 CAMLprim LLVMValueRef llvm_declare_qualified_global(LLVMTypeRef Ty, value Name,
    970                                                     value AddressSpace,
    971                                                     LLVMModuleRef M) {
    972   LLVMValueRef GlobalVar;
    973   if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
    974     if (LLVMGetElementType(LLVMTypeOf(GlobalVar)) != Ty)
    975       return LLVMConstBitCast(GlobalVar,
    976                               LLVMPointerType(Ty, Int_val(AddressSpace)));
    977     return GlobalVar;
    978   }
    979   return LLVMAddGlobalInAddressSpace(M, Ty, String_val(Name),
    980                                      Int_val(AddressSpace));
    981 }
    982 
    983 /* string -> llmodule -> llvalue option */
    984 CAMLprim value llvm_lookup_global(value Name, LLVMModuleRef M) {
    985   CAMLparam1(Name);
    986   LLVMValueRef GlobalVar;
    987   if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
    988     value Option = alloc(1, 0);
    989     Field(Option, 0) = (value) GlobalVar;
    990     CAMLreturn(Option);
    991   }
    992   CAMLreturn(Val_int(0));
    993 }
    994 
    995 /* string -> llvalue -> llmodule -> llvalue */
    996 CAMLprim LLVMValueRef llvm_define_global(value Name, LLVMValueRef Initializer,
    997                                          LLVMModuleRef M) {
    998   LLVMValueRef GlobalVar = LLVMAddGlobal(M, LLVMTypeOf(Initializer),
    999                                          String_val(Name));
   1000   LLVMSetInitializer(GlobalVar, Initializer);
   1001   return GlobalVar;
   1002 }
   1003 
   1004 /* string -> llvalue -> int -> llmodule -> llvalue */
   1005 CAMLprim LLVMValueRef llvm_define_qualified_global(value Name,
   1006                                                    LLVMValueRef Initializer,
   1007                                                    value AddressSpace,
   1008                                                    LLVMModuleRef M) {
   1009   LLVMValueRef GlobalVar = LLVMAddGlobalInAddressSpace(M,
   1010                                                        LLVMTypeOf(Initializer),
   1011                                                        String_val(Name),
   1012                                                        Int_val(AddressSpace));
   1013   LLVMSetInitializer(GlobalVar, Initializer);
   1014   return GlobalVar;
   1015 }
   1016 
   1017 /* llvalue -> unit */
   1018 CAMLprim value llvm_delete_global(LLVMValueRef GlobalVar) {
   1019   LLVMDeleteGlobal(GlobalVar);
   1020   return Val_unit;
   1021 }
   1022 
   1023 /* llvalue -> llvalue -> unit */
   1024 CAMLprim value llvm_set_initializer(LLVMValueRef ConstantVal,
   1025                                     LLVMValueRef GlobalVar) {
   1026   LLVMSetInitializer(GlobalVar, ConstantVal);
   1027   return Val_unit;
   1028 }
   1029 
   1030 /* llvalue -> unit */
   1031 CAMLprim value llvm_remove_initializer(LLVMValueRef GlobalVar) {
   1032   LLVMSetInitializer(GlobalVar, NULL);
   1033   return Val_unit;
   1034 }
   1035 
   1036 /* llvalue -> bool */
   1037 CAMLprim value llvm_is_thread_local(LLVMValueRef GlobalVar) {
   1038   return Val_bool(LLVMIsThreadLocal(GlobalVar));
   1039 }
   1040 
   1041 /* bool -> llvalue -> unit */
   1042 CAMLprim value llvm_set_thread_local(value IsThreadLocal,
   1043                                      LLVMValueRef GlobalVar) {
   1044   LLVMSetThreadLocal(GlobalVar, Bool_val(IsThreadLocal));
   1045   return Val_unit;
   1046 }
   1047 
   1048 /* llvalue -> ThreadLocalMode.t */
   1049 CAMLprim value llvm_thread_local_mode(LLVMValueRef GlobalVar) {
   1050   return Val_int(LLVMGetThreadLocalMode(GlobalVar));
   1051 }
   1052 
   1053 /* ThreadLocalMode.t -> llvalue -> unit */
   1054 CAMLprim value llvm_set_thread_local_mode(value ThreadLocalMode,
   1055                                           LLVMValueRef GlobalVar) {
   1056   LLVMSetThreadLocalMode(GlobalVar, Int_val(ThreadLocalMode));
   1057   return Val_unit;
   1058 }
   1059 
   1060 /* llvalue -> bool */
   1061 CAMLprim value llvm_is_externally_initialized(LLVMValueRef GlobalVar) {
   1062   return Val_bool(LLVMIsExternallyInitialized(GlobalVar));
   1063 }
   1064 
   1065 /* bool -> llvalue -> unit */
   1066 CAMLprim value llvm_set_externally_initialized(value IsExternallyInitialized,
   1067                                                LLVMValueRef GlobalVar) {
   1068   LLVMSetExternallyInitialized(GlobalVar, Bool_val(IsExternallyInitialized));
   1069   return Val_unit;
   1070 }
   1071 
   1072 /* llvalue -> bool */
   1073 CAMLprim value llvm_is_global_constant(LLVMValueRef GlobalVar) {
   1074   return Val_bool(LLVMIsGlobalConstant(GlobalVar));
   1075 }
   1076 
   1077 /* bool -> llvalue -> unit */
   1078 CAMLprim value llvm_set_global_constant(value Flag, LLVMValueRef GlobalVar) {
   1079   LLVMSetGlobalConstant(GlobalVar, Bool_val(Flag));
   1080   return Val_unit;
   1081 }
   1082 
   1083 /*--... Operations on aliases ..............................................--*/
   1084 
   1085 CAMLprim LLVMValueRef llvm_add_alias(LLVMModuleRef M, LLVMTypeRef Ty,
   1086                                      LLVMValueRef Aliasee, value Name) {
   1087   return LLVMAddAlias(M, Ty, Aliasee, String_val(Name));
   1088 }
   1089 
   1090 /*--... Operations on functions ............................................--*/
   1091 
   1092 DEFINE_ITERATORS(function, Function, LLVMModuleRef, LLVMValueRef,
   1093                  LLVMGetGlobalParent)
   1094 
   1095 /* string -> lltype -> llmodule -> llvalue */
   1096 CAMLprim LLVMValueRef llvm_declare_function(value Name, LLVMTypeRef Ty,
   1097                                             LLVMModuleRef M) {
   1098   LLVMValueRef Fn;
   1099   if ((Fn = LLVMGetNamedFunction(M, String_val(Name)))) {
   1100     if (LLVMGetElementType(LLVMTypeOf(Fn)) != Ty)
   1101       return LLVMConstBitCast(Fn, LLVMPointerType(Ty, 0));
   1102     return Fn;
   1103   }
   1104   return LLVMAddFunction(M, String_val(Name), Ty);
   1105 }
   1106 
   1107 /* string -> llmodule -> llvalue option */
   1108 CAMLprim value llvm_lookup_function(value Name, LLVMModuleRef M) {
   1109   CAMLparam1(Name);
   1110   LLVMValueRef Fn;
   1111   if ((Fn = LLVMGetNamedFunction(M, String_val(Name)))) {
   1112     value Option = alloc(1, 0);
   1113     Field(Option, 0) = (value) Fn;
   1114     CAMLreturn(Option);
   1115   }
   1116   CAMLreturn(Val_int(0));
   1117 }
   1118 
   1119 /* string -> lltype -> llmodule -> llvalue */
   1120 CAMLprim LLVMValueRef llvm_define_function(value Name, LLVMTypeRef Ty,
   1121                                            LLVMModuleRef M) {
   1122   LLVMValueRef Fn = LLVMAddFunction(M, String_val(Name), Ty);
   1123   LLVMAppendBasicBlockInContext(LLVMGetTypeContext(Ty), Fn, "entry");
   1124   return Fn;
   1125 }
   1126 
   1127 /* llvalue -> unit */
   1128 CAMLprim value llvm_delete_function(LLVMValueRef Fn) {
   1129   LLVMDeleteFunction(Fn);
   1130   return Val_unit;
   1131 }
   1132 
   1133 /* llvalue -> bool */
   1134 CAMLprim value llvm_is_intrinsic(LLVMValueRef Fn) {
   1135   return Val_bool(LLVMGetIntrinsicID(Fn));
   1136 }
   1137 
   1138 /* llvalue -> int */
   1139 CAMLprim value llvm_function_call_conv(LLVMValueRef Fn) {
   1140   return Val_int(LLVMGetFunctionCallConv(Fn));
   1141 }
   1142 
   1143 /* int -> llvalue -> unit */
   1144 CAMLprim value llvm_set_function_call_conv(value Id, LLVMValueRef Fn) {
   1145   LLVMSetFunctionCallConv(Fn, Int_val(Id));
   1146   return Val_unit;
   1147 }
   1148 
   1149 /* llvalue -> string option */
   1150 CAMLprim value llvm_gc(LLVMValueRef Fn) {
   1151   const char *GC;
   1152   CAMLparam0();
   1153   CAMLlocal2(Name, Option);
   1154 
   1155   if ((GC = LLVMGetGC(Fn))) {
   1156     Name = copy_string(GC);
   1157 
   1158     Option = alloc(1, 0);
   1159     Field(Option, 0) = Name;
   1160     CAMLreturn(Option);
   1161   } else {
   1162     CAMLreturn(Val_int(0));
   1163   }
   1164 }
   1165 
   1166 /* string option -> llvalue -> unit */
   1167 CAMLprim value llvm_set_gc(value GC, LLVMValueRef Fn) {
   1168   LLVMSetGC(Fn, GC == Val_int(0)? 0 : String_val(Field(GC, 0)));
   1169   return Val_unit;
   1170 }
   1171 
   1172 /* llvalue -> int32 -> unit */
   1173 CAMLprim value llvm_add_function_attr(LLVMValueRef Arg, value PA) {
   1174   LLVMAddFunctionAttr(Arg, Int32_val(PA));
   1175   return Val_unit;
   1176 }
   1177 
   1178 /* llvalue -> string -> string -> unit */
   1179 CAMLprim value llvm_add_target_dependent_function_attr(
   1180                   LLVMValueRef Arg, value A, value V) {
   1181   LLVMAddTargetDependentFunctionAttr(Arg, String_val(A), String_val(V));
   1182   return Val_unit;
   1183 }
   1184 
   1185 /* llvalue -> int32 */
   1186 CAMLprim value llvm_function_attr(LLVMValueRef Fn)
   1187 {
   1188     CAMLparam0();
   1189     CAMLreturn(caml_copy_int32(LLVMGetFunctionAttr(Fn)));
   1190 }
   1191 
   1192 /* llvalue -> int32 -> unit */
   1193 CAMLprim value llvm_remove_function_attr(LLVMValueRef Arg, value PA) {
   1194   LLVMRemoveFunctionAttr(Arg, Int32_val(PA));
   1195   return Val_unit;
   1196 }
   1197 /*--... Operations on parameters ...........................................--*/
   1198 
   1199 DEFINE_ITERATORS(param, Param, LLVMValueRef, LLVMValueRef, LLVMGetParamParent)
   1200 
   1201 /* llvalue -> int -> llvalue */
   1202 CAMLprim LLVMValueRef llvm_param(LLVMValueRef Fn, value Index) {
   1203   return LLVMGetParam(Fn, Int_val(Index));
   1204 }
   1205 
   1206 /* llvalue -> int */
   1207 CAMLprim value llvm_param_attr(LLVMValueRef Param)
   1208 {
   1209     CAMLparam0();
   1210     CAMLreturn(caml_copy_int32(LLVMGetAttribute(Param)));
   1211 }
   1212 
   1213 /* llvalue -> llvalue */
   1214 CAMLprim value llvm_params(LLVMValueRef Fn) {
   1215   value Params = alloc(LLVMCountParams(Fn), 0);
   1216   LLVMGetParams(Fn, (LLVMValueRef *) Op_val(Params));
   1217   return Params;
   1218 }
   1219 
   1220 /* llvalue -> int32 -> unit */
   1221 CAMLprim value llvm_add_param_attr(LLVMValueRef Arg, value PA) {
   1222   LLVMAddAttribute(Arg, Int32_val(PA));
   1223   return Val_unit;
   1224 }
   1225 
   1226 /* llvalue -> int32 -> unit */
   1227 CAMLprim value llvm_remove_param_attr(LLVMValueRef Arg, value PA) {
   1228   LLVMRemoveAttribute(Arg, Int32_val(PA));
   1229   return Val_unit;
   1230 }
   1231 
   1232 /* llvalue -> int -> unit */
   1233 CAMLprim value llvm_set_param_alignment(LLVMValueRef Arg, value align) {
   1234   LLVMSetParamAlignment(Arg, Int_val(align));
   1235   return Val_unit;
   1236 }
   1237 
   1238 /*--... Operations on basic blocks .........................................--*/
   1239 
   1240 DEFINE_ITERATORS(
   1241   block, BasicBlock, LLVMValueRef, LLVMBasicBlockRef, LLVMGetBasicBlockParent)
   1242 
   1243 /* llbasicblock -> llvalue option */
   1244 CAMLprim value llvm_block_terminator(LLVMBasicBlockRef Block)
   1245 {
   1246   CAMLparam0();
   1247   LLVMValueRef Term = LLVMGetBasicBlockTerminator(Block);
   1248   if (Term) {
   1249     value Option = alloc(1, 0);
   1250     Field(Option, 0) = (value) Term;
   1251     CAMLreturn(Option);
   1252   }
   1253   CAMLreturn(Val_int(0));
   1254 }
   1255 
   1256 /* llvalue -> llbasicblock array */
   1257 CAMLprim value llvm_basic_blocks(LLVMValueRef Fn) {
   1258   value MLArray = alloc(LLVMCountBasicBlocks(Fn), 0);
   1259   LLVMGetBasicBlocks(Fn, (LLVMBasicBlockRef *) Op_val(MLArray));
   1260   return MLArray;
   1261 }
   1262 
   1263 /* llbasicblock -> unit */
   1264 CAMLprim value llvm_delete_block(LLVMBasicBlockRef BB) {
   1265   LLVMDeleteBasicBlock(BB);
   1266   return Val_unit;
   1267 }
   1268 
   1269 /* llbasicblock -> unit */
   1270 CAMLprim value llvm_remove_block(LLVMBasicBlockRef BB) {
   1271   LLVMRemoveBasicBlockFromParent(BB);
   1272   return Val_unit;
   1273 }
   1274 
   1275 /* llbasicblock -> llbasicblock -> unit */
   1276 CAMLprim value llvm_move_block_before(LLVMBasicBlockRef Pos, LLVMBasicBlockRef BB) {
   1277   LLVMMoveBasicBlockBefore(BB, Pos);
   1278   return Val_unit;
   1279 }
   1280 
   1281 /* llbasicblock -> llbasicblock -> unit */
   1282 CAMLprim value llvm_move_block_after(LLVMBasicBlockRef Pos, LLVMBasicBlockRef BB) {
   1283   LLVMMoveBasicBlockAfter(BB, Pos);
   1284   return Val_unit;
   1285 }
   1286 
   1287 /* string -> llvalue -> llbasicblock */
   1288 CAMLprim LLVMBasicBlockRef llvm_append_block(LLVMContextRef Context, value Name,
   1289                                              LLVMValueRef Fn) {
   1290   return LLVMAppendBasicBlockInContext(Context, Fn, String_val(Name));
   1291 }
   1292 
   1293 /* string -> llbasicblock -> llbasicblock */
   1294 CAMLprim LLVMBasicBlockRef llvm_insert_block(LLVMContextRef Context, value Name,
   1295                                              LLVMBasicBlockRef BB) {
   1296   return LLVMInsertBasicBlockInContext(Context, BB, String_val(Name));
   1297 }
   1298 
   1299 /* llvalue -> bool */
   1300 CAMLprim value llvm_value_is_block(LLVMValueRef Val) {
   1301   return Val_bool(LLVMValueIsBasicBlock(Val));
   1302 }
   1303 
   1304 /*--... Operations on instructions .........................................--*/
   1305 
   1306 DEFINE_ITERATORS(instr, Instruction, LLVMBasicBlockRef, LLVMValueRef,
   1307                  LLVMGetInstructionParent)
   1308 
   1309 /* llvalue -> Opcode.t */
   1310 CAMLprim value llvm_instr_get_opcode(LLVMValueRef Inst) {
   1311   LLVMOpcode o;
   1312   if (!LLVMIsAInstruction(Inst))
   1313       failwith("Not an instruction");
   1314   o = LLVMGetInstructionOpcode(Inst);
   1315   assert (o <= LLVMLandingPad);
   1316   return Val_int(o);
   1317 }
   1318 
   1319 /* llvalue -> ICmp.t option */
   1320 CAMLprim value llvm_instr_icmp_predicate(LLVMValueRef Val) {
   1321   CAMLparam0();
   1322   int x = LLVMGetICmpPredicate(Val);
   1323   if (x) {
   1324     value Option = alloc(1, 0);
   1325     Field(Option, 0) = Val_int(x - LLVMIntEQ);
   1326     CAMLreturn(Option);
   1327   }
   1328   CAMLreturn(Val_int(0));
   1329 }
   1330 
   1331 
   1332 /*--... Operations on call sites ...........................................--*/
   1333 
   1334 /* llvalue -> int */
   1335 CAMLprim value llvm_instruction_call_conv(LLVMValueRef Inst) {
   1336   return Val_int(LLVMGetInstructionCallConv(Inst));
   1337 }
   1338 
   1339 /* int -> llvalue -> unit */
   1340 CAMLprim value llvm_set_instruction_call_conv(value CC, LLVMValueRef Inst) {
   1341   LLVMSetInstructionCallConv(Inst, Int_val(CC));
   1342   return Val_unit;
   1343 }
   1344 
   1345 /* llvalue -> int -> int32 -> unit */
   1346 CAMLprim value llvm_add_instruction_param_attr(LLVMValueRef Instr,
   1347                                                value index,
   1348                                                value PA) {
   1349   LLVMAddInstrAttribute(Instr, Int_val(index), Int32_val(PA));
   1350   return Val_unit;
   1351 }
   1352 
   1353 /* llvalue -> int -> int32 -> unit */
   1354 CAMLprim value llvm_remove_instruction_param_attr(LLVMValueRef Instr,
   1355                                                   value index,
   1356                                                   value PA) {
   1357   LLVMRemoveInstrAttribute(Instr, Int_val(index), Int32_val(PA));
   1358   return Val_unit;
   1359 }
   1360 
   1361 /*--... Operations on call instructions (only) .............................--*/
   1362 
   1363 /* llvalue -> bool */
   1364 CAMLprim value llvm_is_tail_call(LLVMValueRef CallInst) {
   1365   return Val_bool(LLVMIsTailCall(CallInst));
   1366 }
   1367 
   1368 /* bool -> llvalue -> unit */
   1369 CAMLprim value llvm_set_tail_call(value IsTailCall,
   1370                                   LLVMValueRef CallInst) {
   1371   LLVMSetTailCall(CallInst, Bool_val(IsTailCall));
   1372   return Val_unit;
   1373 }
   1374 
   1375 /*--... Operations on load/store instructions (only)........................--*/
   1376 
   1377 /* llvalue -> bool */
   1378 CAMLprim value llvm_is_volatile(LLVMValueRef MemoryInst) {
   1379   return Val_bool(LLVMGetVolatile(MemoryInst));
   1380 }
   1381 
   1382 /* bool -> llvalue -> unit */
   1383 CAMLprim value llvm_set_volatile(value IsVolatile,
   1384                                   LLVMValueRef MemoryInst) {
   1385   LLVMSetVolatile(MemoryInst, Bool_val(IsVolatile));
   1386   return Val_unit;
   1387 }
   1388 
   1389 /*--... Operations on phi nodes ............................................--*/
   1390 
   1391 /* (llvalue * llbasicblock) -> llvalue -> unit */
   1392 CAMLprim value llvm_add_incoming(value Incoming, LLVMValueRef PhiNode) {
   1393   LLVMAddIncoming(PhiNode,
   1394                   (LLVMValueRef*) &Field(Incoming, 0),
   1395                   (LLVMBasicBlockRef*) &Field(Incoming, 1),
   1396                   1);
   1397   return Val_unit;
   1398 }
   1399 
   1400 /* llvalue -> (llvalue * llbasicblock) list */
   1401 CAMLprim value llvm_incoming(LLVMValueRef PhiNode) {
   1402   unsigned I;
   1403   CAMLparam0();
   1404   CAMLlocal3(Hd, Tl, Tmp);
   1405 
   1406   /* Build a tuple list of them. */
   1407   Tl = Val_int(0);
   1408   for (I = LLVMCountIncoming(PhiNode); I != 0; ) {
   1409     Hd = alloc(2, 0);
   1410     Store_field(Hd, 0, (value) LLVMGetIncomingValue(PhiNode, --I));
   1411     Store_field(Hd, 1, (value) LLVMGetIncomingBlock(PhiNode, I));
   1412 
   1413     Tmp = alloc(2, 0);
   1414     Store_field(Tmp, 0, Hd);
   1415     Store_field(Tmp, 1, Tl);
   1416     Tl = Tmp;
   1417   }
   1418 
   1419   CAMLreturn(Tl);
   1420 }
   1421 
   1422 /* llvalue -> unit */
   1423 CAMLprim value llvm_delete_instruction(LLVMValueRef Instruction) {
   1424   LLVMInstructionEraseFromParent(Instruction);
   1425   return Val_unit;
   1426 }
   1427 
   1428 /*===-- Instruction builders ----------------------------------------------===*/
   1429 
   1430 #define Builder_val(v)  (*(LLVMBuilderRef *)(Data_custom_val(v)))
   1431 
   1432 static void llvm_finalize_builder(value B) {
   1433   LLVMDisposeBuilder(Builder_val(B));
   1434 }
   1435 
   1436 static struct custom_operations builder_ops = {
   1437   (char *) "LLVMIRBuilder",
   1438   llvm_finalize_builder,
   1439   custom_compare_default,
   1440   custom_hash_default,
   1441   custom_serialize_default,
   1442   custom_deserialize_default
   1443 #ifdef custom_compare_ext_default
   1444   , custom_compare_ext_default
   1445 #endif
   1446 };
   1447 
   1448 static value alloc_builder(LLVMBuilderRef B) {
   1449   value V = alloc_custom(&builder_ops, sizeof(LLVMBuilderRef), 0, 1);
   1450   Builder_val(V) = B;
   1451   return V;
   1452 }
   1453 
   1454 /* llcontext -> llbuilder */
   1455 CAMLprim value llvm_builder(LLVMContextRef C) {
   1456   return alloc_builder(LLVMCreateBuilderInContext(C));
   1457 }
   1458 
   1459 /* (llbasicblock, llvalue) llpos -> llbuilder -> unit */
   1460 CAMLprim value llvm_position_builder(value Pos, value B) {
   1461   if (Tag_val(Pos) == 0) {
   1462     LLVMBasicBlockRef BB = (LLVMBasicBlockRef) Op_val(Field(Pos, 0));
   1463     LLVMPositionBuilderAtEnd(Builder_val(B), BB);
   1464   } else {
   1465     LLVMValueRef I = (LLVMValueRef) Op_val(Field(Pos, 0));
   1466     LLVMPositionBuilderBefore(Builder_val(B), I);
   1467   }
   1468   return Val_unit;
   1469 }
   1470 
   1471 /* llbuilder -> llbasicblock */
   1472 CAMLprim LLVMBasicBlockRef llvm_insertion_block(value B) {
   1473   LLVMBasicBlockRef InsertBlock = LLVMGetInsertBlock(Builder_val(B));
   1474   if (!InsertBlock)
   1475     raise_not_found();
   1476   return InsertBlock;
   1477 }
   1478 
   1479 /* llvalue -> string -> llbuilder -> unit */
   1480 CAMLprim value llvm_insert_into_builder(LLVMValueRef I, value Name, value B) {
   1481   LLVMInsertIntoBuilderWithName(Builder_val(B), I, String_val(Name));
   1482   return Val_unit;
   1483 }
   1484 
   1485 /*--... Metadata ...........................................................--*/
   1486 
   1487 /* llbuilder -> llvalue -> unit */
   1488 CAMLprim value llvm_set_current_debug_location(value B, LLVMValueRef V) {
   1489   LLVMSetCurrentDebugLocation(Builder_val(B), V);
   1490   return Val_unit;
   1491 }
   1492 
   1493 /* llbuilder -> unit */
   1494 CAMLprim value llvm_clear_current_debug_location(value B) {
   1495   LLVMSetCurrentDebugLocation(Builder_val(B), NULL);
   1496   return Val_unit;
   1497 }
   1498 
   1499 /* llbuilder -> llvalue option */
   1500 CAMLprim value llvm_current_debug_location(value B) {
   1501   CAMLparam0();
   1502   LLVMValueRef L;
   1503   if ((L = LLVMGetCurrentDebugLocation(Builder_val(B)))) {
   1504     value Option = alloc(1, 0);
   1505     Field(Option, 0) = (value) L;
   1506     CAMLreturn(Option);
   1507   }
   1508   CAMLreturn(Val_int(0));
   1509 }
   1510 
   1511 /* llbuilder -> llvalue -> unit */
   1512 CAMLprim value llvm_set_inst_debug_location(value B, LLVMValueRef V) {
   1513   LLVMSetInstDebugLocation(Builder_val(B), V);
   1514   return Val_unit;
   1515 }
   1516 
   1517 
   1518 /*--... Terminators ........................................................--*/
   1519 
   1520 /* llbuilder -> llvalue */
   1521 CAMLprim LLVMValueRef llvm_build_ret_void(value B) {
   1522   return LLVMBuildRetVoid(Builder_val(B));
   1523 }
   1524 
   1525 /* llvalue -> llbuilder -> llvalue */
   1526 CAMLprim LLVMValueRef llvm_build_ret(LLVMValueRef Val, value B) {
   1527   return LLVMBuildRet(Builder_val(B), Val);
   1528 }
   1529 
   1530 /* llvalue array -> llbuilder -> llvalue */
   1531 CAMLprim LLVMValueRef llvm_build_aggregate_ret(value RetVals, value B) {
   1532   return LLVMBuildAggregateRet(Builder_val(B), (LLVMValueRef *) Op_val(RetVals),
   1533                                Wosize_val(RetVals));
   1534 }
   1535 
   1536 /* llbasicblock -> llbuilder -> llvalue */
   1537 CAMLprim LLVMValueRef llvm_build_br(LLVMBasicBlockRef BB, value B) {
   1538   return LLVMBuildBr(Builder_val(B), BB);
   1539 }
   1540 
   1541 /* llvalue -> llbasicblock -> llbasicblock -> llbuilder -> llvalue */
   1542 CAMLprim LLVMValueRef llvm_build_cond_br(LLVMValueRef If,
   1543                                          LLVMBasicBlockRef Then,
   1544                                          LLVMBasicBlockRef Else,
   1545                                          value B) {
   1546   return LLVMBuildCondBr(Builder_val(B), If, Then, Else);
   1547 }
   1548 
   1549 /* llvalue -> llbasicblock -> int -> llbuilder -> llvalue */
   1550 CAMLprim LLVMValueRef llvm_build_switch(LLVMValueRef Of,
   1551                                         LLVMBasicBlockRef Else,
   1552                                         value EstimatedCount,
   1553                                         value B) {
   1554   return LLVMBuildSwitch(Builder_val(B), Of, Else, Int_val(EstimatedCount));
   1555 }
   1556 
   1557 /* lltype -> string -> llbuilder -> llvalue */
   1558 CAMLprim LLVMValueRef llvm_build_malloc(LLVMTypeRef Ty, value Name,
   1559                                         value B)
   1560 {
   1561   return LLVMBuildMalloc(Builder_val(B), Ty, String_val(Name));
   1562 }
   1563 
   1564 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
   1565 CAMLprim LLVMValueRef llvm_build_array_malloc(LLVMTypeRef Ty,
   1566                                               LLVMValueRef Val,
   1567                                               value Name, value B)
   1568 {
   1569   return LLVMBuildArrayMalloc(Builder_val(B), Ty, Val, String_val(Name));
   1570 }
   1571 
   1572 /* llvalue -> llbuilder -> llvalue */
   1573 CAMLprim LLVMValueRef llvm_build_free(LLVMValueRef P, value B)
   1574 {
   1575   return LLVMBuildFree(Builder_val(B), P);
   1576 }
   1577 
   1578 /* llvalue -> llvalue -> llbasicblock -> unit */
   1579 CAMLprim value llvm_add_case(LLVMValueRef Switch, LLVMValueRef OnVal,
   1580                              LLVMBasicBlockRef Dest) {
   1581   LLVMAddCase(Switch, OnVal, Dest);
   1582   return Val_unit;
   1583 }
   1584 
   1585 /* llvalue -> llbasicblock -> llbuilder -> llvalue */
   1586 CAMLprim LLVMValueRef llvm_build_indirect_br(LLVMValueRef Addr,
   1587                                              value EstimatedDests,
   1588                                              value B) {
   1589   return LLVMBuildIndirectBr(Builder_val(B), Addr, EstimatedDests);
   1590 }
   1591 
   1592 /* llvalue -> llvalue -> llbasicblock -> unit */
   1593 CAMLprim value llvm_add_destination(LLVMValueRef IndirectBr,
   1594                                     LLVMBasicBlockRef Dest) {
   1595   LLVMAddDestination(IndirectBr, Dest);
   1596   return Val_unit;
   1597 }
   1598 
   1599 /* llvalue -> llvalue array -> llbasicblock -> llbasicblock -> string ->
   1600    llbuilder -> llvalue */
   1601 CAMLprim LLVMValueRef llvm_build_invoke_nat(LLVMValueRef Fn, value Args,
   1602                                             LLVMBasicBlockRef Then,
   1603                                             LLVMBasicBlockRef Catch,
   1604                                             value Name, value B) {
   1605   return LLVMBuildInvoke(Builder_val(B), Fn, (LLVMValueRef *) Op_val(Args),
   1606                          Wosize_val(Args), Then, Catch, String_val(Name));
   1607 }
   1608 
   1609 /* llvalue -> llvalue array -> llbasicblock -> llbasicblock -> string ->
   1610    llbuilder -> llvalue */
   1611 CAMLprim LLVMValueRef llvm_build_invoke_bc(value Args[], int NumArgs) {
   1612   return llvm_build_invoke_nat((LLVMValueRef) Args[0], Args[1],
   1613                                (LLVMBasicBlockRef) Args[2],
   1614                                (LLVMBasicBlockRef) Args[3],
   1615                                Args[4], Args[5]);
   1616 }
   1617 
   1618 /* lltype -> llvalue -> int -> string -> llbuilder -> llvalue */
   1619 CAMLprim LLVMValueRef llvm_build_landingpad(LLVMTypeRef Ty, LLVMValueRef PersFn,
   1620                                             value NumClauses,  value Name,
   1621                                             value B) {
   1622     return LLVMBuildLandingPad(Builder_val(B), Ty, PersFn, Int_val(NumClauses),
   1623                                String_val(Name));
   1624 }
   1625 
   1626 /* llvalue -> llvalue -> unit */
   1627 CAMLprim value llvm_add_clause(LLVMValueRef LandingPadInst, LLVMValueRef ClauseVal)
   1628 {
   1629     LLVMAddClause(LandingPadInst, ClauseVal);
   1630     return Val_unit;
   1631 }
   1632 
   1633 
   1634 /* llvalue -> bool -> unit */
   1635 CAMLprim value llvm_set_cleanup(LLVMValueRef LandingPadInst, value flag)
   1636 {
   1637     LLVMSetCleanup(LandingPadInst, Bool_val(flag));
   1638     return Val_unit;
   1639 }
   1640 
   1641 /* llvalue -> llbuilder -> llvalue */
   1642 CAMLprim LLVMValueRef llvm_build_resume(LLVMValueRef Exn, value B)
   1643 {
   1644     return LLVMBuildResume(Builder_val(B), Exn);
   1645 }
   1646 
   1647 /* llbuilder -> llvalue */
   1648 CAMLprim LLVMValueRef llvm_build_unreachable(value B) {
   1649   return LLVMBuildUnreachable(Builder_val(B));
   1650 }
   1651 
   1652 /*--... Arithmetic .........................................................--*/
   1653 
   1654 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1655 CAMLprim LLVMValueRef llvm_build_add(LLVMValueRef LHS, LLVMValueRef RHS,
   1656                                      value Name, value B) {
   1657   return LLVMBuildAdd(Builder_val(B), LHS, RHS, String_val(Name));
   1658 }
   1659 
   1660 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1661 CAMLprim LLVMValueRef llvm_build_nsw_add(LLVMValueRef LHS, LLVMValueRef RHS,
   1662                                          value Name, value B) {
   1663   return LLVMBuildNSWAdd(Builder_val(B), LHS, RHS, String_val(Name));
   1664 }
   1665 
   1666 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1667 CAMLprim LLVMValueRef llvm_build_nuw_add(LLVMValueRef LHS, LLVMValueRef RHS,
   1668                                          value Name, value B) {
   1669   return LLVMBuildNUWAdd(Builder_val(B), LHS, RHS, String_val(Name));
   1670 }
   1671 
   1672 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1673 CAMLprim LLVMValueRef llvm_build_fadd(LLVMValueRef LHS, LLVMValueRef RHS,
   1674                                       value Name, value B) {
   1675   return LLVMBuildFAdd(Builder_val(B), LHS, RHS, String_val(Name));
   1676 }
   1677 
   1678 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1679 CAMLprim LLVMValueRef llvm_build_sub(LLVMValueRef LHS, LLVMValueRef RHS,
   1680                                      value Name, value B) {
   1681   return LLVMBuildSub(Builder_val(B), LHS, RHS, String_val(Name));
   1682 }
   1683 
   1684 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1685 CAMLprim LLVMValueRef llvm_build_nsw_sub(LLVMValueRef LHS, LLVMValueRef RHS,
   1686                                          value Name, value B) {
   1687   return LLVMBuildNSWSub(Builder_val(B), LHS, RHS, String_val(Name));
   1688 }
   1689 
   1690 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1691 CAMLprim LLVMValueRef llvm_build_nuw_sub(LLVMValueRef LHS, LLVMValueRef RHS,
   1692                                          value Name, value B) {
   1693   return LLVMBuildNUWSub(Builder_val(B), LHS, RHS, String_val(Name));
   1694 }
   1695 
   1696 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1697 CAMLprim LLVMValueRef llvm_build_fsub(LLVMValueRef LHS, LLVMValueRef RHS,
   1698                                       value Name, value B) {
   1699   return LLVMBuildFSub(Builder_val(B), LHS, RHS, String_val(Name));
   1700 }
   1701 
   1702 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1703 CAMLprim LLVMValueRef llvm_build_mul(LLVMValueRef LHS, LLVMValueRef RHS,
   1704                                      value Name, value B) {
   1705   return LLVMBuildMul(Builder_val(B), LHS, RHS, String_val(Name));
   1706 }
   1707 
   1708 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1709 CAMLprim LLVMValueRef llvm_build_nsw_mul(LLVMValueRef LHS, LLVMValueRef RHS,
   1710                                          value Name, value B) {
   1711   return LLVMBuildNSWMul(Builder_val(B), LHS, RHS, String_val(Name));
   1712 }
   1713 
   1714 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1715 CAMLprim LLVMValueRef llvm_build_nuw_mul(LLVMValueRef LHS, LLVMValueRef RHS,
   1716                                          value Name, value B) {
   1717   return LLVMBuildNUWMul(Builder_val(B), LHS, RHS, String_val(Name));
   1718 }
   1719 
   1720 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1721 CAMLprim LLVMValueRef llvm_build_fmul(LLVMValueRef LHS, LLVMValueRef RHS,
   1722                                       value Name, value B) {
   1723   return LLVMBuildFMul(Builder_val(B), LHS, RHS, String_val(Name));
   1724 }
   1725 
   1726 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1727 CAMLprim LLVMValueRef llvm_build_udiv(LLVMValueRef LHS, LLVMValueRef RHS,
   1728                                       value Name, value B) {
   1729   return LLVMBuildUDiv(Builder_val(B), LHS, RHS, String_val(Name));
   1730 }
   1731 
   1732 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1733 CAMLprim LLVMValueRef llvm_build_sdiv(LLVMValueRef LHS, LLVMValueRef RHS,
   1734                                       value Name, value B) {
   1735   return LLVMBuildSDiv(Builder_val(B), LHS, RHS, String_val(Name));
   1736 }
   1737 
   1738 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1739 CAMLprim LLVMValueRef llvm_build_exact_sdiv(LLVMValueRef LHS, LLVMValueRef RHS,
   1740                                             value Name, value B) {
   1741   return LLVMBuildExactSDiv(Builder_val(B), LHS, RHS, String_val(Name));
   1742 }
   1743 
   1744 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1745 CAMLprim LLVMValueRef llvm_build_fdiv(LLVMValueRef LHS, LLVMValueRef RHS,
   1746                                       value Name, value B) {
   1747   return LLVMBuildFDiv(Builder_val(B), LHS, RHS, String_val(Name));
   1748 }
   1749 
   1750 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1751 CAMLprim LLVMValueRef llvm_build_urem(LLVMValueRef LHS, LLVMValueRef RHS,
   1752                                       value Name, value B) {
   1753   return LLVMBuildURem(Builder_val(B), LHS, RHS, String_val(Name));
   1754 }
   1755 
   1756 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1757 CAMLprim LLVMValueRef llvm_build_srem(LLVMValueRef LHS, LLVMValueRef RHS,
   1758                                       value Name, value B) {
   1759   return LLVMBuildSRem(Builder_val(B), LHS, RHS, String_val(Name));
   1760 }
   1761 
   1762 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1763 CAMLprim LLVMValueRef llvm_build_frem(LLVMValueRef LHS, LLVMValueRef RHS,
   1764                                       value Name, value B) {
   1765   return LLVMBuildFRem(Builder_val(B), LHS, RHS, String_val(Name));
   1766 }
   1767 
   1768 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1769 CAMLprim LLVMValueRef llvm_build_shl(LLVMValueRef LHS, LLVMValueRef RHS,
   1770                                      value Name, value B) {
   1771   return LLVMBuildShl(Builder_val(B), LHS, RHS, String_val(Name));
   1772 }
   1773 
   1774 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1775 CAMLprim LLVMValueRef llvm_build_lshr(LLVMValueRef LHS, LLVMValueRef RHS,
   1776                                       value Name, value B) {
   1777   return LLVMBuildLShr(Builder_val(B), LHS, RHS, String_val(Name));
   1778 }
   1779 
   1780 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1781 CAMLprim LLVMValueRef llvm_build_ashr(LLVMValueRef LHS, LLVMValueRef RHS,
   1782                                       value Name, value B) {
   1783   return LLVMBuildAShr(Builder_val(B), LHS, RHS, String_val(Name));
   1784 }
   1785 
   1786 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1787 CAMLprim LLVMValueRef llvm_build_and(LLVMValueRef LHS, LLVMValueRef RHS,
   1788                                      value Name, value B) {
   1789   return LLVMBuildAnd(Builder_val(B), LHS, RHS, String_val(Name));
   1790 }
   1791 
   1792 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1793 CAMLprim LLVMValueRef llvm_build_or(LLVMValueRef LHS, LLVMValueRef RHS,
   1794                                     value Name, value B) {
   1795   return LLVMBuildOr(Builder_val(B), LHS, RHS, String_val(Name));
   1796 }
   1797 
   1798 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   1799 CAMLprim LLVMValueRef llvm_build_xor(LLVMValueRef LHS, LLVMValueRef RHS,
   1800                                      value Name, value B) {
   1801   return LLVMBuildXor(Builder_val(B), LHS, RHS, String_val(Name));
   1802 }
   1803 
   1804 /* llvalue -> string -> llbuilder -> llvalue */
   1805 CAMLprim LLVMValueRef llvm_build_neg(LLVMValueRef X,
   1806                                      value Name, value B) {
   1807   return LLVMBuildNeg(Builder_val(B), X, String_val(Name));
   1808 }
   1809 
   1810 /* llvalue -> string -> llbuilder -> llvalue */
   1811 CAMLprim LLVMValueRef llvm_build_nsw_neg(LLVMValueRef X,
   1812                                          value Name, value B) {
   1813   return LLVMBuildNSWNeg(Builder_val(B), X, String_val(Name));
   1814 }
   1815 
   1816 /* llvalue -> string -> llbuilder -> llvalue */
   1817 CAMLprim LLVMValueRef llvm_build_nuw_neg(LLVMValueRef X,
   1818                                          value Name, value B) {
   1819   return LLVMBuildNUWNeg(Builder_val(B), X, String_val(Name));
   1820 }
   1821 
   1822 /* llvalue -> string -> llbuilder -> llvalue */
   1823 CAMLprim LLVMValueRef llvm_build_fneg(LLVMValueRef X,
   1824                                      value Name, value B) {
   1825   return LLVMBuildFNeg(Builder_val(B), X, String_val(Name));
   1826 }
   1827 
   1828 /* llvalue -> string -> llbuilder -> llvalue */
   1829 CAMLprim LLVMValueRef llvm_build_not(LLVMValueRef X,
   1830                                      value Name, value B) {
   1831   return LLVMBuildNot(Builder_val(B), X, String_val(Name));
   1832 }
   1833 
   1834 /*--... Memory .............................................................--*/
   1835 
   1836 /* lltype -> string -> llbuilder -> llvalue */
   1837 CAMLprim LLVMValueRef llvm_build_alloca(LLVMTypeRef Ty,
   1838                                         value Name, value B) {
   1839   return LLVMBuildAlloca(Builder_val(B), Ty, String_val(Name));
   1840 }
   1841 
   1842 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
   1843 CAMLprim LLVMValueRef llvm_build_array_alloca(LLVMTypeRef Ty, LLVMValueRef Size,
   1844                                               value Name, value B) {
   1845   return LLVMBuildArrayAlloca(Builder_val(B), Ty, Size, String_val(Name));
   1846 }
   1847 
   1848 /* llvalue -> string -> llbuilder -> llvalue */
   1849 CAMLprim LLVMValueRef llvm_build_load(LLVMValueRef Pointer,
   1850                                       value Name, value B) {
   1851   return LLVMBuildLoad(Builder_val(B), Pointer, String_val(Name));
   1852 }
   1853 
   1854 /* llvalue -> llvalue -> llbuilder -> llvalue */
   1855 CAMLprim LLVMValueRef llvm_build_store(LLVMValueRef Value, LLVMValueRef Pointer,
   1856                                        value B) {
   1857   return LLVMBuildStore(Builder_val(B), Value, Pointer);
   1858 }
   1859 
   1860 /* AtomicRMWBinOp.t -> llvalue -> llvalue -> AtomicOrdering.t ->
   1861    bool -> llbuilder -> llvalue */
   1862 CAMLprim LLVMValueRef llvm_build_atomicrmw_native(value BinOp, LLVMValueRef Ptr,
   1863                                                   LLVMValueRef Val, value Ord,
   1864                                                   value ST, value Name, value B) {
   1865   LLVMValueRef Instr;
   1866   Instr = LLVMBuildAtomicRMW(Builder_val(B), Int_val(BinOp),
   1867                              Ptr, Val, Int_val(Ord), Bool_val(ST));
   1868   LLVMSetValueName(Instr, String_val(Name));
   1869   return Instr;
   1870 }
   1871 
   1872 CAMLprim LLVMValueRef llvm_build_atomicrmw_bytecode(value *argv, int argn) {
   1873   return llvm_build_atomicrmw_native(argv[0], (LLVMValueRef) argv[1],
   1874                                      (LLVMValueRef) argv[2], argv[3],
   1875                                      argv[4], argv[5], argv[6]);
   1876 }
   1877 
   1878 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
   1879 CAMLprim LLVMValueRef llvm_build_gep(LLVMValueRef Pointer, value Indices,
   1880                                      value Name, value B) {
   1881   return LLVMBuildGEP(Builder_val(B), Pointer,
   1882                       (LLVMValueRef *) Op_val(Indices), Wosize_val(Indices),
   1883                       String_val(Name));
   1884 }
   1885 
   1886 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
   1887 CAMLprim LLVMValueRef llvm_build_in_bounds_gep(LLVMValueRef Pointer,
   1888                                                value Indices, value Name,
   1889                                                value B) {
   1890   return LLVMBuildInBoundsGEP(Builder_val(B), Pointer,
   1891                               (LLVMValueRef *) Op_val(Indices),
   1892                               Wosize_val(Indices), String_val(Name));
   1893 }
   1894 
   1895 /* llvalue -> int -> string -> llbuilder -> llvalue */
   1896 CAMLprim LLVMValueRef llvm_build_struct_gep(LLVMValueRef Pointer,
   1897                                                value Index, value Name,
   1898                                                value B) {
   1899   return LLVMBuildStructGEP(Builder_val(B), Pointer,
   1900                               Int_val(Index), String_val(Name));
   1901 }
   1902 
   1903 /* string -> string -> llbuilder -> llvalue */
   1904 CAMLprim LLVMValueRef llvm_build_global_string(value Str, value Name, value B) {
   1905   return LLVMBuildGlobalString(Builder_val(B), String_val(Str),
   1906                                String_val(Name));
   1907 }
   1908 
   1909 /* string -> string -> llbuilder -> llvalue */
   1910 CAMLprim LLVMValueRef llvm_build_global_stringptr(value Str, value Name,
   1911                                                   value B) {
   1912   return LLVMBuildGlobalStringPtr(Builder_val(B), String_val(Str),
   1913                                   String_val(Name));
   1914 }
   1915 
   1916 /*--... Casts ..............................................................--*/
   1917 
   1918 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1919 CAMLprim LLVMValueRef llvm_build_trunc(LLVMValueRef X, LLVMTypeRef Ty,
   1920                                        value Name, value B) {
   1921   return LLVMBuildTrunc(Builder_val(B), X, Ty, String_val(Name));
   1922 }
   1923 
   1924 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1925 CAMLprim LLVMValueRef llvm_build_zext(LLVMValueRef X, LLVMTypeRef Ty,
   1926                                       value Name, value B) {
   1927   return LLVMBuildZExt(Builder_val(B), X, Ty, String_val(Name));
   1928 }
   1929 
   1930 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1931 CAMLprim LLVMValueRef llvm_build_sext(LLVMValueRef X, LLVMTypeRef Ty,
   1932                                       value Name, value B) {
   1933   return LLVMBuildSExt(Builder_val(B), X, Ty, String_val(Name));
   1934 }
   1935 
   1936 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1937 CAMLprim LLVMValueRef llvm_build_fptoui(LLVMValueRef X, LLVMTypeRef Ty,
   1938                                         value Name, value B) {
   1939   return LLVMBuildFPToUI(Builder_val(B), X, Ty, String_val(Name));
   1940 }
   1941 
   1942 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1943 CAMLprim LLVMValueRef llvm_build_fptosi(LLVMValueRef X, LLVMTypeRef Ty,
   1944                                         value Name, value B) {
   1945   return LLVMBuildFPToSI(Builder_val(B), X, Ty, String_val(Name));
   1946 }
   1947 
   1948 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1949 CAMLprim LLVMValueRef llvm_build_uitofp(LLVMValueRef X, LLVMTypeRef Ty,
   1950                                         value Name, value B) {
   1951   return LLVMBuildUIToFP(Builder_val(B), X, Ty, String_val(Name));
   1952 }
   1953 
   1954 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1955 CAMLprim LLVMValueRef llvm_build_sitofp(LLVMValueRef X, LLVMTypeRef Ty,
   1956                                         value Name, value B) {
   1957   return LLVMBuildSIToFP(Builder_val(B), X, Ty, String_val(Name));
   1958 }
   1959 
   1960 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1961 CAMLprim LLVMValueRef llvm_build_fptrunc(LLVMValueRef X, LLVMTypeRef Ty,
   1962                                          value Name, value B) {
   1963   return LLVMBuildFPTrunc(Builder_val(B), X, Ty, String_val(Name));
   1964 }
   1965 
   1966 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1967 CAMLprim LLVMValueRef llvm_build_fpext(LLVMValueRef X, LLVMTypeRef Ty,
   1968                                        value Name, value B) {
   1969   return LLVMBuildFPExt(Builder_val(B), X, Ty, String_val(Name));
   1970 }
   1971 
   1972 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1973 CAMLprim LLVMValueRef llvm_build_prttoint(LLVMValueRef X, LLVMTypeRef Ty,
   1974                                           value Name, value B) {
   1975   return LLVMBuildPtrToInt(Builder_val(B), X, Ty, String_val(Name));
   1976 }
   1977 
   1978 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1979 CAMLprim LLVMValueRef llvm_build_inttoptr(LLVMValueRef X, LLVMTypeRef Ty,
   1980                                           value Name, value B) {
   1981   return LLVMBuildIntToPtr(Builder_val(B), X, Ty, String_val(Name));
   1982 }
   1983 
   1984 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1985 CAMLprim LLVMValueRef llvm_build_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
   1986                                          value Name, value B) {
   1987   return LLVMBuildBitCast(Builder_val(B), X, Ty, String_val(Name));
   1988 }
   1989 
   1990 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1991 CAMLprim LLVMValueRef llvm_build_zext_or_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
   1992                                                  value Name, value B) {
   1993   return LLVMBuildZExtOrBitCast(Builder_val(B), X, Ty, String_val(Name));
   1994 }
   1995 
   1996 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   1997 CAMLprim LLVMValueRef llvm_build_sext_or_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
   1998                                                  value Name, value B) {
   1999   return LLVMBuildSExtOrBitCast(Builder_val(B), X, Ty, String_val(Name));
   2000 }
   2001 
   2002 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   2003 CAMLprim LLVMValueRef llvm_build_trunc_or_bitcast(LLVMValueRef X,
   2004                                                   LLVMTypeRef Ty, value Name,
   2005                                                   value B) {
   2006   return LLVMBuildTruncOrBitCast(Builder_val(B), X, Ty, String_val(Name));
   2007 }
   2008 
   2009 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   2010 CAMLprim LLVMValueRef llvm_build_pointercast(LLVMValueRef X, LLVMTypeRef Ty,
   2011                                              value Name, value B) {
   2012   return LLVMBuildPointerCast(Builder_val(B), X, Ty, String_val(Name));
   2013 }
   2014 
   2015 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   2016 CAMLprim LLVMValueRef llvm_build_intcast(LLVMValueRef X, LLVMTypeRef Ty,
   2017                                          value Name, value B) {
   2018   return LLVMBuildIntCast(Builder_val(B), X, Ty, String_val(Name));
   2019 }
   2020 
   2021 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   2022 CAMLprim LLVMValueRef llvm_build_fpcast(LLVMValueRef X, LLVMTypeRef Ty,
   2023                                         value Name, value B) {
   2024   return LLVMBuildFPCast(Builder_val(B), X, Ty, String_val(Name));
   2025 }
   2026 
   2027 /*--... Comparisons ........................................................--*/
   2028 
   2029 /* Icmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
   2030 CAMLprim LLVMValueRef llvm_build_icmp(value Pred,
   2031                                       LLVMValueRef LHS, LLVMValueRef RHS,
   2032                                       value Name, value B) {
   2033   return LLVMBuildICmp(Builder_val(B), Int_val(Pred) + LLVMIntEQ, LHS, RHS,
   2034                        String_val(Name));
   2035 }
   2036 
   2037 /* Fcmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
   2038 CAMLprim LLVMValueRef llvm_build_fcmp(value Pred,
   2039                                       LLVMValueRef LHS, LLVMValueRef RHS,
   2040                                       value Name, value B) {
   2041   return LLVMBuildFCmp(Builder_val(B), Int_val(Pred), LHS, RHS,
   2042                        String_val(Name));
   2043 }
   2044 
   2045 /*--... Miscellaneous instructions .........................................--*/
   2046 
   2047 /* (llvalue * llbasicblock) list -> string -> llbuilder -> llvalue */
   2048 CAMLprim LLVMValueRef llvm_build_phi(value Incoming, value Name, value B) {
   2049   value Hd, Tl;
   2050   LLVMValueRef FirstValue, PhiNode;
   2051 
   2052   assert(Incoming != Val_int(0) && "Empty list passed to Llvm.build_phi!");
   2053 
   2054   Hd = Field(Incoming, 0);
   2055   FirstValue = (LLVMValueRef) Field(Hd, 0);
   2056   PhiNode = LLVMBuildPhi(Builder_val(B), LLVMTypeOf(FirstValue),
   2057                          String_val(Name));
   2058 
   2059   for (Tl = Incoming; Tl != Val_int(0); Tl = Field(Tl, 1)) {
   2060     value Hd = Field(Tl, 0);
   2061     LLVMAddIncoming(PhiNode, (LLVMValueRef*) &Field(Hd, 0),
   2062                     (LLVMBasicBlockRef*) &Field(Hd, 1), 1);
   2063   }
   2064 
   2065   return PhiNode;
   2066 }
   2067 
   2068 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
   2069 CAMLprim LLVMValueRef llvm_build_call(LLVMValueRef Fn, value Params,
   2070                                       value Name, value B) {
   2071   return LLVMBuildCall(Builder_val(B), Fn, (LLVMValueRef *) Op_val(Params),
   2072                        Wosize_val(Params), String_val(Name));
   2073 }
   2074 
   2075 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
   2076 CAMLprim LLVMValueRef llvm_build_select(LLVMValueRef If,
   2077                                         LLVMValueRef Then, LLVMValueRef Else,
   2078                                         value Name, value B) {
   2079   return LLVMBuildSelect(Builder_val(B), If, Then, Else, String_val(Name));
   2080 }
   2081 
   2082 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
   2083 CAMLprim LLVMValueRef llvm_build_va_arg(LLVMValueRef List, LLVMTypeRef Ty,
   2084                                         value Name, value B) {
   2085   return LLVMBuildVAArg(Builder_val(B), List, Ty, String_val(Name));
   2086 }
   2087 
   2088 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   2089 CAMLprim LLVMValueRef llvm_build_extractelement(LLVMValueRef Vec,
   2090                                                 LLVMValueRef Idx,
   2091                                                 value Name, value B) {
   2092   return LLVMBuildExtractElement(Builder_val(B), Vec, Idx, String_val(Name));
   2093 }
   2094 
   2095 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
   2096 CAMLprim LLVMValueRef llvm_build_insertelement(LLVMValueRef Vec,
   2097                                                LLVMValueRef Element,
   2098                                                LLVMValueRef Idx,
   2099                                                value Name, value B) {
   2100   return LLVMBuildInsertElement(Builder_val(B), Vec, Element, Idx,
   2101                                 String_val(Name));
   2102 }
   2103 
   2104 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
   2105 CAMLprim LLVMValueRef llvm_build_shufflevector(LLVMValueRef V1, LLVMValueRef V2,
   2106                                                LLVMValueRef Mask,
   2107                                                value Name, value B) {
   2108   return LLVMBuildShuffleVector(Builder_val(B), V1, V2, Mask, String_val(Name));
   2109 }
   2110 
   2111 /* llvalue -> int -> string -> llbuilder -> llvalue */
   2112 CAMLprim LLVMValueRef llvm_build_extractvalue(LLVMValueRef Aggregate,
   2113                                               value Idx, value Name, value B) {
   2114   return LLVMBuildExtractValue(Builder_val(B), Aggregate, Int_val(Idx),
   2115                                String_val(Name));
   2116 }
   2117 
   2118 /* llvalue -> llvalue -> int -> string -> llbuilder -> llvalue */
   2119 CAMLprim LLVMValueRef llvm_build_insertvalue(LLVMValueRef Aggregate,
   2120                                              LLVMValueRef Val, value Idx,
   2121                                              value Name, value B) {
   2122   return LLVMBuildInsertValue(Builder_val(B), Aggregate, Val, Int_val(Idx),
   2123                               String_val(Name));
   2124 }
   2125 
   2126 /* llvalue -> string -> llbuilder -> llvalue */
   2127 CAMLprim LLVMValueRef llvm_build_is_null(LLVMValueRef Val, value Name,
   2128                                          value B) {
   2129   return LLVMBuildIsNull(Builder_val(B), Val, String_val(Name));
   2130 }
   2131 
   2132 /* llvalue -> string -> llbuilder -> llvalue */
   2133 CAMLprim LLVMValueRef llvm_build_is_not_null(LLVMValueRef Val, value Name,
   2134                                              value B) {
   2135   return LLVMBuildIsNotNull(Builder_val(B), Val, String_val(Name));
   2136 }
   2137 
   2138 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
   2139 CAMLprim LLVMValueRef llvm_build_ptrdiff(LLVMValueRef LHS, LLVMValueRef RHS,
   2140                                          value Name, value B) {
   2141   return LLVMBuildPtrDiff(Builder_val(B), LHS, RHS, String_val(Name));
   2142 }
   2143 
   2144 /*===-- Memory buffers ----------------------------------------------------===*/
   2145 
   2146 /* string -> llmemorybuffer
   2147    raises IoError msg on error */
   2148 CAMLprim value llvm_memorybuffer_of_file(value Path) {
   2149   CAMLparam1(Path);
   2150   char *Message;
   2151   LLVMMemoryBufferRef MemBuf;
   2152 
   2153   if (LLVMCreateMemoryBufferWithContentsOfFile(String_val(Path),
   2154                                                &MemBuf, &Message))
   2155     llvm_raise(llvm_ioerror_exn, Message);
   2156 
   2157   CAMLreturn((value) MemBuf);
   2158 }
   2159 
   2160 /* unit -> llmemorybuffer
   2161    raises IoError msg on error */
   2162 CAMLprim LLVMMemoryBufferRef llvm_memorybuffer_of_stdin(value Unit) {
   2163   char *Message;
   2164   LLVMMemoryBufferRef MemBuf;
   2165 
   2166   if (LLVMCreateMemoryBufferWithSTDIN(&MemBuf, &Message))
   2167     llvm_raise(llvm_ioerror_exn, Message);
   2168 
   2169   return MemBuf;
   2170 }
   2171 
   2172 /* ?name:string -> string -> llmemorybuffer */
   2173 CAMLprim LLVMMemoryBufferRef llvm_memorybuffer_of_string(value Name, value String) {
   2174   const char *NameCStr;
   2175   if(Name == Val_int(0))
   2176     NameCStr = "";
   2177   else
   2178     NameCStr = String_val(Field(Name, 0));
   2179 
   2180   LLVMMemoryBufferRef MemBuf;
   2181   MemBuf = LLVMCreateMemoryBufferWithMemoryRangeCopy(
   2182                 String_val(String), caml_string_length(String), NameCStr);
   2183 
   2184   return MemBuf;
   2185 }
   2186 
   2187 /* llmemorybuffer -> string */
   2188 CAMLprim value llvm_memorybuffer_as_string(LLVMMemoryBufferRef MemBuf) {
   2189   value String = caml_alloc_string(LLVMGetBufferSize(MemBuf));
   2190   memcpy(String_val(String), LLVMGetBufferStart(MemBuf),
   2191          LLVMGetBufferSize(MemBuf));
   2192 
   2193   return String;
   2194 }
   2195 
   2196 /* llmemorybuffer -> unit */
   2197 CAMLprim value llvm_memorybuffer_dispose(LLVMMemoryBufferRef MemBuf) {
   2198   LLVMDisposeMemoryBuffer(MemBuf);
   2199   return Val_unit;
   2200 }
   2201 
   2202 /*===-- Pass Managers -----------------------------------------------------===*/
   2203 
   2204 /* unit -> [ `Module ] PassManager.t */
   2205 CAMLprim LLVMPassManagerRef llvm_passmanager_create(value Unit) {
   2206   return LLVMCreatePassManager();
   2207 }
   2208 
   2209 /* llmodule -> [ `Function ] PassManager.t -> bool */
   2210 CAMLprim value llvm_passmanager_run_module(LLVMModuleRef M,
   2211                                            LLVMPassManagerRef PM) {
   2212   return Val_bool(LLVMRunPassManager(PM, M));
   2213 }
   2214 
   2215 /* [ `Function ] PassManager.t -> bool */
   2216 CAMLprim value llvm_passmanager_initialize(LLVMPassManagerRef FPM) {
   2217   return Val_bool(LLVMInitializeFunctionPassManager(FPM));
   2218 }
   2219 
   2220 /* llvalue -> [ `Function ] PassManager.t -> bool */
   2221 CAMLprim value llvm_passmanager_run_function(LLVMValueRef F,
   2222                                              LLVMPassManagerRef FPM) {
   2223   return Val_bool(LLVMRunFunctionPassManager(FPM, F));
   2224 }
   2225 
   2226 /* [ `Function ] PassManager.t -> bool */
   2227 CAMLprim value llvm_passmanager_finalize(LLVMPassManagerRef FPM) {
   2228   return Val_bool(LLVMFinalizeFunctionPassManager(FPM));
   2229 }
   2230 
   2231 /* PassManager.any PassManager.t -> unit */
   2232 CAMLprim value llvm_passmanager_dispose(LLVMPassManagerRef PM) {
   2233   LLVMDisposePassManager(PM);
   2234   return Val_unit;
   2235 }
   2236