bindings/ocaml/llvm/llvm_ocaml.c

   1 /*===-- llvm_ocaml.h - LLVM Ocaml Glue --------------------------*- C++ -*-===*\
   2 |*                                                                            *|
   3 |*                     The LLVM Compiler Infrastructure                       *|
   4 |*                                                                            *|
   5 |* This file was developed by Gordon Henriksen and is distributed under the   *|
   6 |* University of Illinois Open Source 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/mlvalues.h"
  22 #include "caml/memory.h"
  23 #include "llvm/Config/config.h"
  24 #include <assert.h>
  25
  26
  27 /*===-- Modules -----------------------------------------------------------===*/
  28
  29 /* string -> llmodule */
  30 CAMLprim LLVMModuleRef llvm_create_module(value ModuleID) {
  31   return LLVMModuleCreateWithName(String_val(ModuleID));
  32 }
  33
  34 /* llmodule -> unit */
  35 CAMLprim value llvm_dispose_module(LLVMModuleRef M) {
  36   LLVMDisposeModule(M);
  37   return Val_unit;
  38 }
  39
  40 /* string -> lltype -> llmodule -> bool */
  41 CAMLprim value llvm_add_type_name(value Name, LLVMTypeRef Ty, LLVMModuleRef M) {
  42   int res = LLVMAddTypeName(M, String_val(Name), Ty);
  43   return Val_bool(res == 0);
  44 }
  45
  46 /* string -> llmodule -> unit */
  47 CAMLprim value llvm_delete_type_name(value Name, LLVMModuleRef M) {
  48   LLVMDeleteTypeName(M, String_val(Name));
  49   return Val_unit;
  50 }
  51
  52
  53 /*===-- Types -------------------------------------------------------------===*/
  54
  55 /* lltype -> type_kind */
  56 CAMLprim value llvm_classify_type(LLVMTypeRef Ty) {
  57   return Val_int(LLVMGetTypeKind(Ty));
  58 }
  59
  60 /*--... Operations on integer types ........................................--*/
  61
  62 /* unit -> lltype */
  63 CAMLprim LLVMTypeRef llvm_i1_type (value Unit) { return LLVMInt1Type();  }
  64 CAMLprim LLVMTypeRef llvm_i8_type (value Unit) { return LLVMInt8Type();  }
  65 CAMLprim LLVMTypeRef llvm_i16_type(value Unit) { return LLVMInt16Type(); }
  66 CAMLprim LLVMTypeRef llvm_i32_type(value Unit) { return LLVMInt32Type(); }
  67 CAMLprim LLVMTypeRef llvm_i64_type(value Unit) { return LLVMInt64Type(); }
  68
  69 /* int -> lltype */
  70 CAMLprim LLVMTypeRef llvm_integer_type(value Width) {
  71   return LLVMIntType(Int_val(Width));
  72 }
  73
  74 /* lltype -> int */
  75 CAMLprim value llvm_integer_bitwidth(LLVMTypeRef IntegerTy) {
  76   return Val_int(LLVMGetIntTypeWidth(IntegerTy));
  77 }
  78
  79 /*--... Operations on real types ...........................................--*/
  80
  81 /* unit -> lltype */
  82 CAMLprim LLVMTypeRef llvm_float_type(value Unit) {
  83   return LLVMFloatType();
  84 }
  85
  86 /* unit -> lltype */
  87 CAMLprim LLVMTypeRef llvm_double_type(value Unit) {
  88   return LLVMDoubleType();
  89 }
  90
  91 /* unit -> lltype */
  92 CAMLprim LLVMTypeRef llvm_x86fp80_type(value Unit) {
  93   return LLVMX86FP80Type();
  94 }
  95
  96 /* unit -> lltype */
  97 CAMLprim LLVMTypeRef llvm_fp128_type(value Unit) {
  98   return LLVMFP128Type();
  99 }
 100
 101 /* unit -> lltype */
 102 CAMLprim LLVMTypeRef llvm_ppc_fp128_type(value Unit) {
 103   return LLVMPPCFP128Type();
 104 }
 105
 106 /*--... Operations on function types .......................................--*/
 107
 108 /* lltype -> lltype array -> lltype */
 109 CAMLprim LLVMTypeRef llvm_function_type(LLVMTypeRef RetTy, value ParamTys) {
 110   return LLVMFunctionType(RetTy, (LLVMTypeRef *) ParamTys,
 111                           Wosize_val(ParamTys), 0);
 112 }
 113
 114 /* lltype -> lltype array -> lltype */
 115 CAMLprim LLVMTypeRef llvm_var_arg_function_type(LLVMTypeRef RetTy,
 116                                                 value ParamTys) {
 117   return LLVMFunctionType(RetTy, (LLVMTypeRef *) ParamTys,
 118                           Wosize_val(ParamTys), 1);
 119 }
 120
 121 /* lltype -> bool */
 122 CAMLprim value llvm_is_var_arg(LLVMTypeRef FunTy) {
 123   return Val_bool(LLVMIsFunctionVarArg(FunTy));
 124 }
 125
 126 /* lltype -> lltype array */
 127 CAMLprim value llvm_param_types(LLVMTypeRef FunTy) {
 128   value Tys = alloc(LLVMCountParamTypes(FunTy), 0);
 129   LLVMGetParamTypes(FunTy, (LLVMTypeRef *) Tys);
 130   return Tys;
 131 }
 132
 133 /*--... Operations on struct types .........................................--*/
 134
 135 /* lltype array -> lltype */
 136 CAMLprim LLVMTypeRef llvm_struct_type(value ElementTypes) {
 137   return LLVMStructType((LLVMTypeRef *) ElementTypes,
 138                         Wosize_val(ElementTypes), 0);
 139 }
 140
 141 /* lltype array -> lltype */
 142 CAMLprim LLVMTypeRef llvm_packed_struct_type(value ElementTypes) {
 143   return LLVMStructType((LLVMTypeRef *) ElementTypes,
 144                         Wosize_val(ElementTypes), 1);
 145 }
 146
 147 /* lltype -> lltype array */
 148 CAMLprim value llvm_element_types(LLVMTypeRef StructTy) {
 149   value Tys = alloc(LLVMCountStructElementTypes(StructTy), 0);
 150   LLVMGetStructElementTypes(StructTy, (LLVMTypeRef *) Tys);
 151   return Tys;
 152 }
 153
 154 /* lltype -> bool */
 155 CAMLprim value llvm_is_packed(LLVMTypeRef StructTy) {
 156   return Val_bool(LLVMIsPackedStruct(StructTy));
 157 }
 158
 159 /*--... Operations on array, pointer, and vector types .....................--*/
 160
 161 /* lltype -> int -> lltype */
 162 CAMLprim LLVMTypeRef llvm_array_type(LLVMTypeRef ElementTy, value Count) {
 163   return LLVMArrayType(ElementTy, Int_val(Count));
 164 }
 165
 166 /* lltype -> int -> lltype */
 167 CAMLprim LLVMTypeRef llvm_vector_type(LLVMTypeRef ElementTy, value Count) {
 168   return LLVMVectorType(ElementTy, Int_val(Count));
 169 }
 170
 171 /* lltype -> int */
 172 CAMLprim value llvm_array_length(LLVMTypeRef ArrayTy) {
 173   return Val_int(LLVMGetArrayLength(ArrayTy));
 174 }
 175
 176 /* lltype -> int */
 177 CAMLprim value llvm_vector_size(LLVMTypeRef VectorTy) {
 178   return Val_int(LLVMGetVectorSize(VectorTy));
 179 }
 180
 181 /*--... Operations on other types ..........................................--*/
 182
 183 /* unit -> lltype */
 184 CAMLprim LLVMTypeRef llvm_void_type (value Unit) { return LLVMVoidType();  }
 185 CAMLprim LLVMTypeRef llvm_label_type(value Unit) { return LLVMLabelType(); }
 186
 187 /* unit -> lltype */
 188 CAMLprim LLVMTypeRef llvm_opaque_type(value Unit) {
 189   return LLVMOpaqueType();
 190 }
 191
 192 /*--... Operations on type handles .........................................--*/
 193
 194 #define Typehandle_val(v)  (*(LLVMTypeHandleRef *)(Data_custom_val(v)))
 195
 196 void llvm_finalize_handle(value TH) {
 197   LLVMDisposeTypeHandle(Typehandle_val(TH));
 198 }
 199
 200 static struct custom_operations typehandle_ops = {
 201   (char *) "LLVMTypeHandle",
 202   llvm_finalize_handle,
 203   custom_compare_default,
 204   custom_hash_default,
 205   custom_serialize_default,
 206   custom_deserialize_default
 207 };
 208
 209 CAMLprim value llvm_handle_to_type(LLVMTypeRef PATy) {
 210   value TH = alloc_custom(&typehandle_ops, sizeof(LLVMBuilderRef), 0, 1);
 211   Typehandle_val(TH) = LLVMCreateTypeHandle(PATy);
 212   return TH;
 213 }
 214
 215 CAMLprim LLVMTypeRef llvm_type_of_handle(value TH) {
 216   return LLVMResolveTypeHandle(Typehandle_val(TH));
 217 }
 218
 219 CAMLprim value llvm_refine_type(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy){
 220   LLVMRefineAbstractType(AbstractTy, ConcreteTy);
 221   return Val_unit;
 222 }
 223
 224
 225 /*===-- VALUES ------------------------------------------------------------===*/
 226
 227 /* llvalue -> lltype */
 228 CAMLprim LLVMTypeRef llvm_type_of(LLVMValueRef Val) {
 229   return LLVMTypeOf(Val);
 230 }
 231
 232 /* llvalue -> string */
 233 CAMLprim value llvm_value_name(LLVMValueRef Val) {
 234   return copy_string(LLVMGetValueName(Val));
 235 }
 236
 237 /* string -> llvalue -> unit */
 238 CAMLprim value llvm_set_value_name(value Name, LLVMValueRef Val) {
 239   LLVMSetValueName(Val, String_val(Name));
 240   return Val_unit;
 241 }
 242
 243 /* llvalue -> unit */
 244 CAMLprim value llvm_dump_value(LLVMValueRef Val) {
 245   LLVMDumpValue(Val);
 246   return Val_unit;
 247 }
 248
 249 /*--... Operations on constants of (mostly) any type .......................--*/
 250
 251 /* llvalue -> bool */
 252 CAMLprim value llvm_is_constant(LLVMValueRef Val) {
 253   return Val_bool(LLVMIsConstant(Val));
 254 }
 255
 256 /* llvalue -> bool */
 257 CAMLprim value llvm_is_null(LLVMValueRef Val) {
 258   return Val_bool(LLVMIsNull(Val));
 259 }
 260
 261 /* llvalue -> bool */
 262 CAMLprim value llvm_is_undef(LLVMValueRef Val) {
 263   return Val_bool(LLVMIsUndef(Val));
 264 }
 265
 266 /*--... Operations on scalar constants .....................................--*/
 267
 268 /* lltype -> int -> llvalue */
 269 CAMLprim LLVMValueRef llvm_const_int(LLVMTypeRef IntTy, value N) {
 270   return LLVMConstInt(IntTy, (long long) Int_val(N), 1);
 271 }
 272
 273 /* lltype -> Int64.t -> bool -> llvalue */
 274 CAMLprim LLVMValueRef llvm_const_of_int64(LLVMTypeRef IntTy, value N,
 275                                           value SExt) {
 276   return LLVMConstInt(IntTy, Int64_val(N), Bool_val(SExt));
 277 }
 278
 279 /* lltype -> float -> llvalue */
 280 CAMLprim LLVMValueRef llvm_const_float(LLVMTypeRef RealTy, value N) {
 281   return LLVMConstReal(RealTy, Double_val(N));
 282 }
 283
 284 /*--... Operations on composite constants ..................................--*/
 285
 286 /* string -> llvalue */
 287 CAMLprim LLVMValueRef llvm_const_string(value Str, value NullTerminate) {
 288   return LLVMConstString(String_val(Str), string_length(Str), 1);
 289 }
 290
 291 /* string -> llvalue */
 292 CAMLprim LLVMValueRef llvm_const_stringz(value Str, value NullTerminate) {
 293   return LLVMConstString(String_val(Str), string_length(Str), 0);
 294 }
 295
 296 /* lltype -> llvalue array -> llvalue */
 297 CAMLprim LLVMValueRef llvm_const_array(LLVMTypeRef ElementTy,
 298                                                value ElementVals) {
 299   return LLVMConstArray(ElementTy, (LLVMValueRef*) Op_val(ElementVals),
 300                         Wosize_val(ElementVals));
 301 }
 302
 303 /* llvalue array -> llvalue */
 304 CAMLprim LLVMValueRef llvm_const_struct(value ElementVals) {
 305   return LLVMConstStruct((LLVMValueRef *) Op_val(ElementVals),
 306                          Wosize_val(ElementVals), 0);
 307 }
 308
 309 /* llvalue array -> llvalue */
 310 CAMLprim LLVMValueRef llvm_const_packed_struct(value ElementVals) {
 311   return LLVMConstStruct((LLVMValueRef *) Op_val(ElementVals),
 312                          Wosize_val(ElementVals), 1);
 313 }
 314
 315 /* llvalue array -> llvalue */
 316 CAMLprim LLVMValueRef llvm_const_vector(value ElementVals) {
 317   return LLVMConstVector((LLVMValueRef*) Op_val(ElementVals),
 318                          Wosize_val(ElementVals));
 319 }
 320
 321 /*--... Constant expressions ...............................................--*/
 322
 323 /* int_predicate -> llvalue -> llvalue -> llvalue */
 324 CAMLprim LLVMValueRef llvm_const_icmp(value Pred,
 325                                       LLVMValueRef LHSConstant,
 326                                       LLVMValueRef RHSConstant) {
 327   return LLVMConstICmp(Int_val(Pred) + LLVMIntEQ, LHSConstant, RHSConstant);
 328 }
 329
 330 /* real_predicate -> llvalue -> llvalue -> llvalue */
 331 CAMLprim LLVMValueRef llvm_const_fcmp(value Pred,
 332                                       LLVMValueRef LHSConstant,
 333                                       LLVMValueRef RHSConstant) {
 334   return LLVMConstFCmp(Int_val(Pred), LHSConstant, RHSConstant);
 335 }
 336
 337 /* llvalue -> llvalue array -> llvalue */
 338 CAMLprim LLVMValueRef llvm_const_gep(LLVMValueRef ConstantVal, value Indices) {
 339   return LLVMConstGEP(ConstantVal, (LLVMValueRef*) Op_val(Indices),
 340                       Wosize_val(Indices));
 341 }
 342
 343 /*--... Operations on global variables, functions, and aliases (globals) ...--*/
 344
 345 /* llvalue -> bool */
 346 CAMLprim value llvm_is_declaration(LLVMValueRef Global) {
 347   return Val_bool(LLVMIsDeclaration(Global));
 348 }
 349
 350 /* llvalue -> linkage */
 351 CAMLprim value llvm_linkage(LLVMValueRef Global) {
 352   return Val_int(LLVMGetLinkage(Global));
 353 }
 354
 355 /* linkage -> llvalue -> unit */
 356 CAMLprim value llvm_set_linkage(value Linkage, LLVMValueRef Global) {
 357   LLVMSetLinkage(Global, Int_val(Linkage));
 358   return Val_unit;
 359 }
 360
 361 /* llvalue -> string */
 362 CAMLprim value llvm_section(LLVMValueRef Global) {
 363   return copy_string(LLVMGetSection(Global));
 364 }
 365
 366 /* string -> llvalue -> unit */
 367 CAMLprim value llvm_set_section(value Section, LLVMValueRef Global) {
 368   LLVMSetSection(Global, String_val(Section));
 369   return Val_unit;
 370 }
 371
 372 /* llvalue -> visibility */
 373 CAMLprim value llvm_visibility(LLVMValueRef Global) {
 374   return Val_int(LLVMGetVisibility(Global));
 375 }
 376
 377 /* visibility -> llvalue -> unit */
 378 CAMLprim value llvm_set_visibility(value Viz, LLVMValueRef Global) {
 379   LLVMSetVisibility(Global, Int_val(Viz));
 380   return Val_unit;
 381 }
 382
 383 /* llvalue -> int */
 384 CAMLprim value llvm_alignment(LLVMValueRef Global) {
 385   return Val_int(LLVMGetAlignment(Global));
 386 }
 387
 388 /* int -> llvalue -> unit */
 389 CAMLprim value llvm_set_alignment(value Bytes, LLVMValueRef Global) {
 390   LLVMSetAlignment(Global, Int_val(Bytes));
 391   return Val_unit;
 392 }
 393
 394 /*--... Operations on global variables .....................................--*/
 395
 396 /* lltype -> string -> llmodule -> llvalue */
 397 CAMLprim LLVMValueRef llvm_declare_global(LLVMTypeRef Ty, value Name,
 398                                           LLVMModuleRef M) {
 399   LLVMValueRef GlobalVar;
 400   if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
 401     if (LLVMGetElementType(LLVMTypeOf(GlobalVar)) != Ty)
 402       return LLVMConstBitCast(GlobalVar, LLVMPointerType(Ty));
 403     return GlobalVar;
 404   }
 405   return LLVMAddGlobal(M, Ty, String_val(Name));
 406 }
 407
 408 /* string -> llmodule -> llvalue option */
 409 CAMLprim value llvm_lookup_global(value Name, LLVMModuleRef M) {
 410   CAMLparam1(Name);
 411   LLVMValueRef GlobalVar;
 412   if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
 413     value Option = alloc(1, 0);
 414     Field(Option, 0) = (value) GlobalVar;
 415     CAMLreturn(Option);
 416   }
 417   CAMLreturn(Val_int(0));
 418 }
 419
 420 /* string -> llvalue -> llmodule -> llvalue */
 421 CAMLprim LLVMValueRef llvm_define_global(value Name, LLVMValueRef Initializer,
 422                                          LLVMModuleRef M) {
 423   LLVMValueRef GlobalVar = LLVMAddGlobal(M, LLVMTypeOf(Initializer),
 424                                          String_val(Name));
 425   LLVMSetInitializer(GlobalVar, Initializer);
 426   return GlobalVar;
 427 }
 428
 429 /* llvalue -> unit */
 430 CAMLprim value llvm_delete_global(LLVMValueRef GlobalVar) {
 431   LLVMDeleteGlobal(GlobalVar);
 432   return Val_unit;
 433 }
 434
 435 /* llvalue -> llvalue -> unit */
 436 CAMLprim value llvm_set_initializer(LLVMValueRef ConstantVal,
 437                                     LLVMValueRef GlobalVar) {
 438   LLVMSetInitializer(GlobalVar, ConstantVal);
 439   return Val_unit;
 440 }
 441
 442 /* llvalue -> unit */
 443 CAMLprim value llvm_remove_initializer(LLVMValueRef GlobalVar) {
 444   LLVMSetInitializer(GlobalVar, NULL);
 445   return Val_unit;
 446 }
 447
 448 /* llvalue -> bool */
 449 CAMLprim value llvm_is_thread_local(LLVMValueRef GlobalVar) {
 450   return Val_bool(LLVMIsThreadLocal(GlobalVar));
 451 }
 452
 453 /* bool -> llvalue -> unit */
 454 CAMLprim value llvm_set_thread_local(value IsThreadLocal,
 455                                      LLVMValueRef GlobalVar) {
 456   LLVMSetThreadLocal(GlobalVar, Bool_val(IsThreadLocal));
 457   return Val_unit;
 458 }
 459
 460 /* llvalue -> bool */
 461 CAMLprim value llvm_is_global_constant(LLVMValueRef GlobalVar) {
 462   return Val_bool(LLVMIsGlobalConstant(GlobalVar));
 463 }
 464
 465 /* bool -> llvalue -> unit */
 466 CAMLprim value llvm_set_global_constant(value Flag, LLVMValueRef GlobalVar) {
 467   LLVMSetGlobalConstant(GlobalVar, Bool_val(Flag));
 468   return Val_unit;
 469 }
 470
 471 /*--... Operations on functions ............................................--*/
 472
 473 /* string -> lltype -> llmodule -> llvalue */
 474 CAMLprim LLVMValueRef llvm_declare_function(value Name, LLVMTypeRef Ty,
 475                                             LLVMModuleRef M) {
 476   LLVMValueRef Fn;
 477   if ((Fn = LLVMGetNamedFunction(M, String_val(Name)))) {
 478     if (LLVMGetElementType(LLVMTypeOf(Fn)) != Ty)
 479       return LLVMConstBitCast(Fn, LLVMPointerType(Ty));
 480     return Fn;
 481   }
 482   return LLVMAddFunction(M, String_val(Name), Ty);
 483 }
 484
 485 /* string -> llmodule -> llvalue option */
 486 CAMLprim value llvm_lookup_function(value Name, LLVMModuleRef M) {
 487   CAMLparam1(Name);
 488   LLVMValueRef Fn;
 489   if ((Fn = LLVMGetNamedFunction(M, String_val(Name)))) {
 490     value Option = alloc(1, 0);
 491     Field(Option, 0) = (value) Fn;
 492     CAMLreturn(Option);
 493   }
 494   CAMLreturn(Val_int(0));
 495 }
 496
 497 /* string -> lltype -> llmodule -> llvalue */
 498 CAMLprim LLVMValueRef llvm_define_function(value Name, LLVMTypeRef Ty,
 499                                            LLVMModuleRef M) {
 500   LLVMValueRef Fn = LLVMAddFunction(M, String_val(Name), Ty);
 501   LLVMAppendBasicBlock(Fn, "entry");
 502   return Fn;
 503 }
 504
 505 /* llvalue -> unit */
 506 CAMLprim value llvm_delete_function(LLVMValueRef Fn) {
 507   LLVMDeleteFunction(Fn);
 508   return Val_unit;
 509 }
 510
 511 /* llvalue -> int -> llvalue */
 512 CAMLprim LLVMValueRef llvm_param(LLVMValueRef Fn, value Index) {
 513   return LLVMGetParam(Fn, Int_val(Index));
 514 }
 515
 516 /* llvalue -> int -> llvalue */
 517 CAMLprim value llvm_params(LLVMValueRef Fn, value Index) {
 518   value Params = alloc(LLVMCountParams(Fn), 0);
 519   LLVMGetParams(Fn, (LLVMValueRef *) Op_val(Params));
 520   return Params;
 521 }
 522
 523 /* llvalue -> bool */
 524 CAMLprim value llvm_is_intrinsic(LLVMValueRef Fn) {
 525   return Val_bool(LLVMGetIntrinsicID(Fn));
 526 }
 527
 528 /* llvalue -> int */
 529 CAMLprim value llvm_function_call_conv(LLVMValueRef Fn) {
 530   return Val_int(LLVMGetFunctionCallConv(Fn));
 531 }
 532
 533 /* int -> llvalue -> unit */
 534 CAMLprim value llvm_set_function_call_conv(value Id, LLVMValueRef Fn) {
 535   LLVMSetFunctionCallConv(Fn, Int_val(Id));
 536   return Val_unit;
 537 }
 538
 539 /* llvalue -> string option */
 540 CAMLprim value llvm_collector(LLVMValueRef Fn) {
 541   const char *Collector;
 542   CAMLparam0();
 543   CAMLlocal2(Name, Option);
 544
 545   if ((Collector = LLVMGetCollector(Fn))) {
 546     Name = copy_string(Collector);
 547
 548     Option = alloc(1, 0);
 549     Field(Option, 0) = Name;
 550     CAMLreturn(Option);
 551   } else {
 552     CAMLreturn(Val_int(0));
 553   }
 554 }
 555
 556 /* string option -> llvalue -> unit */
 557 CAMLprim value llvm_set_collector(value GC, LLVMValueRef Fn) {
 558   LLVMSetCollector(Fn, GC == Val_int(0)? 0 : String_val(Field(GC, 0)));
 559   return Val_unit;
 560 }
 561
 562 /*--... Operations on basic blocks .........................................--*/
 563
 564 /* llvalue -> llbasicblock array */
 565 CAMLprim value llvm_basic_blocks(LLVMValueRef Fn) {
 566   value MLArray = alloc(LLVMCountBasicBlocks(Fn), 0);
 567   LLVMGetBasicBlocks(Fn, (LLVMBasicBlockRef *) Op_val(MLArray));
 568   return MLArray;
 569 }
 570
 571 /* llbasicblock -> unit */
 572 CAMLprim value llvm_delete_block(LLVMBasicBlockRef BB) {
 573   LLVMDeleteBasicBlock(BB);
 574   return Val_unit;
 575 }
 576
 577 /* string -> llvalue -> llbasicblock */
 578 CAMLprim LLVMBasicBlockRef llvm_append_block(value Name, LLVMValueRef Fn) {
 579   return LLVMAppendBasicBlock(Fn, String_val(Name));
 580 }
 581
 582 /* string -> llbasicblock -> llbasicblock */
 583 CAMLprim LLVMBasicBlockRef llvm_insert_block(value Name, LLVMBasicBlockRef BB) {
 584   return LLVMInsertBasicBlock(BB, String_val(Name));
 585 }
 586
 587 /* llvalue -> bool */
 588 CAMLprim value llvm_value_is_block(LLVMValueRef Val) {
 589   return Val_bool(LLVMValueIsBasicBlock(Val));
 590 }
 591
 592 /*--... Operations on phi nodes ............................................--*/
 593
 594 /* (llvalue * llbasicblock) -> llvalue -> unit */
 595 CAMLprim value llvm_add_incoming(value Incoming, LLVMValueRef PhiNode) {
 596   LLVMAddIncoming(PhiNode,
 597                   (LLVMValueRef*) &Field(Incoming, 0),
 598                   (LLVMBasicBlockRef*) &Field(Incoming, 1),
 599                   1);
 600   return Val_unit;
 601 }
 602
 603 /* llvalue -> (llvalue * llbasicblock) list */
 604 CAMLprim value llvm_incoming(LLVMValueRef PhiNode) {
 605   unsigned I;
 606   CAMLparam0();
 607   CAMLlocal3(Hd, Tl, Tmp);
 608
 609   /* Build a tuple list of them. */
 610   Tl = Val_int(0);
 611   for (I = LLVMCountIncoming(PhiNode); I != 0; ) {
 612     Hd = alloc(2, 0);
 613     Store_field(Hd, 0, (value) LLVMGetIncomingValue(PhiNode, --I));
 614     Store_field(Hd, 1, (value) LLVMGetIncomingBlock(PhiNode, I));
 615
 616     Tmp = alloc(2, 0);
 617     Store_field(Tmp, 0, Hd);
 618     Store_field(Tmp, 1, Tl);
 619     Tl = Tmp;
 620   }
 621
 622   CAMLreturn(Tl);
 623 }
 624
 625
 626 /*===-- Instruction builders ----------------------------------------------===*/
 627
 628 #define Builder_val(v)  (*(LLVMBuilderRef *)(Data_custom_val(v)))
 629
 630 void llvm_finalize_builder(value B) {
 631   LLVMDisposeBuilder(Builder_val(B));
 632 }
 633
 634 static struct custom_operations builder_ops = {
 635   (char *) "LLVMBuilder",
 636   llvm_finalize_builder,
 637   custom_compare_default,
 638   custom_hash_default,
 639   custom_serialize_default,
 640   custom_deserialize_default
 641 };
 642
 643 /* llvalue -> llbuilder */
 644 CAMLprim value llvm_builder_before(LLVMValueRef Inst) {
 645   value V;
 646   LLVMBuilderRef B = LLVMCreateBuilder();
 647   LLVMPositionBuilderBefore(B, Inst);
 648   V = alloc_custom(&builder_ops, sizeof(LLVMBuilderRef), 0, 1);
 649   Builder_val(V) = B;
 650   return V;
 651 }
 652
 653 /* llbasicblock -> llbuilder */
 654 CAMLprim value llvm_builder_at_end(LLVMBasicBlockRef BB) {
 655   value V;
 656   LLVMBuilderRef B = LLVMCreateBuilder();
 657   LLVMPositionBuilderAtEnd(B, BB);
 658   V = alloc_custom(&builder_ops, sizeof(LLVMBuilderRef), 0, 1);
 659   Builder_val(V) = B;
 660   return V;
 661 }
 662
 663 /* llvalue -> llbuilder -> unit */
 664 CAMLprim value llvm_position_before(LLVMValueRef Inst, value B) {
 665   LLVMPositionBuilderBefore(Builder_val(B), Inst);
 666   return Val_unit;
 667 }
 668
 669 /* llbasicblock -> llbuilder -> unit */
 670 CAMLprim value llvm_position_at_end(LLVMBasicBlockRef BB, value B) {
 671   LLVMPositionBuilderAtEnd(Builder_val(B), BB);
 672   return Val_unit;
 673 }
 674
 675 /*--... Terminators ........................................................--*/
 676
 677 /* llbuilder -> llvalue */
 678 CAMLprim LLVMValueRef llvm_build_ret_void(value B) {
 679   return LLVMBuildRetVoid(Builder_val(B));
 680 }
 681
 682 /* llvalue -> llbuilder -> llvalue */
 683 CAMLprim LLVMValueRef llvm_build_ret(LLVMValueRef Val, value B) {
 684   return LLVMBuildRet(Builder_val(B), Val);
 685 }
 686
 687 /* llbasicblock -> llbuilder -> llvalue */
 688 CAMLprim LLVMValueRef llvm_build_br(LLVMBasicBlockRef BB, value B) {
 689   return LLVMBuildBr(Builder_val(B), BB);
 690 }
 691
 692 /* llvalue -> llbasicblock -> llbasicblock -> llbuilder -> llvalue */
 693 CAMLprim LLVMValueRef llvm_build_cond_br(LLVMValueRef If,
 694                                          LLVMBasicBlockRef Then,
 695                                          LLVMBasicBlockRef Else,
 696                                          value B) {
 697   return LLVMBuildCondBr(Builder_val(B), If, Then, Else);
 698 }
 699
 700 /* llvalue -> llbasicblock -> int -> llbuilder -> llvalue */
 701 CAMLprim LLVMValueRef llvm_build_switch(LLVMValueRef Of,
 702                                         LLVMBasicBlockRef Else,
 703                                         value EstimatedCount,
 704                                         value B) {
 705   return LLVMBuildSwitch(Builder_val(B), Of, Else, Int_val(EstimatedCount));
 706 }
 707
 708 /* llvalue -> llvalue array -> llbasicblock -> llbasicblock -> string ->
 709    llbuilder -> llvalue */
 710 CAMLprim LLVMValueRef llvm_build_invoke_nat(LLVMValueRef Fn, value Args,
 711                                             LLVMBasicBlockRef Then,
 712                                             LLVMBasicBlockRef Catch,
 713                                             value Name, value B) {
 714   return LLVMBuildInvoke(Builder_val(B), Fn, (LLVMValueRef *) Op_val(Args),
 715                          Wosize_val(Args), Then, Catch, String_val(Name));
 716 }
 717
 718 /* llvalue -> llvalue array -> llbasicblock -> llbasicblock -> string ->
 719    llbuilder -> llvalue */
 720 CAMLprim LLVMValueRef llvm_build_invoke_bc(value Args[], int NumArgs) {
 721   return llvm_build_invoke_nat((LLVMValueRef) Args[0], Args[1],
 722                                (LLVMBasicBlockRef) Args[2],
 723                                (LLVMBasicBlockRef) Args[3],
 724                                Args[4], Args[5]);
 725 }
 726
 727 /* llbuilder -> llvalue */
 728 CAMLprim LLVMValueRef llvm_build_unwind(value B) {
 729   return LLVMBuildUnwind(Builder_val(B));
 730 }
 731
 732 /* llbuilder -> llvalue */
 733 CAMLprim LLVMValueRef llvm_build_unreachable(value B) {
 734   return LLVMBuildUnreachable(Builder_val(B));
 735 }
 736
 737 /*--... Arithmetic .........................................................--*/
 738
 739 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 740 CAMLprim LLVMValueRef llvm_build_add(LLVMValueRef LHS, LLVMValueRef RHS,
 741                                      value Name, value B) {
 742   return LLVMBuildAdd(Builder_val(B), LHS, RHS, String_val(Name));
 743 }
 744
 745 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 746 CAMLprim LLVMValueRef llvm_build_sub(LLVMValueRef LHS, LLVMValueRef RHS,
 747                                      value Name, value B) {
 748   return LLVMBuildSub(Builder_val(B), LHS, RHS, String_val(Name));
 749 }
 750
 751 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 752 CAMLprim LLVMValueRef llvm_build_mul(LLVMValueRef LHS, LLVMValueRef RHS,
 753                                      value Name, value B) {
 754   return LLVMBuildMul(Builder_val(B), LHS, RHS, String_val(Name));
 755 }
 756
 757 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 758 CAMLprim LLVMValueRef llvm_build_udiv(LLVMValueRef LHS, LLVMValueRef RHS,
 759                                       value Name, value B) {
 760   return LLVMBuildUDiv(Builder_val(B), LHS, RHS, String_val(Name));
 761 }
 762
 763 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 764 CAMLprim LLVMValueRef llvm_build_sdiv(LLVMValueRef LHS, LLVMValueRef RHS,
 765                                       value Name, value B) {
 766   return LLVMBuildSDiv(Builder_val(B), LHS, RHS, String_val(Name));
 767 }
 768
 769 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 770 CAMLprim LLVMValueRef llvm_build_fdiv(LLVMValueRef LHS, LLVMValueRef RHS,
 771                                       value Name, value B) {
 772   return LLVMBuildFDiv(Builder_val(B), LHS, RHS, String_val(Name));
 773 }
 774
 775 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 776 CAMLprim LLVMValueRef llvm_build_urem(LLVMValueRef LHS, LLVMValueRef RHS,
 777                                       value Name, value B) {
 778   return LLVMBuildURem(Builder_val(B), LHS, RHS, String_val(Name));
 779 }
 780
 781 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 782 CAMLprim LLVMValueRef llvm_build_srem(LLVMValueRef LHS, LLVMValueRef RHS,
 783                                       value Name, value B) {
 784   return LLVMBuildSRem(Builder_val(B), LHS, RHS, String_val(Name));
 785 }
 786
 787 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 788 CAMLprim LLVMValueRef llvm_build_frem(LLVMValueRef LHS, LLVMValueRef RHS,
 789                                       value Name, value B) {
 790   return LLVMBuildFRem(Builder_val(B), LHS, RHS, String_val(Name));
 791 }
 792
 793 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 794 CAMLprim LLVMValueRef llvm_build_shl(LLVMValueRef LHS, LLVMValueRef RHS,
 795                                      value Name, value B) {
 796   return LLVMBuildShl(Builder_val(B), LHS, RHS, String_val(Name));
 797 }
 798
 799 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 800 CAMLprim LLVMValueRef llvm_build_lshr(LLVMValueRef LHS, LLVMValueRef RHS,
 801                                       value Name, value B) {
 802   return LLVMBuildLShr(Builder_val(B), LHS, RHS, String_val(Name));
 803 }
 804
 805 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 806 CAMLprim LLVMValueRef llvm_build_ashr(LLVMValueRef LHS, LLVMValueRef RHS,
 807                                       value Name, value B) {
 808   return LLVMBuildAShr(Builder_val(B), LHS, RHS, String_val(Name));
 809 }
 810
 811 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 812 CAMLprim LLVMValueRef llvm_build_and(LLVMValueRef LHS, LLVMValueRef RHS,
 813                                      value Name, value B) {
 814   return LLVMBuildAnd(Builder_val(B), LHS, RHS, String_val(Name));
 815 }
 816
 817 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 818 CAMLprim LLVMValueRef llvm_build_or(LLVMValueRef LHS, LLVMValueRef RHS,
 819                                     value Name, value B) {
 820   return LLVMBuildOr(Builder_val(B), LHS, RHS, String_val(Name));
 821 }
 822
 823 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
 824 CAMLprim LLVMValueRef llvm_build_xor(LLVMValueRef LHS, LLVMValueRef RHS,
 825                                      value Name, value B) {
 826   return LLVMBuildXor(Builder_val(B), LHS, RHS, String_val(Name));
 827 }
 828
 829 /* llvalue -> string -> llbuilder -> llvalue */
 830 CAMLprim LLVMValueRef llvm_build_neg(LLVMValueRef X,
 831                                      value Name, value B) {
 832   return LLVMBuildNeg(Builder_val(B), X, String_val(Name));
 833 }
 834
 835 /* llvalue -> string -> llbuilder -> llvalue */
 836 CAMLprim LLVMValueRef llvm_build_not(LLVMValueRef X,
 837                                      value Name, value B) {
 838   return LLVMBuildNot(Builder_val(B), X, String_val(Name));
 839 }
 840
 841 /*--... Memory .............................................................--*/
 842
 843 /* lltype -> string -> llbuilder -> llvalue */
 844 CAMLprim LLVMValueRef llvm_build_malloc(LLVMTypeRef Ty,
 845                                         value Name, value B) {
 846   return LLVMBuildMalloc(Builder_val(B), Ty, String_val(Name));
 847 }
 848
 849 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
 850 CAMLprim LLVMValueRef llvm_build_array_malloc(LLVMTypeRef Ty, LLVMValueRef Size,
 851                                               value Name, value B) {
 852   return LLVMBuildArrayMalloc(Builder_val(B), Ty, Size, String_val(Name));
 853 }
 854
 855 /* lltype -> string -> llbuilder -> llvalue */
 856 CAMLprim LLVMValueRef llvm_build_alloca(LLVMTypeRef Ty,
 857                                         value Name, value B) {
 858   return LLVMBuildAlloca(Builder_val(B), Ty, String_val(Name));
 859 }
 860
 861 /* lltype -> llvalue -> string -> llbuilder -> llvalue */
 862 CAMLprim LLVMValueRef llvm_build_array_alloca(LLVMTypeRef Ty, LLVMValueRef Size,
 863                                               value Name, value B) {
 864   return LLVMBuildArrayAlloca(Builder_val(B), Ty, Size, String_val(Name));
 865 }
 866
 867 /* llvalue -> llbuilder -> llvalue */
 868 CAMLprim LLVMValueRef llvm_build_free(LLVMValueRef Pointer, value B) {
 869   return LLVMBuildFree(Builder_val(B), Pointer);
 870 }
 871
 872 /* llvalue -> string -> llbuilder -> llvalue */
 873 CAMLprim LLVMValueRef llvm_build_load(LLVMValueRef Pointer,
 874                                       value Name, value B) {
 875   return LLVMBuildLoad(Builder_val(B), Pointer, String_val(Name));
 876 }
 877
 878 /* llvalue -> llvalue -> llbuilder -> llvalue */
 879 CAMLprim LLVMValueRef llvm_build_store(LLVMValueRef Value, LLVMValueRef Pointer,
 880                                        value B) {
 881   return LLVMBuildStore(Builder_val(B), Value, Pointer);
 882 }
 883
 884 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
 885 CAMLprim LLVMValueRef llvm_build_gep(LLVMValueRef Pointer, value Indices,
 886                                      value Name, value B) {
 887   return LLVMBuildGEP(Builder_val(B), Pointer,
 888                       (LLVMValueRef *) Op_val(Indices), Wosize_val(Indices),
 889                       String_val(Name));
 890 }
 891
 892 /*--... Casts ..............................................................--*/
 893
 894 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 895 CAMLprim LLVMValueRef llvm_build_trunc(LLVMValueRef X, LLVMTypeRef Ty,
 896                                        value Name, value B) {
 897   return LLVMBuildTrunc(Builder_val(B), X, Ty, String_val(Name));
 898 }
 899
 900 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 901 CAMLprim LLVMValueRef llvm_build_zext(LLVMValueRef X, LLVMTypeRef Ty,
 902                                       value Name, value B) {
 903   return LLVMBuildZExt(Builder_val(B), X, Ty, String_val(Name));
 904 }
 905
 906 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 907 CAMLprim LLVMValueRef llvm_build_sext(LLVMValueRef X, LLVMTypeRef Ty,
 908                                       value Name, value B) {
 909   return LLVMBuildSExt(Builder_val(B), X, Ty, String_val(Name));
 910 }
 911
 912 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 913 CAMLprim LLVMValueRef llvm_build_fptoui(LLVMValueRef X, LLVMTypeRef Ty,
 914                                         value Name, value B) {
 915   return LLVMBuildFPToUI(Builder_val(B), X, Ty, String_val(Name));
 916 }
 917
 918 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 919 CAMLprim LLVMValueRef llvm_build_fptosi(LLVMValueRef X, LLVMTypeRef Ty,
 920                                         value Name, value B) {
 921   return LLVMBuildFPToSI(Builder_val(B), X, Ty, String_val(Name));
 922 }
 923
 924 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 925 CAMLprim LLVMValueRef llvm_build_uitofp(LLVMValueRef X, LLVMTypeRef Ty,
 926                                         value Name, value B) {
 927   return LLVMBuildUIToFP(Builder_val(B), X, Ty, String_val(Name));
 928 }
 929
 930 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 931 CAMLprim LLVMValueRef llvm_build_sitofp(LLVMValueRef X, LLVMTypeRef Ty,
 932                                         value Name, value B) {
 933   return LLVMBuildSIToFP(Builder_val(B), X, Ty, String_val(Name));
 934 }
 935
 936 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 937 CAMLprim LLVMValueRef llvm_build_fptrunc(LLVMValueRef X, LLVMTypeRef Ty,
 938                                          value Name, value B) {
 939   return LLVMBuildFPTrunc(Builder_val(B), X, Ty, String_val(Name));
 940 }
 941
 942 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 943 CAMLprim LLVMValueRef llvm_build_fpext(LLVMValueRef X, LLVMTypeRef Ty,
 944                                        value Name, value B) {
 945   return LLVMBuildFPExt(Builder_val(B), X, Ty, String_val(Name));
 946 }
 947
 948 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 949 CAMLprim LLVMValueRef llvm_build_prttoint(LLVMValueRef X, LLVMTypeRef Ty,
 950                                           value Name, value B) {
 951   return LLVMBuildPtrToInt(Builder_val(B), X, Ty, String_val(Name));
 952 }
 953
 954 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 955 CAMLprim LLVMValueRef llvm_build_inttoptr(LLVMValueRef X, LLVMTypeRef Ty,
 956                                           value Name, value B) {
 957   return LLVMBuildIntToPtr(Builder_val(B), X, Ty, String_val(Name));
 958 }
 959
 960 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
 961 CAMLprim LLVMValueRef llvm_build_bitcast(LLVMValueRef X, LLVMTypeRef Ty,
 962                                          value Name, value B) {
 963   return LLVMBuildBitCast(Builder_val(B), X, Ty, String_val(Name));
 964 }
 965
 966 /*--... Comparisons ........................................................--*/
 967
 968 /* int_predicate -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 969 CAMLprim LLVMValueRef llvm_build_icmp(value Pred,
 970                                       LLVMValueRef LHS, LLVMValueRef RHS,
 971                                       value Name, value B) {
 972   return LLVMBuildICmp(Builder_val(B), Int_val(Pred) + LLVMIntEQ, LHS, RHS,
 973                        String_val(Name));
 974 }
 975
 976 /* real_predicate -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
 977 CAMLprim LLVMValueRef llvm_build_fcmp(value Pred,
 978                                       LLVMValueRef LHS, LLVMValueRef RHS,
 979                                       value Name, value B) {
 980   return LLVMBuildFCmp(Builder_val(B), Int_val(Pred), LHS, RHS,
 981                        String_val(Name));
 982 }
 983
 984 /*--... Miscellaneous instructions .........................................--*/
 985
 986 /* (llvalue * llbasicblock) list -> string -> llbuilder -> llvalue */
 987 CAMLprim LLVMValueRef llvm_build_phi(value Incoming, value Name, value B) {
 988   value Hd, Tl;
 989   LLVMValueRef FirstValue, PhiNode;
 990
 991   assert(Incoming != Val_int(0) && "Empty list passed to Llvm.build_phi!");
 992
 993   Hd = Field(Incoming, 0);
 994   FirstValue = (LLVMValueRef) Field(Hd, 0);
 995   PhiNode = LLVMBuildPhi(Builder_val(B), LLVMTypeOf(FirstValue),
 996                          String_val(Name));
 997
 998   for (Tl = Incoming; Tl != Val_int(0); Tl = Field(Tl, 1)) {
 999     value Hd = Field(Tl, 0);
1000     LLVMAddIncoming(PhiNode, (LLVMValueRef*) &Field(Hd, 0),
1001                     (LLVMBasicBlockRef*) &Field(Hd, 1), 1);
1002   }
1003
1004   return PhiNode;
1005 }
1006
1007 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
1008 CAMLprim LLVMValueRef llvm_build_call(LLVMValueRef Fn, value Params,
1009                                       value Name, value B) {
1010   return LLVMBuildCall(Builder_val(B), Fn, (LLVMValueRef *) Op_val(Params),
1011                        Wosize_val(Params), String_val(Name));
1012 }
1013
1014 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
1015 CAMLprim LLVMValueRef llvm_build_select(LLVMValueRef If,
1016                                         LLVMValueRef Then, LLVMValueRef Else,
1017                                         value Name, value B) {
1018   return LLVMBuildSelect(Builder_val(B), If, Then, Else, String_val(Name));
1019 }
1020
1021 /* llvalue -> lltype -> string -> llbuilder -> llvalue */
1022 CAMLprim LLVMValueRef llvm_build_va_arg(LLVMValueRef List, LLVMTypeRef Ty,
1023                                         value Name, value B) {
1024   return LLVMBuildVAArg(Builder_val(B), List, Ty, String_val(Name));
1025 }
1026
1027 /* llvalue -> llvalue -> string -> llbuilder -> llvalue */
1028 CAMLprim LLVMValueRef llvm_build_extractelement(LLVMValueRef Vec,
1029                                                 LLVMValueRef Idx,
1030                                                 value Name, value B) {
1031   return LLVMBuildExtractElement(Builder_val(B), Vec, Idx, String_val(Name));
1032 }
1033
1034 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
1035 CAMLprim LLVMValueRef llvm_build_insertelement(LLVMValueRef Vec,
1036                                                LLVMValueRef Element,
1037                                                LLVMValueRef Idx,
1038                                                value Name, value B) {
1039   return LLVMBuildInsertElement(Builder_val(B), Vec, Element, Idx,
1040                                 String_val(Name));
1041 }
1042
1043 /* llvalue -> llvalue -> llvalue -> string -> llbuilder -> llvalue */
1044 CAMLprim LLVMValueRef llvm_build_shufflevector(LLVMValueRef V1, LLVMValueRef V2,
1045                                                LLVMValueRef Mask,
1046                                                value Name, value B) {
1047   return LLVMBuildShuffleVector(Builder_val(B), V1, V2, Mask, String_val(Name));
1048 }
1049