bindings/ocaml/llvm/llvm_ocaml.c

   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 "llvm/Config/config.h"
  25 #include <assert.h>
  26 #include <stdlib.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   return Val_unit;
  37 }
  38
  39 static void llvm_raise(value Prototype, char *Message) {
  40   CAMLparam1(Prototype);
  41   CAMLlocal1(CamlMessage);
  42
  43   CamlMessage = copy_string(Message);
  44   LLVMDisposeMessage(Message);
  45
  46   raise_with_arg(Prototype, CamlMessage);
  47   abort(); /* NOTREACHED */
  48 #ifdef CAMLnoreturn
  49   CAMLnoreturn; /* Silences warnings, but is missing in some versions. */
  50 #endif
  51 }
  52
  53 static value alloc_variant(int tag, void *Value) {
  54   value Iter = alloc_small(1, tag);
  55   Field(Iter, 0) = Val_op(Value);
  56   return Iter;
  57 }
  58
  59 /* Macro to convert the C first/next/last/prev idiom to the Ocaml llpos/
  60    llrev_pos idiom. */
  61 #define DEFINE_ITERATORS(camlname, cname, pty, cty, pfun) \
  62   /* llmodule -> ('a, 'b) llpos */                        \
  63   CAMLprim value llvm_##camlname##_begin(pty Mom) {       \
  64     cty First = LLVMGetFirst##cname(Mom);                 \
  65     if (First)                                            \
  66       return alloc_variant(1, First);                     \
  67     return alloc_variant(0, Mom);                         \
  68   }                                                       \
  69                                                           \
  70   /* llvalue -> ('a, 'b) llpos */                         \
  71   CAMLprim value llvm_##camlname##_succ(cty Kid) {        \
  72     cty Next = LLVMGetNext##cname(Kid);                   \
  73     if (Next)                                             \
  74       return alloc_variant(1, Next);                      \
  75     return alloc_variant(0, pfun(Kid));                   \
  76   }                                                       \
  77                                                           \
  78   /* llmodule -> ('a, 'b) llrev_pos */                    \
  79   CAMLprim value llvm_##camlname##_end(pty Mom) {         \
  80     cty Last = LLVMGetLast##cname(Mom);                   \
  81     if (Last)                                             \
  82       return alloc_variant(1, Last);                      \
  83     return alloc_variant(0, Mom);                         \
  84   }                                                       \
  85                                                           \
  86   /* llvalue -> ('a, 'b) llrev_pos */                     \
  87   CAMLprim value llvm_##camlname##_pred(cty Kid) {        \
  88     cty Prev = LLVMGetPrevious##cname(Kid);               \
  89     if (Prev)                                             \
  90       return alloc_variant(1, Prev);                      \
  91     return alloc_variant(0, pfun(Kid));                   \
  92   }
  93
  94
  95 /*===-- Contexts ----------------------------------------------------------===*/
  96
  97 /* unit -> llcontext */
  98 CAMLprim LLVMContextRef llvm_create_context(value Unit) {
  99   return LLVMContextCreate();
 100 }
 101
 102 /* llcontext -> unit */
 103 CAMLprim value llvm_dispose_context(LLVMContextRef C) {
 104   LLVMContextDispose(C);
 105   return Val_unit;
 106 }
 107
 108 /* unit -> llcontext */
 109 CAMLprim LLVMContextRef llvm_global_context(value Unit) {
 110   return LLVMGetGlobalContext();
 111 }
 112
 113 /*===-- Modules -----------------------------------------------------------===*/
 114
 115 /* llcontext -> string -> llmodule */
 116 CAMLprim LLVMModuleRef llvm_create_module(LLVMContextRef C, value ModuleID) {
 117   return LLVMModuleCreateWithNameInContext(String_val(ModuleID), C);
 118 }
 119
 120 /* llmodule -> unit */
 121 CAMLprim value llvm_dispose_module(LLVMModuleRef M) {
 122   LLVMDisposeModule(M);
 123   return Val_unit;
 124 }
 125
 126 /* llmodule -> string */
 127 CAMLprim value llvm_target_triple(LLVMModuleRef M) {
 128   return copy_string(LLVMGetTarget(M));
 129 }
 130
 131 /* string -> llmodule -> unit */
 132 CAMLprim value llvm_set_target_triple(value Trip, LLVMModuleRef M) {
 133   LLVMSetTarget(M, String_val(Trip));
 134   return Val_unit;
 135 }
 136
 137 /* llmodule -> string */
 138 CAMLprim value llvm_data_layout(LLVMModuleRef M) {
 139   return copy_string(LLVMGetDataLayout(M));
 140 }
 141
 142 /* string -> llmodule -> unit */
 143 CAMLprim value llvm_set_data_layout(value Layout, LLVMModuleRef M) {
 144   LLVMSetDataLayout(M, String_val(Layout));
 145   return Val_unit;
 146 }
 147
 148 /* string -> lltype -> llmodule -> bool */
 149 CAMLprim value llvm_add_type_name(value Name, LLVMTypeRef Ty, LLVMModuleRef M) {
 150   int res = LLVMAddTypeName(M, String_val(Name), Ty);
 151   return Val_bool(res == 0);
 152 }
 153
 154 /* string -> llmodule -> unit */
 155 CAMLprim value llvm_delete_type_name(value Name, LLVMModuleRef M) {
 156   LLVMDeleteTypeName(M, String_val(Name));
 157   return Val_unit;
 158 }
 159
 160 /* llmodule -> unit */
 161 CAMLprim value llvm_dump_module(LLVMModuleRef M) {
 162   LLVMDumpModule(M);
 163   return Val_unit;
 164 }
 165
 166
 167 /*===-- Types -------------------------------------------------------------===*/
 168
 169 /* lltype -> TypeKind.t */
 170 CAMLprim value llvm_classify_type(LLVMTypeRef Ty) {
 171   return Val_int(LLVMGetTypeKind(Ty));
 172 }
 173
 174 /* lltype -> llcontext */
 175 CAMLprim LLVMContextRef llvm_type_context(LLVMTypeRef Ty) {
 176   return LLVMGetTypeContext(Ty);
 177 }
 178
 179 /*--... Operations on integer types ........................................--*/
 180
 181 /* llcontext -> lltype */
 182 CAMLprim LLVMTypeRef llvm_i1_type (LLVMContextRef Context) {
 183   return LLVMInt1TypeInContext(Context);
 184 }
 185
 186 /* llcontext -> lltype */
 187 CAMLprim LLVMTypeRef llvm_i8_type (LLVMContextRef Context) {
 188   return LLVMInt8TypeInContext(Context);
 189 }
 190
 191 /* llcontext -> lltype */
 192 CAMLprim LLVMTypeRef llvm_i16_type (LLVMContextRef Context) {
 193   return LLVMInt16TypeInContext(Context);
 194 }
 195
 196 /* llcontext -> lltype */
 197 CAMLprim LLVMTypeRef llvm_i32_type (LLVMContextRef Context) {
 198   return LLVMInt32TypeInContext(Context);
 199 }
 200
 201 /* llcontext -> lltype */
 202 CAMLprim LLVMTypeRef llvm_i64_type (LLVMContextRef Context) {
 203   return LLVMInt64TypeInContext(Context);
 204 }
 205
 206 /* llcontext -> int -> lltype */
 207 CAMLprim LLVMTypeRef llvm_integer_type(LLVMContextRef Context, value Width) {
 208   return LLVMIntTypeInContext(Context, Int_val(Width));
 209 }
 210
 211 /* lltype -> int */
 212 CAMLprim value llvm_integer_bitwidth(LLVMTypeRef IntegerTy) {
 213   return Val_int(LLVMGetIntTypeWidth(IntegerTy));
 214 }
 215
 216 /*--... Operations on real types ...........................................--*/
 217
 218 /* llcontext -> lltype */
 219 CAMLprim LLVMTypeRef llvm_float_type(LLVMContextRef Context) {
 220   return LLVMFloatTypeInContext(Context);
 221 }
 222
 223 /* llcontext -> lltype */
 224 CAMLprim LLVMTypeRef llvm_double_type(LLVMContextRef Context) {
 225   return LLVMDoubleTypeInContext(Context);
 226 }
 227
 228 /* llcontext -> lltype */
 229 CAMLprim LLVMTypeRef llvm_x86fp80_type(LLVMContextRef Context) {
 230   return LLVMX86FP80TypeInContext(Context);
 231 }
 232
 233 /* llcontext -> lltype */
 234 CAMLprim LLVMTypeRef llvm_fp128_type(LLVMContextRef Context) {
 235   return LLVMFP128TypeInContext(Context);
 236 }
 237
 238 /* llcontext -> lltype */
 239 CAMLprim LLVMTypeRef llvm_ppc_fp128_type(LLVMContextRef Context) {
 240   return LLVMPPCFP128TypeInContext(Context);
 241 }
 242
 243 /*--... Operations on function types .......................................--*/
 244
 245 /* lltype -> lltype array -> lltype */
 246 CAMLprim LLVMTypeRef llvm_function_type(LLVMTypeRef RetTy, value ParamTys) {
 247   return LLVMFunctionType(RetTy, (LLVMTypeRef *) ParamTys,
 248                           Wosize_val(ParamTys), 0);
 249 }
 250
 251 /* lltype -> lltype array -> lltype */
 252 CAMLprim LLVMTypeRef llvm_var_arg_function_type(LLVMTypeRef RetTy,
 253                                                 value ParamTys) {
 254   return LLVMFunctionType(RetTy, (LLVMTypeRef *) ParamTys,
 255                           Wosize_val(ParamTys), 1);
 256 }
 257
 258 /* lltype -> bool */
 259 CAMLprim value llvm_is_var_arg(LLVMTypeRef FunTy) {
 260   return Val_bool(LLVMIsFunctionVarArg(FunTy));
 261 }
 262
 263 /* lltype -> lltype array */
 264 CAMLprim value llvm_param_types(LLVMTypeRef FunTy) {
 265   value Tys = alloc(LLVMCountParamTypes(FunTy), 0);
 266   LLVMGetParamTypes(FunTy, (LLVMTypeRef *) Tys);
 267   return Tys;
 268 }
 269
 270 /*--... Operations on struct types .........................................--*/
 271
 272 /* llcontext -> lltype array -> lltype */
 273 CAMLprim LLVMTypeRef llvm_struct_type(LLVMContextRef C, value ElementTypes) {
 274   return LLVMStructTypeInContext(C, (LLVMTypeRef *) ElementTypes,
 275                                  Wosize_val(ElementTypes), 0);
 276 }
 277
 278 /* llcontext -> lltype array -> lltype */
 279 CAMLprim LLVMTypeRef llvm_packed_struct_type(LLVMContextRef C,
 280                                              value ElementTypes) {
 281   return LLVMStructTypeInContext(C, (LLVMTypeRef *) ElementTypes,
 282                                  Wosize_val(ElementTypes), 1);
 283 }
 284
 285 /* lltype -> lltype array */
 286 CAMLprim value llvm_struct_element_types(LLVMTypeRef StructTy) {
 287   value Tys = alloc(LLVMCountStructElementTypes(StructTy), 0);
 288   LLVMGetStructElementTypes(StructTy, (LLVMTypeRef *) Tys);
 289   return Tys;
 290 }
 291
 292 /* lltype -> bool */
 293 CAMLprim value llvm_is_packed(LLVMTypeRef StructTy) {
 294   return Val_bool(LLVMIsPackedStruct(StructTy));
 295 }
 296
 297 /*--... Operations on union types ..........................................--*/
 298
 299 /* llcontext -> lltype array -> lltype */
 300 CAMLprim LLVMTypeRef llvm_union_type(LLVMContextRef C, value ElementTypes) {
 301   return LLVMUnionTypeInContext(C, (LLVMTypeRef *) ElementTypes,
 302                                 Wosize_val(ElementTypes));
 303 }
 304
 305 /* lltype -> lltype array */
 306 CAMLprim value llvm_union_element_types(LLVMTypeRef UnionTy) {
 307   value Tys = alloc(LLVMCountUnionElementTypes(UnionTy), 0);
 308   LLVMGetUnionElementTypes(UnionTy, (LLVMTypeRef *) Tys);
 309   return Tys;
 310 }
 311
 312 /*--... Operations on array, pointer, and vector types .....................--*/
 313
 314 /* lltype -> int -> lltype */
 315 CAMLprim LLVMTypeRef llvm_array_type(LLVMTypeRef ElementTy, value Count) {
 316   return LLVMArrayType(ElementTy, Int_val(Count));
 317 }
 318
 319 /* lltype -> lltype */
 320 CAMLprim LLVMTypeRef llvm_pointer_type(LLVMTypeRef ElementTy) {
 321   return LLVMPointerType(ElementTy, 0);
 322 }
 323
 324 /* lltype -> int -> lltype */
 325 CAMLprim LLVMTypeRef llvm_qualified_pointer_type(LLVMTypeRef ElementTy,
 326                                                  value AddressSpace) {
 327   return LLVMPointerType(ElementTy, Int_val(AddressSpace));
 328 }
 329
 330 /* lltype -> int -> lltype */
 331 CAMLprim LLVMTypeRef llvm_vector_type(LLVMTypeRef ElementTy, value Count) {
 332   return LLVMVectorType(ElementTy, Int_val(Count));
 333 }
 334
 335 /* lltype -> int */
 336 CAMLprim value llvm_array_length(LLVMTypeRef ArrayTy) {
 337   return Val_int(LLVMGetArrayLength(ArrayTy));
 338 }
 339
 340 /* lltype -> int */
 341 CAMLprim value llvm_address_space(LLVMTypeRef PtrTy) {
 342   return Val_int(LLVMGetPointerAddressSpace(PtrTy));
 343 }
 344
 345 /* lltype -> int */
 346 CAMLprim value llvm_vector_size(LLVMTypeRef VectorTy) {
 347   return Val_int(LLVMGetVectorSize(VectorTy));
 348 }
 349
 350 /*--... Operations on other types ..........................................--*/
 351
 352 /* llcontext -> lltype */
 353 CAMLprim LLVMTypeRef llvm_void_type (LLVMContextRef Context) {
 354   return LLVMVoidTypeInContext(Context);
 355 }
 356
 357 /* llcontext -> lltype */
 358 CAMLprim LLVMTypeRef llvm_label_type(LLVMContextRef Context) {
 359   return LLVMLabelTypeInContext(Context);
 360 }
 361
 362 /* llcontext -> lltype */
 363 CAMLprim LLVMTypeRef llvm_opaque_type(LLVMContextRef Context) {
 364   return LLVMOpaqueTypeInContext(Context);
 365 }
 366
 367 /*--... Operations on type handles .........................................--*/
 368
 369 #define Typehandle_val(v)  (*(LLVMTypeHandleRef *)(Data_custom_val(v)))
 370
 371 static void llvm_finalize_handle(value TH) {
 372   LLVMDisposeTypeHandle(Typehandle_val(TH));
 373 }
 374
 375 static struct custom_operations typehandle_ops = {
 376   (char *) "LLVMTypeHandle",
 377   llvm_finalize_handle,
 378   custom_compare_default,
 379   custom_hash_default,
 380   custom_serialize_default,
 381   custom_deserialize_default
 382 };
 383
 384 CAMLprim value llvm_handle_to_type(LLVMTypeRef PATy) {
 385   value TH = alloc_custom(&typehandle_ops, sizeof(LLVMBuilderRef), 0, 1);
 386   Typehandle_val(TH) = LLVMCreateTypeHandle(PATy);
 387   return TH;
 388 }
 389
 390 CAMLprim LLVMTypeRef llvm_type_of_handle(value TH) {
 391   return LLVMResolveTypeHandle(Typehandle_val(TH));
 392 }
 393
 394 CAMLprim value llvm_refine_type(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy){
 395   LLVMRefineType(AbstractTy, ConcreteTy);
 396   return Val_unit;
 397 }
 398
 399
 400 /*===-- VALUES ------------------------------------------------------------===*/
 401
 402 /* llvalue -> lltype */
 403 CAMLprim LLVMTypeRef llvm_type_of(LLVMValueRef Val) {
 404   return LLVMTypeOf(Val);
 405 }
 406
 407 /* llvalue -> string */
 408 CAMLprim value llvm_value_name(LLVMValueRef Val) {
 409   return copy_string(LLVMGetValueName(Val));
 410 }
 411
 412 /* string -> llvalue -> unit */
 413 CAMLprim value llvm_set_value_name(value Name, LLVMValueRef Val) {
 414   LLVMSetValueName(Val, String_val(Name));
 415   return Val_unit;
 416 }
 417
 418 /* llvalue -> unit */
 419 CAMLprim value llvm_dump_value(LLVMValueRef Val) {
 420   LLVMDumpValue(Val);
 421   return Val_unit;
 422 }
 423
 424 /*--... Operations on constants of (mostly) any type .......................--*/
 425
 426 /* llvalue -> bool */
 427 CAMLprim value llvm_is_constant(LLVMValueRef Val) {
 428   return Val_bool(LLVMIsConstant(Val));
 429 }
 430
 431 /* llvalue -> bool */
 432 CAMLprim value llvm_is_null(LLVMValueRef Val) {
 433   return Val_bool(LLVMIsNull(Val));
 434 }
 435
 436 /* llvalue -> bool */
 437 CAMLprim value llvm_is_undef(LLVMValueRef Val) {
 438   return Val_bool(LLVMIsUndef(Val));
 439 }
 440
 441 /*--... Operations on scalar constants .....................................--*/
 442
 443 /* lltype -> int -> llvalue */
 444 CAMLprim LLVMValueRef llvm_const_int(LLVMTypeRef IntTy, value N) {
 445   return LLVMConstInt(IntTy, (long long) Int_val(N), 1);
 446 }
 447
 448 /* lltype -> Int64.t -> bool -> llvalue */
 449 CAMLprim LLVMValueRef llvm_const_of_int64(LLVMTypeRef IntTy, value N,
 450                                           value SExt) {
 451   return LLVMConstInt(IntTy, Int64_val(N), Bool_val(SExt));
 452 }
 453
 454 /* lltype -> string -> int -> llvalue */
 455 CAMLprim LLVMValueRef llvm_const_int_of_string(LLVMTypeRef IntTy, value S,
 456                                                value Radix) {
 457   return LLVMConstIntOfStringAndSize(IntTy, String_val(S), caml_string_length(S),
 458                                      Int_val(Radix));
 459 }
 460
 461 /* lltype -> float -> llvalue */
 462 CAMLprim LLVMValueRef llvm_const_float(LLVMTypeRef RealTy, value N) {
 463   return LLVMConstReal(RealTy, Double_val(N));
 464 }
 465
 466 /* lltype -> string -> llvalue */
 467 CAMLprim LLVMValueRef llvm_const_float_of_string(LLVMTypeRef RealTy, value S) {
 468   return LLVMConstRealOfStringAndSize(RealTy, String_val(S),
 469                                       caml_string_length(S));
 470 }
 471
 472 /*--... Operations on composite constants ..................................--*/
 473
 474 /* llcontext -> string -> llvalue */
 475 CAMLprim LLVMValueRef llvm_const_string(LLVMContextRef Context, value Str,
 476                                         value NullTerminate) {
 477   return LLVMConstStringInContext(Context, String_val(Str), string_length(Str),
 478                                   1);
 479 }
 480
 481 /* llcontext -> string -> llvalue */
 482 CAMLprim LLVMValueRef llvm_const_stringz(LLVMContextRef Context, value Str,
 483                                          value NullTerminate) {
 484   return LLVMConstStringInContext(Context, String_val(Str), string_length(Str),
 485                                   0);
 486 }
 487
 488 /* lltype -> llvalue array -> llvalue */
 489 CAMLprim LLVMValueRef llvm_const_array(LLVMTypeRef ElementTy,
 490                                                value ElementVals) {
 491   return LLVMConstArray(ElementTy, (LLVMValueRef*) Op_val(ElementVals),
 492                         Wosize_val(ElementVals));
 493 }
 494
 495 /* llcontext -> llvalue array -> llvalue */
 496 CAMLprim LLVMValueRef llvm_const_struct(LLVMContextRef C, value ElementVals) {
 497   return LLVMConstStructInContext(C, (LLVMValueRef *) Op_val(ElementVals),
 498                                   Wosize_val(ElementVals), 0);
 499 }
 500
 501 /* llcontext -> llvalue array -> llvalue */
 502 CAMLprim LLVMValueRef llvm_const_packed_struct(LLVMContextRef C,
 503                                                value ElementVals) {
 504   return LLVMConstStructInContext(C, (LLVMValueRef *) Op_val(ElementVals),
 505                                   Wosize_val(ElementVals), 1);
 506 }
 507
 508 /* llvalue array -> llvalue */
 509 CAMLprim LLVMValueRef llvm_const_vector(value ElementVals) {
 510   return LLVMConstVector((LLVMValueRef*) Op_val(ElementVals),
 511                          Wosize_val(ElementVals));
 512 }
 513
 514 /*--... Constant expressions ...............................................--*/
 515
 516 /* Icmp.t -> llvalue -> llvalue -> llvalue */
 517 CAMLprim LLVMValueRef llvm_const_icmp(value Pred,
 518                                       LLVMValueRef LHSConstant,
 519                                       LLVMValueRef RHSConstant) {
 520   return LLVMConstICmp(Int_val(Pred) + LLVMIntEQ, LHSConstant, RHSConstant);
 521 }
 522
 523 /* Fcmp.t -> llvalue -> llvalue -> llvalue */
 524 CAMLprim LLVMValueRef llvm_const_fcmp(value Pred,
 525                                       LLVMValueRef LHSConstant,
 526                                       LLVMValueRef RHSConstant) {
 527   return LLVMConstFCmp(Int_val(Pred), LHSConstant, RHSConstant);
 528 }
 529
 530 /* llvalue -> llvalue array -> llvalue */
 531 CAMLprim LLVMValueRef llvm_const_gep(LLVMValueRef ConstantVal, value Indices) {
 532   return LLVMConstGEP(ConstantVal, (LLVMValueRef*) Op_val(Indices),
 533                       Wosize_val(Indices));
 534 }
 535
 536 /* llvalue -> llvalue array -> llvalue */
 537 CAMLprim LLVMValueRef llvm_const_in_bounds_gep(LLVMValueRef ConstantVal,
 538                                                value Indices) {
 539   return LLVMConstInBoundsGEP(ConstantVal, (LLVMValueRef*) Op_val(Indices),
 540                               Wosize_val(Indices));
 541 }
 542
 543 /* llvalue -> int array -> llvalue */
 544 CAMLprim LLVMValueRef llvm_const_extractvalue(LLVMValueRef Aggregate,
 545                                               value Indices) {
 546   CAMLparam1(Indices);
 547   int size = Wosize_val(Indices);
 548   int i;
 549   LLVMValueRef result;
 550
 551   unsigned* idxs = (unsigned*)malloc(size * sizeof(unsigned));
 552   for (i = 0; i < size; i++) {
 553     idxs[i] = Int_val(Field(Indices, i));
 554   }
 555
 556   result = LLVMConstExtractValue(Aggregate, idxs, size);
 557   free(idxs);
 558   CAMLreturnT(LLVMValueRef, result);
 559 }
 560
 561 /* llvalue -> llvalue -> int array -> llvalue */
 562 CAMLprim LLVMValueRef llvm_const_insertvalue(LLVMValueRef Aggregate,
 563                                              LLVMValueRef Val, value Indices) {
 564   CAMLparam1(Indices);
 565   int size = Wosize_val(Indices);
 566   int i;
 567   LLVMValueRef result;
 568
 569   unsigned* idxs = (unsigned*)malloc(size * sizeof(unsigned));
 570   for (i = 0; i < size; i++) {
 571     idxs[i] = Int_val(Field(Indices, i));
 572   }
 573
 574   result = LLVMConstInsertValue(Aggregate, Val, idxs, size);
 575   free(idxs);
 576   CAMLreturnT(LLVMValueRef, result);
 577 }
 578
 579 /*--... Operations on global variables, functions, and aliases (globals) ...--*/
 580
 581 /* llvalue -> bool */
 582 CAMLprim value llvm_is_declaration(LLVMValueRef Global) {
 583   return Val_bool(LLVMIsDeclaration(Global));
 584 }
 585
 586 /* llvalue -> Linkage.t */
 587 CAMLprim value llvm_linkage(LLVMValueRef Global) {
 588   return Val_int(LLVMGetLinkage(Global));
 589 }
 590
 591 /* Linkage.t -> llvalue -> unit */
 592 CAMLprim value llvm_set_linkage(value Linkage, LLVMValueRef Global) {
 593   LLVMSetLinkage(Global, Int_val(Linkage));
 594   return Val_unit;
 595 }
 596
 597 /* llvalue -> string */
 598 CAMLprim value llvm_section(LLVMValueRef Global) {
 599   return copy_string(LLVMGetSection(Global));
 600 }
 601
 602 /* string -> llvalue -> unit */
 603 CAMLprim value llvm_set_section(value Section, LLVMValueRef Global) {
 604   LLVMSetSection(Global, String_val(Section));
 605   return Val_unit;
 606 }
 607
 608 /* llvalue -> Visibility.t */
 609 CAMLprim value llvm_visibility(LLVMValueRef Global) {
 610   return Val_int(LLVMGetVisibility(Global));
 611 }
 612
 613 /* Visibility.t -> llvalue -> unit */
 614 CAMLprim value llvm_set_visibility(value Viz, LLVMValueRef Global) {
 615   LLVMSetVisibility(Global, Int_val(Viz));
 616   return Val_unit;
 617 }
 618
 619 /* llvalue -> int */
 620 CAMLprim value llvm_alignment(LLVMValueRef Global) {
 621   return Val_int(LLVMGetAlignment(Global));
 622 }
 623
 624 /* int -> llvalue -> unit */
 625 CAMLprim value llvm_set_alignment(value Bytes, LLVMValueRef Global) {
 626   LLVMSetAlignment(Global, Int_val(Bytes));
 627   return Val_unit;
 628 }
 629
 630 /*--... Operations on global variables .....................................--*/
 631
 632 DEFINE_ITERATORS(global, Global, LLVMModuleRef, LLVMValueRef,
 633                  LLVMGetGlobalParent)
 634
 635 /* lltype -> string -> llmodule -> llvalue */
 636 CAMLprim LLVMValueRef llvm_declare_global(LLVMTypeRef Ty, value Name,
 637                                           LLVMModuleRef M) {
 638   LLVMValueRef GlobalVar;
 639   if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
 640     if (LLVMGetElementType(LLVMTypeOf(GlobalVar)) != Ty)
 641       return LLVMConstBitCast(GlobalVar, LLVMPointerType(Ty, 0));
 642     return GlobalVar;
 643   }
 644   return LLVMAddGlobal(M, Ty, String_val(Name));
 645 }
 646
 647 /* string -> llmodule -> llvalue option */
 648 CAMLprim value llvm_lookup_global(value Name, LLVMModuleRef M) {
 649   CAMLparam1(Name);
 650   LLVMValueRef GlobalVar;
 651   if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
 652     value Option = alloc(1, 0);
 653     Field(Option, 0) = (value) GlobalVar;
 654     CAMLreturn(Option);
 655   }
 656   CAMLreturn(Val_int(0));
 657 }
 658
 659 /* string -> llvalue -> llmodule -> llvalue */
 660 CAMLprim LLVMValueRef llvm_define_global(value Name, LLVMValueRef Initializer,
 661                                          LLVMModuleRef M) {
 662   LLVMValueRef GlobalVar = LLVMAddGlobal(M, LLVMTypeOf(Initializer),
 663                                          String_val(Name));
 664   LLVMSetInitializer(GlobalVar, Initializer);
 665   return GlobalVar;
 666 }
 667
 668 /* llvalue -> unit */
 669 CAMLprim value llvm_delete_global(LLVMValueRef GlobalVar) {
 670   LLVMDeleteGlobal(GlobalVar);
 671   return Val_unit;
 672 }
 673
 674 /* llvalue -> llvalue -> unit */
 675 CAMLprim value llvm_set_initializer(LLVMValueRef ConstantVal,
 676                                     LLVMValueRef GlobalVar) {
 677   LLVMSetInitializer(GlobalVar, ConstantVal);
 678   return Val_unit;
 679 }
 680
 681 /* llvalue -> unit */
 682 CAMLprim value llvm_remove_initializer(LLVMValueRef GlobalVar) {
 683   LLVMSetInitializer(GlobalVar, NULL);
 684   return Val_unit;
 685 }
 686
 687 /* llvalue -> bool */
 688 CAMLprim value llvm_is_thread_local(LLVMValueRef GlobalVar) {
 689   return Val_bool(LLVMIsThreadLocal(GlobalVar));
 690 }
 691
 692 /* bool -> llvalue -> unit */
 693 CAMLprim value llvm_set_thread_local(value IsThreadLocal,
 694                                      LLVMValueRef GlobalVar) {
 695   LLVMSetThreadLocal(GlobalVar, Bool_val(IsThreadLocal));
 696   return Val_unit;
 697 }
 698
 699 /* llvalue -> bool */
 700 CAMLprim value llvm_is_global_constant(LLVMValueRef GlobalVar) {
 701   return Val_bool(LLVMIsGlobalConstant(GlobalVar));
 702 }
 703
 704 /* bool -> llvalue -> unit */
 705 CAMLprim value llvm_set_global_constant(value Flag, LLVMValueRef GlobalVar) {
 706   LLVMSetGlobalConstant(GlobalVar, Bool_val(Flag));
 707   return Val_unit;
 708 }
 709
 710 /*--... Operations on functions ............................................--*/
 711
 712 DEFINE_ITERATORS(function, Function, LLVMModuleRef, LLVMValueRef,
 713                  LLVMGetGlobalParent)
 714
 715 /* string -> lltype -> llmodule -> llvalue */
 716 CAMLprim LLVMValueRef llvm_declare_function(value Name, LLVMTypeRef Ty,
 717                                             LLVMModuleRef M) {
 718   LLVMValueRef Fn;
 719   if ((Fn = LLVMGetNamedFunction(M, String_val(Name)))) {
 720     if (LLVMGetElementType(LLVMTypeOf(Fn)) != Ty)
 721       return LLVMConstBitCast(Fn, LLVMPointerType(Ty, 0));
 722     return Fn;
 723   }
 724   return LLVMAddFunction(M, String_val(Name), Ty);
 725 }
 726
 727 /* string -> llmodule -> llvalue option */
 728 CAMLprim value llvm_lookup_function(value Name, LLVMModuleRef M) {
 729   CAMLparam1(Name);
 730   LLVMValueRef Fn;
 731   if ((Fn = LLVMGetNamedFunction(M, String_val(Name)))) {
 732     value Option = alloc(1, 0);
 733     Field(Option, 0) = (value) Fn;
 734     CAMLreturn(Option);
 735   }
 736   CAMLreturn(Val_int(0));
 737 }
 738
 739 /* string -> lltype -> llmodule -> llvalue */
 740 CAMLprim LLVMValueRef llvm_define_function(value Name, LLVMTypeRef Ty,
 741                                            LLVMModuleRef M) {
 742   LLVMValueRef Fn = LLVMAddFunction(M, String_val(Name), Ty);
 743   LLVMAppendBasicBlockInContext(LLVMGetTypeContext(Ty), Fn, "entry");
 744   return Fn;
 745 }
 746
 747 /* llvalue -> unit */
 748 CAMLprim value llvm_delete_function(LLVMValueRef Fn) {
 749   LLVMDeleteFunction(Fn);
 750   return Val_unit;
 751 }
 752
 753 /* llvalue -> bool */
 754 CAMLprim value llvm_is_intrinsic(LLVMValueRef Fn) {
 755   return Val_bool(LLVMGetIntrinsicID(Fn));
 756 }
 757
 758 /* llvalue -> int */
 759 CAMLprim value llvm_function_call_conv(LLVMValueRef Fn) {
 760   return Val_int(LLVMGetFunctionCallConv(Fn));
 761 }
 762
 763 /* int -> llvalue -> unit */
 764 CAMLprim value llvm_set_function_call_conv(value Id, LLVMValueRef Fn) {
 765   LLVMSetFunctionCallConv(Fn, Int_val(Id));
 766   return Val_unit;
 767 }
 768
 769 /* llvalue -> string option */
 770 CAMLprim value llvm_gc(LLVMValueRef Fn) {
 771   const char *GC;
 772   CAMLparam0();
 773   CAMLlocal2(Name, Option);
 774
 775   if ((GC = LLVMGetGC(Fn))) {
 776     Name = copy_string(GC);
 777
 778     Option = alloc(1, 0);
 779     Field(Option, 0) = Name;
 780     CAMLreturn(Option);
 781   } else {
 782     CAMLreturn(Val_int(0));
 783   }
 784 }
 785
 786 /* string option -> llvalue -> unit */
 787 CAMLprim value llvm_set_gc(value GC, LLVMValueRef Fn) {
 788   LLVMSetGC(Fn, GC == Val_int(0)? 0 : String_val(Field(GC, 0)));
 789   return Val_unit;
 790 }
 791
 792 /* llvalue -> Attribute.t -> unit */
 793 CAMLprim value llvm_add_function_attr(LLVMValueRef Arg, value PA) {
 794   LLVMAddFunctionAttr(Arg, 1<<Int_val(PA));
 795   return Val_unit;
 796 }
 797
 798 /* llvalue -> Attribute.t -> unit */
 799 CAMLprim value llvm_remove_function_attr(LLVMValueRef Arg, value PA) {
 800   LLVMRemoveFunctionAttr(Arg, 1<<Int_val(PA));
 801   return Val_unit;
 802 }
 803 /*--... Operations on parameters ...........................................--*/
 804
 805 DEFINE_ITERATORS(param, Param, LLVMValueRef, LLVMValueRef, LLVMGetParamParent)
 806
 807 /* llvalue -> int -> llvalue */
 808 CAMLprim LLVMValueRef llvm_param(LLVMValueRef Fn, value Index) {
 809   return LLVMGetParam(Fn, Int_val(Index));
 810 }
 811
 812 /* llvalue -> int -> llvalue */
 813 CAMLprim value llvm_params(LLVMValueRef Fn, value Index) {
 814   value Params = alloc(LLVMCountParams(Fn), 0);
 815   LLVMGetParams(Fn, (LLVMValueRef *) Op_val(Params));
 816   return Params;
 817 }
 818
 819 /* llvalue -> Attribute.t -> unit */
 820 CAMLprim value llvm_add_param_attr(LLVMValueRef Arg, value PA) {
 821   LLVMAddAttribute(Arg, 1<<Int_val(PA));
 822   return Val_unit;
 823 }
 824
 825 /* llvalue -> Attribute.t -> unit */
 826 CAMLprim value llvm_remove_param_attr(LLVMValueRef Arg, value PA) {
 827   LLVMRemoveAttribute(Arg, 1<<Int_val(PA));
 828   return Val_unit;
 829 }
 830
 831 /* llvalue -> int -> unit */
 832 CAMLprim value llvm_set_param_alignment(LLVMValueRef Arg, value align) {
 833   LLVMSetParamAlignment(Arg, Int_val(align));
 834   return Val_unit;
 835 }
 836
 837 /*--... Operations on basic blocks .........................................--*/
 838
 839 DEFINE_ITERATORS(
 840   block, BasicBlock, LLVMValueRef, LLVMBasicBlockRef, LLVMGetBasicBlockParent)
 841
 842 /* llvalue -> llbasicblock array */
 843 CAMLprim value llvm_basic_blocks(LLVMValueRef Fn) {
 844   value MLArray = alloc(LLVMCountBasicBlocks(Fn), 0);
 845   LLVMGetBasicBlocks(Fn, (LLVMBasicBlockRef *) Op_val(MLArray));
 846   return MLArray;
 847 }
 848
 849 /* llbasicblock -> unit */
 850 CAMLprim value llvm_delete_block(LLVMBasicBlockRef BB) {
 851   LLVMDeleteBasicBlock(BB);
 852   return Val_unit;
 853 }
 854
 855 /* string -> llvalue -> llbasicblock */
 856 CAMLprim LLVMBasicBlockRef llvm_append_block(LLVMContextRef Context, value Name,
 857                                              LLVMValueRef Fn) {
 858   return LLVMAppendBasicBlockInContext(Context, Fn, String_val(Name));
 859 }
 860
 861 /* string -> llbasicblock -> llbasicblock */
 862 CAMLprim LLVMBasicBlockRef llvm_insert_block(LLVMContextRef Context, value Name,
 863                                              LLVMBasicBlockRef BB) {
 864   return LLVMInsertBasicBlockInContext(Context, BB, String_val(Name));
 865 }
 866
 867 /* llvalue -> bool */
 868 CAMLprim value llvm_value_is_block(LLVMValueRef Val) {
 869   return Val_bool(LLVMValueIsBasicBlock(Val));
 870 }
 871
 872 /*--... Operations on instructions .........................................--*/
 873
 874 DEFINE_ITERATORS(instr, Instruction, LLVMBasicBlockRef, LLVMValueRef,
 875                  LLVMGetInstructionParent)
 876
 877
 878 /*--... Operations on call sites ...........................................--*/
 879
 880 /* llvalue -> int */
 881 CAMLprim value llvm_instruction_call_conv(LLVMValueRef Inst) {
 882   return Val_int(LLVMGetInstructionCallConv(Inst));
 883 }
 884
 885 /* int -> llvalue -> unit */
 886 CAMLprim value llvm_set_instruction_call_conv(value CC, LLVMValueRef Inst) {
 887   LLVMSetInstructionCallConv(Inst, Int_val(CC));
 888   return Val_unit;
 889 }
 890
 891 /* llvalue -> int -> Attribute.t -> unit */
 892 CAMLprim value llvm_add_instruction_param_attr(LLVMValueRef Instr,
 893                                                value index,
 894                                                value PA) {
 895   LLVMAddInstrAttribute(Instr, Int_val(index), 1<<Int_val(PA));
 896   return Val_unit;
 897 }
 898
 899 /* llvalue -> int -> Attribute.t -> unit */
 900 CAMLprim value llvm_remove_instruction_param_attr(LLVMValueRef Instr,
 901                                                   value index,
 902                                                   value PA) {
 903   LLVMRemoveInstrAttribute(Instr, Int_val(index), 1<<Int_val(PA));
 904   return Val_unit;
 905 }
 906
 907 /*--... Operations on call instructions (only) .............................--*/
 908
 909 /* llvalue -> bool */
 910 CAMLprim value llvm_is_tail_call(LLVMValueRef CallInst) {
 911   return Val_bool(LLVMIsTailCall(CallInst));
 912 }
 913
 914 /* bool -> llvalue -> unit */
 915 CAMLprim value llvm_set_tail_call(value IsTailCall,
 916                                   LLVMValueRef CallInst) {
 917   LLVMSetTailCall(CallInst, Bool_val(IsTailCall));
 918   return Val_unit;
 919 }
 920
 921 /*--... Operations on phi nodes ............................................--*/
 922
 923 /* (llvalue * llbasicblock) -> llvalue -> unit */
 924 CAMLprim value llvm_add_incoming(value Incoming, LLVMValueRef PhiNode) {
 925   LLVMAddIncoming(PhiNode,
 926                   (LLVMValueRef*) &Field(Incoming, 0),
 927                   (LLVMBasicBlockRef*) &Field(Incoming, 1),
 928                   1);
 929   return Val_unit;
 930 }
 931
 932 /* llvalue -> (llvalue * llbasicblock) list */
 933 CAMLprim value llvm_incoming(LLVMValueRef PhiNode) {
 934   unsigned I;
 935   CAMLparam0();
 936   CAMLlocal3(Hd, Tl, Tmp);
 937
 938   /* Build a tuple list of them. */
 939   Tl = Val_int(0);
 940   for (I = LLVMCountIncoming(PhiNode); I != 0; ) {
 941     Hd = alloc(2, 0);
 942     Store_field(Hd, 0, (value) LLVMGetIncomingValue(PhiNode, --I));
 943     Store_field(Hd, 1, (value) LLVMGetIncomingBlock(PhiNode, I));
 944
 945     Tmp = alloc(2, 0);
 946     Store_field(Tmp, 0, Hd);
 947     Store_field(Tmp, 1, Tl);
 948     Tl = Tmp;
 949   }
 950
 951   CAMLreturn(Tl);
 952 }
 953
 954
 955 /*===-- Instruction builders ----------------------------------------------===*/
 956
 957 #define Builder_val(v)  (*(LLVMBuilderRef *)(Data_custom_val(v)))
 958
 959 static void llvm_finalize_builder(value B) {
 960   LLVMDisposeBuilder(Builder_val(B));
 961 }
 962
 963 static struct custom_operations builder_ops = {
 964   (char *) "IRBuilder",
 965   llvm_finalize_builder,
 966   custom_compare_default,
 967   custom_hash_default,
 968   custom_serialize_default,
 969   custom_deserialize_default
 970 };
 971
 972 static value alloc_builder(LLVMBuilderRef B) {
 973   value V = alloc_custom(&builder_ops, sizeof(LLVMBuilderRef), 0, 1);
 974   Builder_val(V) = B;
 975   return V;
 976 }
 977
 978 /* llcontext -> llbuilder */
 979 CAMLprim value llvm_builder(LLVMContextRef C) {
 980   return alloc_builder(LLVMCreateBuilderInContext(C));
 981 }
 982
 983 /* (llbasicblock, llvalue) llpos -> llbuilder -> unit */
 984 CAMLprim value llvm_position_builder(value Pos, value B) {
 985   if (Tag_val(Pos) == 0) {
 986     LLVMBasicBlockRef BB = (LLVMBasicBlockRef) Op_val(Field(Pos, 0));
 987     LLVMPositionBuilderAtEnd(Builder_val(B), BB);
 988   } else {
 989     LLVMValueRef I = (LLVMValueRef) Op_val(Field(Pos, 0));
 990     LLVMPositionBuilderBefore(Builder_val(B), I);
 991   }
 992   return Val_unit;
 993 }
 994
 995 /* llbuilder -> llbasicblock */
 996 CAMLprim LLVMBasicBlockRef llvm_insertion_block(value B) {
 997   LLVMBasicBlockRef InsertBlock = LLVMGetInsertBlock(Builder_val(B));
 998   if (!InsertBlock)
 999     raise_not_found();
1000   return InsertBlock;
1001 }
1002
1003 /* llvalue -> string -> llbuilder -> unit */
1004 CAMLprim value llvm_insert_into_builder(LLVMValueRef I, value Name, value B) {
1005   LLVMInsertIntoBuilderWithName(Builder_val(B), I, String_val(Name));
1006   return Val_unit;
1007 }
1008
1009 /*--... Terminators ........................................................--*/
1010
1011 /* llbuilder -> llvalue */
1012 CAMLprim LLVMValueRef llvm_build_ret_void(value B) {
1013   return LLVMBuildRetVoid(Builder_val(B));
1014 }
1015
1016 /* llvalue -> llbuilder -> llvalue */
1017 CAMLprim LLVMValueRef llvm_build_ret(LLVMValueRef Val, value B) {
1018   return LLVMBuildRet(Builder_val(B), Val);
1019 }
1020
1021 /* llvalue array -> llbuilder -> llvalue */
1022 CAMLprim LLVMValueRef llvm_build_aggregate_ret(value RetVals, value B) {
1023   return LLVMBuildAggregateRet(Builder_val(B), (LLVMValueRef *) Op_val(RetVals),
1024                                Wosize_val(RetVals));
1025 }
1026
1027 /* llbasicblock -> llbuilder -> llvalue */
1028 CAMLprim LLVMValueRef llvm_build_br(LLVMBasicBlockRef BB, value B) {
1029   return LLVMBuildBr(Builder_val(B), BB);
1030 }
1031
1032 /* llvalue -> llbasicblock -> llbasicblock -> llbuilder -> llvalue */
1033 CAMLprim LLVMValueRef llvm_build_cond_br(LLVMValueRef If,
1034                                          LLVMBasicBlockRef Then,
1035                                          LLVMBasicBlockRef Else,
1036                                          value B) {
1037   return LLVMBuildCondBr(Builder_val(B), If, Then, Else);
1038 }
1039
1040 /* llvalue -> llbasicblock -> int -> llbuilder -> llvalue */
1041 CAMLprim LLVMValueRef llvm_build_switch(LLVMValueRef Of,
1042                                         LLVMBasicBlockRef Else,
1043                                         value EstimatedCount,
1044                                         value B) {
1045   return LLVMBuildSwitch(Builder_val(B), Of, Else, Int_val(EstimatedCount));
1046 }
1047
1048 /* llvalue -> llvalue -> llbasicblock -> unit */
1049 CAMLprim value llvm_add_case(LLVMValueRef Switch, LLVMValueRef OnVal,
1050                              LLVMBasicBlockRef Dest) {
1051   LLVMAddCase(Switch, OnVal, Dest);
1052   return Val_unit;
1053 }
1054
1055 /* llvalue -> llvalue array -> llbasicblock -> llbasicblock -> string ->
1056    llbuilder -> llvalue */
1057 CAMLprim LLVMValueRef llvm_build_invoke_nat(LLVMValueRef Fn, value Args,
1058                                             LLVMBasicBlockRef Then,
1059                                             LLVMBasicBlockRef Catch,
1060                                             value Name, value B) {
1061   return LLVMBuildInvoke(Builder_val(B), Fn, (LLVMValueRef *) Op_val(Args),
1062                          Wosize_val(Args), Then, Catch, String_val(Name));
1063 }
1064
1065 /* llvalue -> llvalue array -> llbasicblock -> llbasicblock -> string ->
1066    llbuilder -> llvalue */
1067 CAMLprim LLVMValueRef llvm_build_invoke_bc(value Args[], int NumArgs) {
1068   return llvm_build_invoke_nat((LLVMValueRef) Args[0], Args[1],
1069                                (LLVMBasicBlockRef) Args[2],
1070                                (LLVMBasicBlockRef) Args[3],
1071                                Args[4], Args[5]);
1072 }
1073
1074 /* llbuilder -> llvalue */
1075 CAMLprim LLVMValueRef llvm_build_unwind(value B) {
1076   return LLVMBuildUnwind(Builder_val(B));
1077 }
1078
1079 /* llbuilder -> llvalue */
1080 CAMLprim LLVMValueRef llvm_build_unreachable(value B) {
1081   return LLVMBuildUnreachable(Builder_val(B));
1082 }
1083
1084 /*--... Arithmetic .........................................................--*/
1085
1086 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1087 CAMLprim LLVMValueRef llvm_build_add(LLVMValueRef LHS, LLVMValueRef RHS,
1088                                      value Name, value B) {
1089   return LLVMBuildAdd(Builder_val(B), LHS, RHS, String_val(Name));
1090 }
1091
1092 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1093 CAMLprim LLVMValueRef llvm_build_nsw_add(LLVMValueRef LHS, LLVMValueRef RHS,
1094                                          value Name, value B) {
1095   return LLVMBuildNSWAdd(Builder_val(B), LHS, RHS, String_val(Name));
1096 }
1097
1098 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1099 CAMLprim LLVMValueRef llvm_build_nuw_add(LLVMValueRef LHS, LLVMValueRef RHS,
1100                                          value Name, value B) {
1101   return LLVMBuildNUWAdd(Builder_val(B), LHS, RHS, String_val(Name));
1102 }
1103
1104 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1105 CAMLprim LLVMValueRef llvm_build_fadd(LLVMValueRef LHS, LLVMValueRef RHS,
1106                                       value Name, value B) {
1107   return LLVMBuildFAdd(Builder_val(B), LHS, RHS, String_val(Name));
1108 }
1109
1110 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1111 CAMLprim LLVMValueRef llvm_build_sub(LLVMValueRef LHS, LLVMValueRef RHS,
1112                                      value Name, value B) {
1113   return LLVMBuildSub(Builder_val(B), LHS, RHS, String_val(Name));
1114 }
1115
1116 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1117 CAMLprim LLVMValueRef llvm_build_nsw_sub(LLVMValueRef LHS, LLVMValueRef RHS,
1118                                          value Name, value B) {
1119   return LLVMBuildNSWSub(Builder_val(B), LHS, RHS, String_val(Name));
1120 }
1121
1122 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1123 CAMLprim LLVMValueRef llvm_build_nuw_sub(LLVMValueRef LHS, LLVMValueRef RHS,
1124                                          value Name, value B) {
1125   return LLVMBuildNUWSub(Builder_val(B), LHS, RHS, String_val(Name));
1126 }
1127
1128 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1129 CAMLprim LLVMValueRef llvm_build_fsub(LLVMValueRef LHS, LLVMValueRef RHS,
1130                                       value Name, value B) {
1131   return LLVMBuildFSub(Builder_val(B), LHS, RHS, String_val(Name));
1132 }
1133
1134 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1135 CAMLprim LLVMValueRef llvm_build_mul(LLVMValueRef LHS, LLVMValueRef RHS,
1136                                      value Name, value B) {
1137   return LLVMBuildMul(Builder_val(B), LHS, RHS, String_val(Name));
1138 }
1139
1140 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1141 CAMLprim LLVMValueRef llvm_build_nsw_mul(LLVMValueRef LHS, LLVMValueRef RHS,
1142                                          value Name, value B) {
1143   return LLVMBuildNSWMul(Builder_val(B), LHS, RHS, String_val(Name));
1144 }
1145
1146 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1147 CAMLprim LLVMValueRef llvm_build_nuw_mul(LLVMValueRef LHS, LLVMValueRef RHS,
1148                                          value Name, value B) {
1149   return LLVMBuildNUWMul(Builder_val(B), LHS, RHS, String_val(Name));
1150 }
1151
1152 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1153 CAMLprim LLVMValueRef llvm_build_fmul(LLVMValueRef LHS, LLVMValueRef RHS,
1154                                       value Name, value B) {
1155   return LLVMBuildFMul(Builder_val(B), LHS, RHS, String_val(Name));
1156 }
1157
1158 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1159 CAMLprim LLVMValueRef llvm_build_udiv(LLVMValueRef LHS, LLVMValueRef RHS,
1160                                       value Name, value B) {
1161   return LLVMBuildUDiv(Builder_val(B), LHS, RHS, String_val(Name));
1162 }
1163
1164 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1165 CAMLprim LLVMValueRef llvm_build_sdiv(LLVMValueRef LHS, LLVMValueRef RHS,
1166                                       value Name, value B) {
1167   return LLVMBuildSDiv(Builder_val(B), LHS, RHS, String_val(Name));
1168 }
1169
1170 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1171 CAMLprim LLVMValueRef llvm_build_exact_sdiv(LLVMValueRef LHS, LLVMValueRef RHS,
1172                                             value Name, value B) {
1173   return LLVMBuildExactSDiv(Builder_val(B), LHS, RHS, String_val(Name));
1174 }
1175
1176 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1177 CAMLprim LLVMValueRef llvm_build_fdiv(LLVMValueRef LHS, LLVMValueRef RHS,
1178                                       value Name, value B) {
1179   return LLVMBuildFDiv(Builder_val(B), LHS, RHS, String_val(Name));
1180 }
1181
1182 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1183 CAMLprim LLVMValueRef llvm_build_urem(LLVMValueRef LHS, LLVMValueRef RHS,
1184                                       value Name, value B) {
1185   return LLVMBuildURem(Builder_val(B), LHS, RHS, String_val(Name));
1186 }
1187
1188 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1189 CAMLprim LLVMValueRef llvm_build_srem(LLVMValueRef LHS, LLVMValueRef RHS,
1190                                       value Name, value B) {
1191   return LLVMBuildSRem(Builder_val(B), LHS, RHS, String_val(Name));
1192 }
1193
1194 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1195 CAMLprim LLVMValueRef llvm_build_frem(LLVMValueRef LHS, LLVMValueRef RHS,
1196                                       value Name, value B) {
1197   return LLVMBuildFRem(Builder_val(B), LHS, RHS, String_val(Name));
1198 }
1199
1200 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1201 CAMLprim LLVMValueRef llvm_build_shl(LLVMValueRef LHS, LLVMValueRef RHS,
1202                                      value Name, value B) {
1203   return LLVMBuildShl(Builder_val(B), LHS, RHS, String_val(Name));
1204 }
1205
1206 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1207 CAMLprim LLVMValueRef llvm_build_lshr(LLVMValueRef LHS, LLVMValueRef RHS,
1208                                       value Name, value B) {
1209   return LLVMBuildLShr(Builder_val(B), LHS, RHS, String_val(Name));
1210 }
1211
1212 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1213 CAMLprim LLVMValueRef llvm_build_ashr(LLVMValueRef LHS, LLVMValueRef RHS,
1214                                       value Name, value B) {
1215   return LLVMBuildAShr(Builder_val(B), LHS, RHS, String_val(Name));
1216 }
1217
1218 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1219 CAMLprim LLVMValueRef llvm_build_and(LLVMValueRef LHS, LLVMValueRef RHS,
1220                                      value Name, value B) {
1221   return LLVMBuildAnd(Builder_val(B), LHS, RHS, String_val(Name));
1222 }
1223
1224 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1225 CAMLprim LLVMValueRef llvm_build_or(LLVMValueRef LHS, LLVMValueRef RHS,
1226                                     value Name, value B) {
1227   return LLVMBuildOr(Builder_val(B), LHS, RHS, String_val(Name));
1228 }
1229
1230 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1231 CAMLprim LLVMValueRef llvm_build_xor(LLVMValueRef LHS, LLVMValueRef RHS,
1232                                      value Name, value B) {
1233   return LLVMBuildXor(Builder_val(B), LHS, RHS, String_val(Name));
1234 }
1235
1236 /* llvalue -> string -> llbuilder -> llvalue */
1237 CAMLprim LLVMValueRef llvm_build_neg(LLVMValueRef X,
1238                                      value Name, value B) {
1239   return LLVMBuildNeg(Builder_val(B), X, String_val(Name));
1240 }
1241
1242 /* llvalue -> string -> llbuilder -> llvalue */
1243 CAMLprim LLVMValueRef llvm_build_nsw_neg(LLVMValueRef X,
1244                                          value Name, value B) {
1245   return LLVMBuildNSWNeg(Builder_val(B), X, String_val(Name));
1246 }
1247
1248 /* llvalue -> string -> llbuilder -> llvalue */
1249 CAMLprim LLVMValueRef llvm_build_nuw_neg(LLVMValueRef X,
1250                                          value Name, value B) {
1251   return LLVMBuildNUWNeg(Builder_val(B), X, String_val(Name));
1252 }
1253
1254 /* llvalue -> string -> llbuilder -> llvalue */
1255 CAMLprim LLVMValueRef llvm_build_fneg(LLVMValueRef X,
1256                                      value Name, value B) {
1257   return LLVMBuildFNeg(Builder_val(B), X, String_val(Name));
1258 }
1259
1260 /* llvalue -> string -> llbuilder -> llvalue */
1261 CAMLprim LLVMValueRef llvm_build_not(LLVMValueRef X,
1262                                      value Name, value B) {
1263   return LLVMBuildNot(Builder_val(B), X, String_val(Name));
1264 }
1265
1266 /*--... Memory .............................................................--*/
1267
1268 /* lltype -> string -> llbuilder -> llvalue */
1269 CAMLprim LLVMValueRef llvm_build_alloca(LLVMTypeRef Ty,
1270                                         value Name, value B) {
1271   return LLVMBuildAlloca(Builder_val(B), Ty, String_val(Name));
1272 }
1273
1274 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
1275 CAMLprim LLVMValueRef llvm_build_array_alloca(LLVMTypeRef Ty, LLVMValueRef Size,
1276                                               value Name, value B) {
1277   return LLVMBuildArrayAlloca(Builder_val(B), Ty, Size, String_val(Name));
1278 }
1279
1280 /* llvalue -> string -> llbuilder -> llvalue */
1281 CAMLprim LLVMValueRef llvm_build_load(LLVMValueRef Pointer,
1282                                       value Name, value B) {
1283   return LLVMBuildLoad(Builder_val(B), Pointer, String_val(Name));
1284 }
1285
1286 /* llvalue -> llvalue -> llbuilder -> llvalue */
1287 CAMLprim LLVMValueRef llvm_build_store(LLVMValueRef Value, LLVMValueRef Pointer,
1288                                        value B) {
1289   return LLVMBuildStore(Builder_val(B), Value, Pointer);
1290 }
1291
1292 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
1293 CAMLprim LLVMValueRef llvm_build_gep(LLVMValueRef Pointer, value Indices,
1294                                      value Name, value B) {
1295   return LLVMBuildGEP(Builder_val(B), Pointer,
1296                       (LLVMValueRef *) Op_val(Indices), Wosize_val(Indices),
1297                       String_val(Name));
1298 }
1299
1300 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
1301 CAMLprim LLVMValueRef llvm_build_in_bounds_gep(LLVMValueRef Pointer,
1302                                                value Indices, value Name,
1303                                                value B) {
1304   return LLVMBuildInBoundsGEP(Builder_val(B), Pointer,
1305                               (LLVMValueRef *) Op_val(Indices),
1306                               Wosize_val(Indices), String_val(Name));
1307 }
1308
1309 /* llvalue -> int -> string -> llbuilder -> llvalue */
1310 CAMLprim LLVMValueRef llvm_build_struct_gep(LLVMValueRef Pointer,
1311                                                value Index, value Name,
1312                                                value B) {
1313   return LLVMBuildStructGEP(Builder_val(B), Pointer,
1314                               Int_val(Index), String_val(Name));
1315 }
1316
1317 /* string -> string -> llbuilder -> llvalue */
1318 CAMLprim LLVMValueRef llvm_build_global_string(value Str, value Name, value B) {
1319   return LLVMBuildGlobalString(Builder_val(B), String_val(Str),
1320                                String_val(Name));
1321 }
1322
1323 /* string -> string -> llbuilder -> llvalue */
1324 CAMLprim LLVMValueRef llvm_build_global_stringptr(value Str, value Name,
1325                                                   value B) {
1326   return LLVMBuildGlobalStringPtr(Builder_val(B), String_val(Str),
1327                                   String_val(Name));
1328 }
1329
1330 /*--... Casts ..............................................................--*/
1331
1332 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1333 CAMLprim LLVMValueRef llvm_build_trunc(LLVMValueRef X, LLVMTypeRef Ty,
1334                                        value Name, value B) {
1335   return LLVMBuildTrunc(Builder_val(B), X, Ty, String_val(Name));
1336 }
1337
1338 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1339 CAMLprim LLVMValueRef llvm_build_zext(LLVMValueRef X, LLVMTypeRef Ty,
1340                                       value Name, value B) {
1341   return LLVMBuildZExt(Builder_val(B), X, Ty, String_val(Name));
1342 }
1343
1344 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1345 CAMLprim LLVMValueRef llvm_build_sext(LLVMValueRef X, LLVMTypeRef Ty,
1346                                       value Name, value B) {
1347   return LLVMBuildSExt(Builder_val(B), X, Ty, String_val(Name));
1348 }
1349
1350 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1351 CAMLprim LLVMValueRef llvm_build_fptoui(LLVMValueRef X, LLVMTypeRef Ty,
1352                                         value Name, value B) {
1353   return LLVMBuildFPToUI(Builder_val(B), X, Ty, String_val(Name));
1354 }
1355
1356 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1357 CAMLprim LLVMValueRef llvm_build_fptosi(LLVMValueRef X, LLVMTypeRef Ty,
1358                                         value Name, value B) {
1359   return LLVMBuildFPToSI(Builder_val(B), X, Ty, String_val(Name));
1360 }
1361
1362 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1363 CAMLprim LLVMValueRef llvm_build_uitofp(LLVMValueRef X, LLVMTypeRef Ty,
1364                                         value Name, value B) {
1365   return LLVMBuildUIToFP(Builder_val(B), X, Ty, String_val(Name));
1366 }
1367
1368 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1369 CAMLprim LLVMValueRef llvm_build_sitofp(LLVMValueRef X, LLVMTypeRef Ty,
1370                                         value Name, value B) {
1371   return LLVMBuildSIToFP(Builder_val(B), X, Ty, String_val(Name));
1372 }
1373
1374 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1375 CAMLprim LLVMValueRef llvm_build_fptrunc(LLVMValueRef X, LLVMTypeRef Ty,
1376                                          value Name, value B) {
1377   return LLVMBuildFPTrunc(Builder_val(B), X, Ty, String_val(Name));
1378 }
1379
1380 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1381 CAMLprim LLVMValueRef llvm_build_fpext(LLVMValueRef X, LLVMTypeRef Ty,
1382                                        value Name, value B) {
1383   return LLVMBuildFPExt(Builder_val(B), X, Ty, String_val(Name));
1384 }
1385
1386 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1387 CAMLprim LLVMValueRef llvm_build_prttoint(LLVMValueRef X, LLVMTypeRef Ty,
1388                                           value Name, value B) {
1389   return LLVMBuildPtrToInt(Builder_val(B), X, Ty, String_val(Name));
1390 }
1391
1392 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1393 CAMLprim LLVMValueRef llvm_build_inttoptr(LLVMValueRef X, LLVMTypeRef Ty,
1394                                           value Name, value B) {
1395   return LLVMBuildIntToPtr(Builder_val(B), X, Ty, String_val(Name));
1396 }
1397
1398 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1399 CAMLprim LLVMValueRef llvm_build_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
1400                                          value Name, value B) {
1401   return LLVMBuildBitCast(Builder_val(B), X, Ty, String_val(Name));
1402 }
1403
1404 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1405 CAMLprim LLVMValueRef llvm_build_zext_or_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
1406                                                  value Name, value B) {
1407   return LLVMBuildZExtOrBitCast(Builder_val(B), X, Ty, String_val(Name));
1408 }
1409
1410 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1411 CAMLprim LLVMValueRef llvm_build_sext_or_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
1412                                                  value Name, value B) {
1413   return LLVMBuildSExtOrBitCast(Builder_val(B), X, Ty, String_val(Name));
1414 }
1415
1416 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1417 CAMLprim LLVMValueRef llvm_build_trunc_or_bitcast(LLVMValueRef X,
1418                                                   LLVMTypeRef Ty, value Name,
1419                                                   value B) {
1420   return LLVMBuildTruncOrBitCast(Builder_val(B), X, Ty, String_val(Name));
1421 }
1422
1423 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1424 CAMLprim LLVMValueRef llvm_build_pointercast(LLVMValueRef X, LLVMTypeRef Ty,
1425                                              value Name, value B) {
1426   return LLVMBuildPointerCast(Builder_val(B), X, Ty, String_val(Name));
1427 }
1428
1429 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1430 CAMLprim LLVMValueRef llvm_build_intcast(LLVMValueRef X, LLVMTypeRef Ty,
1431                                          value Name, value B) {
1432   return LLVMBuildIntCast(Builder_val(B), X, Ty, String_val(Name));
1433 }
1434
1435 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1436 CAMLprim LLVMValueRef llvm_build_fpcast(LLVMValueRef X, LLVMTypeRef Ty,
1437                                         value Name, value B) {
1438   return LLVMBuildFPCast(Builder_val(B), X, Ty, String_val(Name));
1439 }
1440
1441 /*--... Comparisons ........................................................--*/
1442
1443 /* Icmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
1444 CAMLprim LLVMValueRef llvm_build_icmp(value Pred,
1445                                       LLVMValueRef LHS, LLVMValueRef RHS,
1446                                       value Name, value B) {
1447   return LLVMBuildICmp(Builder_val(B), Int_val(Pred) + LLVMIntEQ, LHS, RHS,
1448                        String_val(Name));
1449 }
1450
1451 /* Fcmp.t -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
1452 CAMLprim LLVMValueRef llvm_build_fcmp(value Pred,
1453                                       LLVMValueRef LHS, LLVMValueRef RHS,
1454                                       value Name, value B) {
1455   return LLVMBuildFCmp(Builder_val(B), Int_val(Pred), LHS, RHS,
1456                        String_val(Name));
1457 }
1458
1459 /*--... Miscellaneous instructions .........................................--*/
1460
1461 /* (llvalue * llbasicblock) list -> string -> llbuilder -> llvalue */
1462 CAMLprim LLVMValueRef llvm_build_phi(value Incoming, value Name, value B) {
1463   value Hd, Tl;
1464   LLVMValueRef FirstValue, PhiNode;
1465
1466   assert(Incoming != Val_int(0) && "Empty list passed to Llvm.build_phi!");
1467
1468   Hd = Field(Incoming, 0);
1469   FirstValue = (LLVMValueRef) Field(Hd, 0);
1470   PhiNode = LLVMBuildPhi(Builder_val(B), LLVMTypeOf(FirstValue),
1471                          String_val(Name));
1472
1473   for (Tl = Incoming; Tl != Val_int(0); Tl = Field(Tl, 1)) {
1474     value Hd = Field(Tl, 0);
1475     LLVMAddIncoming(PhiNode, (LLVMValueRef*) &Field(Hd, 0),
1476                     (LLVMBasicBlockRef*) &Field(Hd, 1), 1);
1477   }
1478
1479   return PhiNode;
1480 }
1481
1482 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
1483 CAMLprim LLVMValueRef llvm_build_call(LLVMValueRef Fn, value Params,
1484                                       value Name, value B) {
1485   return LLVMBuildCall(Builder_val(B), Fn, (LLVMValueRef *) Op_val(Params),
1486                        Wosize_val(Params), String_val(Name));
1487 }
1488
1489 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
1490 CAMLprim LLVMValueRef llvm_build_select(LLVMValueRef If,
1491                                         LLVMValueRef Then, LLVMValueRef Else,
1492                                         value Name, value B) {
1493   return LLVMBuildSelect(Builder_val(B), If, Then, Else, String_val(Name));
1494 }
1495
1496 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1497 CAMLprim LLVMValueRef llvm_build_va_arg(LLVMValueRef List, LLVMTypeRef Ty,
1498                                         value Name, value B) {
1499   return LLVMBuildVAArg(Builder_val(B), List, Ty, String_val(Name));
1500 }
1501
1502 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1503 CAMLprim LLVMValueRef llvm_build_extractelement(LLVMValueRef Vec,
1504                                                 LLVMValueRef Idx,
1505                                                 value Name, value B) {
1506   return LLVMBuildExtractElement(Builder_val(B), Vec, Idx, String_val(Name));
1507 }
1508
1509 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
1510 CAMLprim LLVMValueRef llvm_build_insertelement(LLVMValueRef Vec,
1511                                                LLVMValueRef Element,
1512                                                LLVMValueRef Idx,
1513                                                value Name, value B) {
1514   return LLVMBuildInsertElement(Builder_val(B), Vec, Element, Idx,
1515                                 String_val(Name));
1516 }
1517
1518 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
1519 CAMLprim LLVMValueRef llvm_build_shufflevector(LLVMValueRef V1, LLVMValueRef V2,
1520                                                LLVMValueRef Mask,
1521                                                value Name, value B) {
1522   return LLVMBuildShuffleVector(Builder_val(B), V1, V2, Mask, String_val(Name));
1523 }
1524
1525 /* llvalue -> int -> string -> llbuilder -> llvalue */
1526 CAMLprim LLVMValueRef llvm_build_extractvalue(LLVMValueRef Aggregate,
1527                                               value Idx, value Name, value B) {
1528   return LLVMBuildExtractValue(Builder_val(B), Aggregate, Int_val(Idx),
1529                                String_val(Name));
1530 }
1531
1532 /* llvalue -> llvalue -> int -> string -> llbuilder -> llvalue */
1533 CAMLprim LLVMValueRef llvm_build_insertvalue(LLVMValueRef Aggregate,
1534                                              LLVMValueRef Val, value Idx,
1535                                              value Name, value B) {
1536   return LLVMBuildInsertValue(Builder_val(B), Aggregate, Val, Int_val(Idx),
1537                               String_val(Name));
1538 }
1539
1540 /* llvalue -> string -> llbuilder -> llvalue */
1541 CAMLprim LLVMValueRef llvm_build_is_null(LLVMValueRef Val, value Name,
1542                                          value B) {
1543   return LLVMBuildIsNull(Builder_val(B), Val, String_val(Name));
1544 }
1545
1546 /* llvalue -> string -> llbuilder -> llvalue */
1547 CAMLprim LLVMValueRef llvm_build_is_not_null(LLVMValueRef Val, value Name,
1548                                              value B) {
1549   return LLVMBuildIsNotNull(Builder_val(B), Val, String_val(Name));
1550 }
1551
1552 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1553 CAMLprim LLVMValueRef llvm_build_ptrdiff(LLVMValueRef LHS, LLVMValueRef RHS,
1554                                          value Name, value B) {
1555   return LLVMBuildPtrDiff(Builder_val(B), LHS, RHS, String_val(Name));
1556 }
1557
1558 /*===-- Module Providers --------------------------------------------------===*/
1559
1560 /* llmoduleprovider -> unit */
1561 CAMLprim value llvm_dispose_module_provider(LLVMModuleProviderRef MP) {
1562   LLVMDisposeModuleProvider(MP);
1563   return Val_unit;
1564 }
1565
1566
1567 /*===-- Memory buffers ----------------------------------------------------===*/
1568
1569 /* string -> llmemorybuffer
1570    raises IoError msg on error */
1571 CAMLprim value llvm_memorybuffer_of_file(value Path) {
1572   CAMLparam1(Path);
1573   char *Message;
1574   LLVMMemoryBufferRef MemBuf;
1575
1576   if (LLVMCreateMemoryBufferWithContentsOfFile(String_val(Path),
1577                                                &MemBuf, &Message))
1578     llvm_raise(llvm_ioerror_exn, Message);
1579
1580   CAMLreturn((value) MemBuf);
1581 }
1582
1583 /* unit -> llmemorybuffer
1584    raises IoError msg on error */
1585 CAMLprim LLVMMemoryBufferRef llvm_memorybuffer_of_stdin(value Unit) {
1586   char *Message;
1587   LLVMMemoryBufferRef MemBuf;
1588
1589   if (LLVMCreateMemoryBufferWithSTDIN(&MemBuf, &Message))
1590     llvm_raise(llvm_ioerror_exn, Message);
1591
1592   return MemBuf;
1593 }
1594
1595 /* llmemorybuffer -> unit */
1596 CAMLprim value llvm_memorybuffer_dispose(LLVMMemoryBufferRef MemBuf) {
1597   LLVMDisposeMemoryBuffer(MemBuf);
1598   return Val_unit;
1599 }
1600
1601 /*===-- Pass Managers -----------------------------------------------------===*/
1602
1603 /* unit -> [ `Module ] PassManager.t */
1604 CAMLprim LLVMPassManagerRef llvm_passmanager_create(value Unit) {
1605   return LLVMCreatePassManager();
1606 }
1607
1608 /* llmodule -> [ `Function ] PassManager.t -> bool */
1609 CAMLprim value llvm_passmanager_run_module(LLVMModuleRef M,
1610                                            LLVMPassManagerRef PM) {
1611   return Val_bool(LLVMRunPassManager(PM, M));
1612 }
1613
1614 /* [ `Function ] PassManager.t -> bool */
1615 CAMLprim value llvm_passmanager_initialize(LLVMPassManagerRef FPM) {
1616   return Val_bool(LLVMInitializeFunctionPassManager(FPM));
1617 }
1618
1619 /* llvalue -> [ `Function ] PassManager.t -> bool */
1620 CAMLprim value llvm_passmanager_run_function(LLVMValueRef F,
1621                                              LLVMPassManagerRef FPM) {
1622   return Val_bool(LLVMRunFunctionPassManager(FPM, F));
1623 }
1624
1625 /* [ `Function ] PassManager.t -> bool */
1626 CAMLprim value llvm_passmanager_finalize(LLVMPassManagerRef FPM) {
1627   return Val_bool(LLVMFinalizeFunctionPassManager(FPM));
1628 }
1629
1630 /* PassManager.any PassManager.t -> unit */
1631 CAMLprim value llvm_passmanager_dispose(LLVMPassManagerRef PM) {
1632   LLVMDisposePassManager(PM);
1633   return Val_unit;
1634 }