[OCaml] Omit unnecessary GC root registrations

[jberdine]

Summary

The current code does not follow the simple interface to the OCaml GC,
where GC roots are registered conservatively, only initializing
allocations are performed, etc. This is intentional, as stated in the
opening file comments. On the other hand, the current code does
register GC roots in many situations where it is not strictly
necessary. This diff omits many of them.

[jberdine]

I intend to do some additional testing of this, but put this diff up in the meantime for feedback and perhaps also some wider testing.

[vaivaswatha]

Similar to my comment in https://reviews.llvm.org/D99472, I don't understand this a 100%, but it seems sane to me.

Also, let me know if I can help you test these patches in anyway.

[jberdine]

I have been testing this stack of diffs with a sort of stress test that involves running a system that consumes bitcode and uses the ocaml api to traverse and translate it. The testing has used a range of OCaml GC settings in order to make the GC work much harder and trigger much more often than usual (e.g. Gc.set {(Gc.get ()) with minor_heap_size= 1024; space_overhead= 20}). The reasoning here is that if the bindings are not playing nice with the GC, then there is a higher chance to uncover such issues if the GC runs much more often. This testing has not revealed any issues.

@vaivaswatha if it is not too much overhead in your application, it would be helpful if you could arc patch these diffs, add a call to Gc.set as above in your initialization code, and just run your application to see if there are any crashes.

[vaivaswatha]

In D99475#2661044, @jberdine wrote:

I have been testing this stack of diffs with a sort of stress test that involves running a system that consumes bitcode and uses the ocaml api to traverse and translate it. The testing has used a range of OCaml GC settings in order to make the GC work much harder and trigger much more often than usual (e.g. Gc.set {(Gc.get ()) with minor_heap_size= 1024; space_overhead= 20}). The reasoning here is that if the bindings are not playing nice with the GC, then there is a higher chance to uncover such issues if the GC runs much more often. This testing has not revealed any issues.

@vaivaswatha if it is not too much overhead in your application, it would be helpful if you could arc patch these diffs, add a call to Gc.set as above in your initialization code, and just run your application to see if there are any crashes.

@jberdine I'll surely try it out. What do you mean by initialization code? Can you send me an example of where you're setting it (if that's open source), I'll try and mimic that in my application.

btw, if you have GitHub links to the patches here (like you did for your review suggestions for my debuginfo patch), please send that. it's easier to just cherry-pick git commits. Otherwise I'll try arch patch.

[jberdine]

See https://github.com/jberdine/llvm-project/tree/ocaml for this stack on github.

For the init code, I just mean to add that Gc.set call somewhere in your code that uses the LLVM bindings before you do much with Llvm.

[vaivaswatha]

In D99475#2663806, @jberdine wrote:

See https://github.com/jberdine/llvm-project/tree/ocaml for this stack on github.

For the init code, I just mean to add that Gc.set call somewhere in your code that uses the LLVM bindings before you do much with Llvm.

@jberdine I built your branch locally and linked to it from my project that uses LLVM (and its OCaml bindings). I added the call to Gc.set before calling any of the LLVM functions. Everything worked fine and my testsuite succeeded. Let me know if you want me to try out anything else. Thank you.

[jberdine]

Thank you very much @vaivaswatha, that is very helpful!

llvm/bindings/ocaml/llvm/llvm_ocaml.c

 
 CAMLprim value ptr_to_option(void *Ptr) {
   if (!Ptr)
     return Val_none;
   return caml_alloc_some((value)Ptr);
 }
 
 CAMLprim value cstr_to_string(const char *Str, mlsize_t Len) {
-  CAMLparam0();
-  CAMLlocal1(String);
-  if (Str) {
-    String = caml_alloc_string(Len);
-    memcpy((char *)String_val(String), Str, Len);
-  } else {
-    String = caml_alloc_string(0);
-  }
-  CAMLreturn(String);
+  if (!Str)
+    return caml_alloc_string(0);
+  value String = caml_alloc_string(Len);
+  return String;
 }
 
 CAMLprim value cstr_to_string_option(const char *CStr, mlsize_t Len) {
-  CAMLparam0();
-  CAMLlocal1(String);
   if (!CStr)
-    CAMLreturn(Val_none);
-  String = caml_alloc_string(Len);
+    return Val_none;
+  value String = caml_alloc_string(Len);
   memcpy((char *)String_val(String), CStr, Len);
   return caml_alloc_some(String);
 }
 
 void llvm_raise(value Prototype, char *Message) {
-  CAMLparam1(Prototype);
   caml_raise_with_arg(Prototype, llvm_string_of_message(Message));
-  CAMLnoreturn;
 }
 
 static value llvm_fatal_error_handler;
 
 static void llvm_fatal_error_trampoline(const char *Reason) {
   callback(llvm_fatal_error_handler, caml_copy_string(Reason));
 }
 
CAMLprim value llvm_print_module(value Filename, LLVMModuleRef M) {
   if(LLVMPrintModuleToFile(M, String_val(Filename), &Message))
     llvm_raise(*caml_named_value("Llvm.IoError"), Message);
 
   return Val_unit;
 }
 
 /* llmodule -> string */
 CAMLprim value llvm_string_of_llmodule(LLVMModuleRef M) {
-  CAMLparam0();
-  CAMLlocal1(ModuleStr);
-  char* ModuleCStr;
-
-  ModuleCStr = LLVMPrintModuleToString(M);
-  ModuleStr = caml_copy_string(ModuleCStr);
+  char *ModuleCStr = LLVMPrintModuleToString(M);
+  value ModuleStr = caml_copy_string(ModuleCStr);
   LLVMDisposeMessage(ModuleCStr);
 
-  CAMLreturn(ModuleStr);
+  return ModuleStr;
 }
 
 /* llmodule -> string */
 CAMLprim value llvm_get_module_identifier(LLVMModuleRef M) {
   size_t Len;
   const char *Name = LLVMGetModuleIdentifier(M, &Len);
   return cstr_to_string(Name, (mlsize_t)Len);
 }
#else
   caml_raise_with_arg(*caml_named_value("Llvm.FeatureDisabled"),
       caml_copy_string("dump"));
 #endif
   return Val_unit;
 }
 
 /* lltype -> string */
 CAMLprim value llvm_string_of_lltype(LLVMTypeRef M) {
-  CAMLparam0();
-  CAMLlocal1(TypeStr);
-  char* TypeCStr;
-
-  TypeCStr = LLVMPrintTypeToString(M);
-  TypeStr = caml_copy_string(TypeCStr);
+  char *TypeCStr = LLVMPrintTypeToString(M);
+  value TypeStr = caml_copy_string(TypeCStr);
   LLVMDisposeMessage(TypeCStr);
 
-  CAMLreturn(TypeStr);
+  return TypeStr;
 }
 
 /*--... Operations on integer types ........................................--*/
 
 /* llcontext -> lltype */
 CAMLprim LLVMTypeRef llvm_i1_type (LLVMContextRef Context) {
   return LLVMInt1TypeInContext(Context);
 }

 CAMLprim value llvm_is_literal(LLVMTypeRef StructTy) {
   return Val_bool(LLVMIsLiteralStruct(StructTy));
 }
 
 /*--... Operations on array, pointer, and vector types .....................--*/
 
 /* lltype -> lltype array */
 CAMLprim value llvm_subtypes(LLVMTypeRef Ty) {
-  CAMLparam0();
-  CAMLlocal1(Arr);
-
   unsigned Size = LLVMGetNumContainedTypes(Ty);
-
-  Arr = caml_alloc_tuple_uninit(Size);
-
+  value Arr = caml_alloc_tuple_uninit(Size);
   LLVMGetSubtypes(Ty, (LLVMTypeRef *)Op_val(Arr));
-
-  CAMLreturn(Arr);
+  return Arr;
 }
 
 /* lltype -> int -> lltype */
 CAMLprim LLVMTypeRef llvm_array_type(LLVMTypeRef ElementTy, value Count) {
   return LLVMArrayType(ElementTy, Int_val(Count));
 }
 
 /* lltype -> lltype */

 }
 
 /* llcontext -> lltype */
 CAMLprim LLVMTypeRef llvm_x86_mmx_type(LLVMContextRef Context) {
   return LLVMX86MMXTypeInContext(Context);
 }
 
 CAMLprim value llvm_type_by_name(LLVMModuleRef M, value Name) {
-  CAMLparam1(Name);
-  LLVMTypeRef Ty = LLVMGetTypeByName(M, String_val(Name));
-  CAMLreturn(ptr_to_option(Ty));
+  return ptr_to_option(LLVMGetTypeByName(M, String_val(Name)));
 }
 
 /*===-- VALUES ------------------------------------------------------------===*/
 
 /* llvalue -> lltype */
 CAMLprim LLVMTypeRef llvm_type_of(LLVMValueRef Val) {
   return LLVMTypeOf(Val);
 }
enum ValueKind {
   GlobalVariable,
   UndefValue,
   PoisonValue,
   Instruction
 };
 
 /* llvalue -> ValueKind.t */
 #define DEFINE_CASE(Val, Kind) \
-    do {if (LLVMIsA##Kind(Val)) CAMLreturn(Val_int(Kind));} while(0)
+    do {if (LLVMIsA##Kind(Val)) return Val_int(Kind);} while(0)
 
 CAMLprim value llvm_classify_value(LLVMValueRef Val) {
-  CAMLparam0();
-  CAMLlocal1(result);
   if (!Val)
-    CAMLreturn(Val_int(NullValue));
+    return Val_int(NullValue);
   if (LLVMIsAConstant(Val)) {
     DEFINE_CASE(Val, BlockAddress);
     DEFINE_CASE(Val, ConstantAggregateZero);
     DEFINE_CASE(Val, ConstantArray);
     DEFINE_CASE(Val, ConstantDataArray);
     DEFINE_CASE(Val, ConstantDataVector);
     DEFINE_CASE(Val, ConstantExpr);
     DEFINE_CASE(Val, ConstantFP);
     DEFINE_CASE(Val, ConstantInt);
     DEFINE_CASE(Val, ConstantPointerNull);
     DEFINE_CASE(Val, ConstantStruct);
     DEFINE_CASE(Val, ConstantVector);
   }
   if (LLVMIsAInstruction(Val)) {
-    result = caml_alloc_small(1, 0);
+    value result = caml_alloc_small(1, 0);
     Field(result, 0) = Val_int(LLVMGetInstructionOpcode(Val));
-    CAMLreturn(result);
+    return result;
   }
   if (LLVMIsAGlobalValue(Val)) {
     DEFINE_CASE(Val, Function);
     DEFINE_CASE(Val, GlobalAlias);
     DEFINE_CASE(Val, GlobalIFunc);
     DEFINE_CASE(Val, GlobalVariable);
   }
   DEFINE_CASE(Val, Argument);

 /* llvalue -> unit */
 CAMLprim value llvm_dump_value(LLVMValueRef Val) {
   LLVMDumpValue(Val);
   return Val_unit;
 }
 
 /* llvalue -> string */
 CAMLprim value llvm_string_of_llvalue(LLVMValueRef M) {
-  CAMLparam0();
-  CAMLlocal1(ValueStr);
-  char* ValueCStr;
-
-  ValueCStr = LLVMPrintValueToString(M);
-  ValueStr = caml_copy_string(ValueCStr);
+  char *ValueCStr = LLVMPrintValueToString(M);
+  value ValueStr = caml_copy_string(ValueCStr);
   LLVMDisposeMessage(ValueCStr);
 
-  CAMLreturn(ValueStr);
+  return ValueStr;
 }
 
 /* llvalue -> llvalue -> unit */
 CAMLprim value llvm_replace_all_uses_with(LLVMValueRef OldVal,
                                           LLVMValueRef NewVal) {
   LLVMReplaceAllUsesWith(OldVal, NewVal);
   return Val_unit;
 }

 
 /* llvalue -> int */
 CAMLprim value llvm_num_operands(LLVMValueRef V) {
   return Val_int(LLVMGetNumOperands(V));
 }
 
 /* llvalue -> int array */
 CAMLprim value llvm_indices(LLVMValueRef Instr) {
-  CAMLparam0();
-  CAMLlocal1(indices);
   unsigned n = LLVMGetNumIndices(Instr);
   const unsigned *Indices = LLVMGetIndices(Instr);
-  indices = caml_alloc_tuple_uninit(n);
+  value indices = caml_alloc_tuple_uninit(n);
   for (unsigned i = 0; i < n; i++) {
     Op_val(indices)[i] = Val_int(Indices[i]);
   }
-  CAMLreturn(indices);
+  return indices;
 }
 
 /*--... Operations on constants of (mostly) any type .......................--*/
 
 /* llvalue -> bool */
 CAMLprim value llvm_is_constant(LLVMValueRef Val) {
   return Val_bool(LLVMIsConstant(Val));
 }

 
 /* llvalue -> bool */
 CAMLprim value llvm_has_metadata(LLVMValueRef Val) {
   return Val_bool(LLVMHasMetadata(Val));
 }
 
 /* llvalue -> int -> llvalue option */
 CAMLprim value llvm_metadata(LLVMValueRef Val, value MDKindID) {
-  CAMLparam1(MDKindID);
-  CAMLreturn(ptr_to_option(LLVMGetMetadata(Val, Int_val(MDKindID))));
+  return ptr_to_option(LLVMGetMetadata(Val, Int_val(MDKindID)));
 }
 
 /* llvalue -> int -> llvalue -> unit */
 CAMLprim value llvm_set_metadata(LLVMValueRef Val, value MDKindID,
                                  LLVMValueRef MD) {
   LLVMSetMetadata(Val, Int_val(MDKindID), MD);
   return Val_unit;
 }

 /* llvalue -> string option */
 CAMLprim value llvm_get_mdstring(LLVMValueRef V) {
   unsigned Len;
   const char *CStr = LLVMGetMDString(V, &Len);
   return cstr_to_string_option(CStr, Len);
 }
 
 CAMLprim value llvm_get_mdnode_operands(LLVMValueRef V) {
-  CAMLparam0();
-  CAMLlocal1(Operands);
-  unsigned int n;
-
-  n = LLVMGetMDNodeNumOperands(V);
-  Operands = caml_alloc_tuple_uninit(n);
+  unsigned int n = LLVMGetMDNodeNumOperands(V);
+  value Operands = caml_alloc_tuple_uninit(n);
   LLVMGetMDNodeOperands(V, (LLVMValueRef *)Op_val(Operands));
-  CAMLreturn(Operands);
+  return Operands;
 }
 
 /* llmodule -> string -> llvalue array */
 CAMLprim value llvm_get_namedmd(LLVMModuleRef M, value Name) {
   CAMLparam1(Name);
-  CAMLlocal1(Nodes);
-  Nodes = caml_alloc_tuple_uninit(
+  value Nodes = caml_alloc_tuple_uninit(
       LLVMGetNamedMetadataNumOperands(M, String_val(Name)));
   LLVMGetNamedMetadataOperands(M, String_val(Name),
                                (LLVMValueRef *)Op_val(Nodes));
   CAMLreturn(Nodes);
 }
 
 /* llmodule -> string -> llvalue -> unit */
 CAMLprim value llvm_append_namedmd(LLVMModuleRef M, value Name, LLVMValueRef Val) {

 CAMLprim LLVMValueRef llvm_const_float(LLVMTypeRef RealTy, value N) {
   return LLVMConstReal(RealTy, Double_val(N));
 }
 
 /* llvalue -> float */
 CAMLprim value llvm_float_of_const(LLVMValueRef Const) {
   LLVMBool LosesInfo;
   double Result;
-
   if (!LLVMIsAConstantFP(Const))
     return Val_none;
-
   Result = LLVMConstRealGetDouble(Const, &LosesInfo);
   if (LosesInfo)
     return Val_none;
-
   return caml_alloc_some(caml_copy_double(Result));
 }
 
 /* lltype -> string -> llvalue */
 CAMLprim LLVMValueRef llvm_const_float_of_string(LLVMTypeRef RealTy, value S) {
   return LLVMConstRealOfStringAndSize(RealTy, String_val(S),
                                       caml_string_length(S));
 }

 CAMLprim LLVMValueRef llvm_const_intcast(LLVMValueRef CV, LLVMTypeRef T,
                                          value IsSigned) {
   return LLVMConstIntCast(CV, T, Bool_val(IsSigned));
 }
 
 /* llvalue -> int array -> llvalue */
 CAMLprim LLVMValueRef llvm_const_extractvalue(LLVMValueRef Aggregate,
                                               value Indices) {
-  CAMLparam1(Indices);
   int size = Wosize_val(Indices);
   int i;
   LLVMValueRef result;
 
-  unsigned* idxs = (unsigned*)malloc(size * sizeof(unsigned));
+  unsigned *idxs = (unsigned *)malloc(size * sizeof(unsigned));
   for (i = 0; i < size; i++) {
     idxs[i] = Int_val(Field(Indices, i));
   }
 
   result = LLVMConstExtractValue(Aggregate, idxs, size);
   free(idxs);
-  CAMLreturnT(LLVMValueRef, result);
+  return result;
 }
 
 /* llvalue -> llvalue -> int array -> llvalue */
 CAMLprim LLVMValueRef llvm_const_insertvalue(LLVMValueRef Aggregate,
                                              LLVMValueRef Val, value Indices) {
-  CAMLparam1(Indices);
   int size = Wosize_val(Indices);
   int i;
   LLVMValueRef result;
 
-  unsigned* idxs = (unsigned*)malloc(size * sizeof(unsigned));
+  unsigned *idxs = (unsigned *)malloc(size * sizeof(unsigned));
   for (i = 0; i < size; i++) {
     idxs[i] = Int_val(Field(Indices, i));
   }
 
   result = LLVMConstInsertValue(Aggregate, Val, idxs, size);
   free(idxs);
-  CAMLreturnT(LLVMValueRef, result);
+  return result;
 }
 
 /* lltype -> string -> string -> bool -> bool -> llvalue */
 CAMLprim LLVMValueRef llvm_const_inline_asm(LLVMTypeRef Ty, value Asm,
                                      value Constraints, value HasSideEffects,
                                      value IsAlignStack) {
   return LLVMConstInlineAsm(Ty, String_val(Asm), String_val(Constraints),
                             Bool_val(HasSideEffects), Bool_val(IsAlignStack));

 CAMLprim value llvm_set_alignment(value Bytes, LLVMValueRef Global) {
   LLVMSetAlignment(Global, Int_val(Bytes));
   return Val_unit;
 }
 
 /* llvalue -> (llmdkind * llmetadata) array */
 CAMLprim value llvm_global_copy_all_metadata(LLVMValueRef Global) {
   CAMLparam0();
-  CAMLlocal2(Array, Pair);
+  CAMLlocal1(Array);
   size_t NumEntries;
   LLVMValueMetadataEntry *Entries =
       LLVMGlobalCopyAllMetadata(Global, &NumEntries);
   Array = caml_alloc_tuple(NumEntries);
   for (int i = 0; i < NumEntries; i++) {
-    Pair = caml_alloc_small(2, 0);
+    value Pair = caml_alloc_small(2, 0);
     Field(Pair, 0) = Val_int(LLVMValueMetadataEntriesGetKind(Entries, i));
     Field(Pair, 1) = (value)LLVMValueMetadataEntriesGetMetadata(Entries, i);
     Store_field(Array, i, Pair);
   }
   LLVMDisposeValueMetadataEntries(Entries);
   CAMLreturn(Array);
 }
 
if ((GlobalVar = LLVMGetNamedGlobal(M, String_val(Name)))) {
     return GlobalVar;
   }
   return LLVMAddGlobalInAddressSpace(M, Ty, String_val(Name),
                                      Int_val(AddressSpace));
 }
 
 /* string -> llmodule -> llvalue option */
 CAMLprim value llvm_lookup_global(value Name, LLVMModuleRef M) {
-  CAMLparam1(Name);
-  CAMLreturn(ptr_to_option(LLVMGetNamedGlobal(M, String_val(Name))));
+  return ptr_to_option(LLVMGetNamedGlobal(M, String_val(Name)));
 }
 
 /* string -> llvalue -> llmodule -> llvalue */
 CAMLprim LLVMValueRef llvm_define_global(value Name, LLVMValueRef Initializer,
                                          LLVMModuleRef M) {
   LLVMValueRef GlobalVar = LLVMAddGlobal(M, LLVMTypeOf(Initializer),
                                          String_val(Name));
   LLVMSetInitializer(GlobalVar, Initializer);
if (LLVMGetElementType(LLVMTypeOf(Fn)) != Ty)
       return LLVMConstBitCast(Fn, LLVMPointerType(Ty, 0));
     return Fn;
   }
   return LLVMAddFunction(M, String_val(Name), Ty);
 }
 
 /* string -> llmodule -> llvalue option */
 CAMLprim value llvm_lookup_function(value Name, LLVMModuleRef M) {
-  CAMLparam1(Name);
-  CAMLreturn(ptr_to_option(LLVMGetNamedFunction(M, String_val(Name))));
+  return ptr_to_option(LLVMGetNamedFunction(M, String_val(Name)));
 }
 
 /* string -> lltype -> llmodule -> llvalue */
 CAMLprim LLVMValueRef llvm_define_function(value Name, LLVMTypeRef Ty,
                                            LLVMModuleRef M) {
   LLVMValueRef Fn = LLVMAddFunction(M, String_val(Name), Ty);
   LLVMAppendBasicBlockInContext(LLVMGetTypeContext(Ty), Fn, "entry");
   return Fn;

 CAMLprim value llvm_set_function_call_conv(value Id, LLVMValueRef Fn) {
   LLVMSetFunctionCallConv(Fn, Int_val(Id));
   return Val_unit;
 }
 
 /* llvalue -> string option */
 CAMLprim value llvm_gc(LLVMValueRef Fn) {
   const char *GC = LLVMGetGC(Fn);
-
   if (!GC)
     return Val_none;
-
   return caml_alloc_some(caml_copy_string(GC));
 }
 
 /* string option -> llvalue -> unit */
 CAMLprim value llvm_set_gc(value GC, LLVMValueRef Fn) {
   LLVMSetGC(Fn, GC == Val_none ? 0 : String_val(Field(GC, 0)));
   return Val_unit;
 }
LLVMAddIncoming(PhiNode,
                   1);
   return Val_unit;
 }
 
 /* llvalue -> (llvalue * llbasicblock) list */
 CAMLprim value llvm_incoming(LLVMValueRef PhiNode) {
   unsigned I;
   CAMLparam0();
-  CAMLlocal3(Hd, Tl, Tmp);
+  CAMLlocal2(Hd, Tl);
 
   /* Build a tuple list of them. */
   Tl = Val_int(0);
   for (I = LLVMCountIncoming(PhiNode); I != 0;) {
     Hd = caml_alloc_small(2, 0);
     Field(Hd, 0) = (value)LLVMGetIncomingValue(PhiNode, --I);
     Field(Hd, 1) = (value)LLVMGetIncomingBlock(PhiNode, I);
 
-    Tmp = caml_alloc_small(2, 0);
+    value Tmp = caml_alloc_small(2, 0);
     Field(Tmp, 0) = Hd;
     Field(Tmp, 1) = Tl;
     Tl = Tmp;
   }
 
   CAMLreturn(Tl);
 }
 
LLVMAddIncoming(PhiNode, (LLVMValueRef*) &Field(Hd, 0),
                     (LLVMBasicBlockRef*) &Field(Hd, 1), 1);
   }
 
   return PhiNode;
 }
 
 /* lltype -> string -> llbuilder -> value */
 CAMLprim LLVMValueRef llvm_build_empty_phi(LLVMTypeRef Type, value Name, value B) {
-  LLVMValueRef PhiNode;
-
   return LLVMBuildPhi(Builder_val(B), Type, String_val(Name));
-
-  return PhiNode;
 }
 
 /* llvalue -> llvalue array -> string -> llbuilder -> llvalue */
 CAMLprim LLVMValueRef llvm_build_call(LLVMValueRef Fn, value Params,
                                       value Name, value B) {
   return LLVMBuildCall(Builder_val(B), Fn, (LLVMValueRef *) Op_val(Params),
                        Wosize_val(Params), String_val(Name));
 }
CAMLprim LLVMValueRef llvm_build_freeze(LLVMValueRef X,
                                         value Name, value B) {
   return LLVMBuildFreeze(Builder_val(B), X, String_val(Name));
 }
 
 /*===-- Memory buffers ----------------------------------------------------===*/
 
 /* string -> llmemorybuffer
    raises IoError msg on error */
-CAMLprim value llvm_memorybuffer_of_file(value Path) {
-  CAMLparam1(Path);
+CAMLprim LLVMMemoryBufferRef llvm_memorybuffer_of_file(value Path) {
   char *Message;
   LLVMMemoryBufferRef MemBuf;
 
-  if (LLVMCreateMemoryBufferWithContentsOfFile(String_val(Path),
-                                               &MemBuf, &Message))
+  if (LLVMCreateMemoryBufferWithContentsOfFile(String_val(Path), &MemBuf,
+                                               &Message))
     llvm_raise(*caml_named_value("Llvm.IoError"), Message);
 
-  CAMLreturn((value) MemBuf);
+  return MemBuf;
 }
 
 /* unit -> llmemorybuffer
    raises IoError msg on error */
 CAMLprim LLVMMemoryBufferRef llvm_memorybuffer_of_stdin(value Unit) {
   char *Message;
   LLVMMemoryBufferRef MemBuf;