[NFC][OCaml] Resolve const and unsigned compilation warnings

[jberdine]

Summary

There are a number of compilation warnings regarding disregarding
const qualifiers, and casting between pointers to integer types with
different sign.

The incompatible sign warnings are due to treating the result of
LLVMGetModuleIdentifier as const unsigned char *, but it is
declared as const char *.

The dropped const qualifiers are due to the code pattern
memcpy(String_val(_),_,_) which ought to be (following the
implementation of the OCaml runtime)
memcpy((char *)String_val(_),_,_). The issue is that String_val is
usually used to get the value of an immutable string. But in the
context of the memcpy calls, the string is in the process of being
initialized, so is not yet constant.

llvm/bindings/ocaml/llvm/llvm_ocaml.h

 |* Note that these functions intentionally take liberties with the CAMLparamX *|
 |* macros, since most of the parameters are not GC heap objects.              *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #ifndef LLVM_LLVM_OCAML_H
 #define LLVM_LLVM_OCAML_H
 
 #include "caml/alloc.h"
 #include "caml/custom.h"
 
 /* Convert a C pointer to an OCaml option */
 CAMLprim value ptr_to_option(void *Ptr);
 
 /* Convert a C string into an OCaml string */
-CAMLprim value cstr_to_string(const unsigned char *Str, mlsize_t Len);
+CAMLprim value cstr_to_string(const char *Str, mlsize_t Len);
 
 #endif // LLVM_LLVM_OCAML_H

llvm/bindings/ocaml/llvm/llvm_ocaml.c

 \*===----------------------------------------------------------------------===*/
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include "llvm-c/Core.h"
 #include "llvm-c/Support.h"
 #include "llvm/Config/llvm-config.h"
 #include "caml/memory.h"
 #include "caml/fail.h"
 #include "caml/callback.h"
 
 #include "llvm_ocaml.h"
 
 value llvm_string_of_message(char* Message) {
   value String = caml_copy_string(Message);
   LLVMDisposeMessage(Message);
 
   return String;
 }
 
 CAMLprim value ptr_to_option(void *Ptr) {
   CAMLparam0();
   CAMLlocal1(Option);
   if (!Ptr)
     CAMLreturn(Val_int(0));
   Option = caml_alloc_small(1, 0);
   Store_field(Option, 0, (value)Ptr);
   CAMLreturn(Option);
 }
 
-CAMLprim value cstr_to_string(const unsigned char *Str, mlsize_t Len) {
+CAMLprim value cstr_to_string(const char *Str, mlsize_t Len) {
   CAMLparam0();
   CAMLlocal1(String);
   if (Str) {
     String = caml_alloc_string(Len);
-    memcpy(String_val(String), Str, Len);
+    memcpy((char *)String_val(String), Str, Len);
   } else {
     String = caml_alloc_string(0);
   }
   CAMLreturn(String);
 }
 
 void llvm_raise(value Prototype, char *Message) {
   CAMLparam1(Prototype);

 }
 
 CAMLprim value llvm_enable_pretty_stacktrace(value Unit) {
   LLVMEnablePrettyStackTrace();
   return Val_unit;
 }
 
 CAMLprim value llvm_parse_command_line_options(value Overview, value Args) {
-  char *COverview;
+  const char *COverview;
   if (Overview == Val_int(0)) {
     COverview = NULL;
   } else {
     COverview = String_val(Field(Overview, 0));
   }
   LLVMParseCommandLineOptions(Wosize_val(Args), (const char* const*) Op_val(Args), COverview);
   return Val_unit;
 }
CAMLprim value llvm_is_string_attr(LLVMAttributeRef A) {
   return Val_int(LLVMIsStringAttribute(A));
 }
 
 /* llattribute -> string */
 CAMLprim value llvm_get_string_attr_kind(LLVMAttributeRef A) {
   unsigned Length;
   const char *String = LLVMGetStringAttributeKind(A, &Length);
   value Result = caml_alloc_string(Length);
-  memcpy(String_val(Result), String, Length);
+  memcpy((char *)String_val(Result), String, Length);
   return Result;
 }
 
 /* llattribute -> string */
 CAMLprim value llvm_get_string_attr_value(LLVMAttributeRef A) {
   unsigned Length;
   const char *String = LLVMGetStringAttributeValue(A, &Length);
   value Result = caml_alloc_string(Length);
-  memcpy(String_val(Result), String, Length);
+  memcpy((char *)String_val(Result), String, Length);
   return Result;
 }
 
 /*===-- Modules -----------------------------------------------------------===*/
 
 /* llcontext -> string -> llmodule */
 CAMLprim LLVMModuleRef llvm_create_module(LLVMContextRef C, value ModuleID) {
   return LLVMModuleCreateWithNameInContext(String_val(ModuleID), C);

 CAMLprim value llvm_get_mdstring(LLVMValueRef V) {
   CAMLparam0();
   CAMLlocal2(Option, Str);
   const char *S;
   unsigned Len;
 
   if ((S = LLVMGetMDString(V, &Len))) {
     Str = caml_alloc_string(Len);
-    memcpy(String_val(Str), S, Len);
+    memcpy((char *)String_val(Str), S, Len);
     Option = alloc(1,0);
     Store_field(Option, 0, Str);
     CAMLreturn(Option);
   }
   CAMLreturn(Val_int(0));
 }
 
 CAMLprim value llvm_get_mdnode_operands(LLVMValueRef V) {
CAMLprim value llvm_string_of_const(LLVMValueRef Const) {
   const char *S;
   size_t Len;
   CAMLparam0();
   CAMLlocal2(Option, Str);
 
   if(LLVMIsAConstantDataSequential(Const) && LLVMIsConstantString(Const)) {
     S = LLVMGetAsString(Const, &Len);
     Str = caml_alloc_string(Len);
-    memcpy(String_val(Str), S, Len);
+    memcpy((char *)String_val(Str), S, Len);
 
     Option = alloc(1, 0);
     Field(Option, 0) = Str;
     CAMLreturn(Option);
   } else {
     CAMLreturn(Val_int(0));
   }
 }
MemBuf = LLVMCreateMemoryBufferWithMemoryRangeCopy(
                 String_val(String), caml_string_length(String), NameCStr);
 
   return MemBuf;
 }
 
 /* llmemorybuffer -> string */
 CAMLprim value llvm_memorybuffer_as_string(LLVMMemoryBufferRef MemBuf) {
   value String = caml_alloc_string(LLVMGetBufferSize(MemBuf));
-  memcpy(String_val(String), LLVMGetBufferStart(MemBuf),
+  memcpy((char *)String_val(String), LLVMGetBufferStart(MemBuf),
          LLVMGetBufferSize(MemBuf));
 
   return String;
 }
 
 /* llmemorybuffer -> unit */
 CAMLprim value llvm_memorybuffer_dispose(LLVMMemoryBufferRef MemBuf) {
   LLVMDisposeMemoryBuffer(MemBuf);