[OCaml] Add OCaml API for __cxa_demangle

[jberdine]

Summary

Adds a demangle function to the OCaml API to expose the internal
implementation of __cxa_demangle. This is useful for OCaml clients
which would not otherwise link to libstdc++.

[whitequark]

I'm not sure if this function has a place here. It's not a function provided by the LLVM API, and it's platform-specific. I think with this change it would not be possible to build the OCaml bindings under MSVC, for example.

[erik.pilkington]

Using the copy of the demangler in LLVMDemangle would solve the issues @whitequark brought up, FWIW.

[jberdine]

Thanks for the suggestion @erik.pilkington. I assume you mean to call the itaniumDemangle function declared in include/llvm/Demangle/Demanagle.h. Since that is in the llvm namespace, it would need a shim extern C function in C++ to call from the OCaml bindings. It's not clear to me that such a function would be welcome in e.g. lib/IR/Core.cpp. There could be other options I'm overlooking. My brief experiments adding some C++ code under bindings/ocaml all failed to compile, but maybe there is some build system magic that would make that work. But since it is possible for clients of the OCaml API to call __cxa_demangle without exposing it here, maybe @whitequark is right that it doesn't fit.

bindings/ocaml/llvm/llvm.ml

 external set_visibility : Visibility.t -> llvalue -> unit = "llvm_set_visibility"
 external dll_storage_class : llvalue -> DLLStorageClass.t = "llvm_dll_storage_class"
 external set_dll_storage_class : DLLStorageClass.t -> llvalue -> unit = "llvm_set_dll_storage_class"
 external alignment : llvalue -> int = "llvm_alignment"
 external set_alignment : int -> llvalue -> unit = "llvm_set_alignment"
 external is_global_constant : llvalue -> bool = "llvm_is_global_constant"
 external set_global_constant : bool -> llvalue -> unit
                              = "llvm_set_global_constant"
+external demangle : string -> string = "llvm_demangle"
 
 (*--... Operations on global variables .....................................--*)
 external declare_global : lltype -> string -> llmodule -> llvalue
                         = "llvm_declare_global"
 external declare_qualified_global : lltype -> string -> int -> llmodule ->
                                     llvalue
                                   = "llvm_declare_qualified_global"
 external define_global : string -> llvalue -> llmodule -> llvalue

bindings/ocaml/llvm/llvm.mli

 (** [alignment g] returns the required alignment of the global value [g].
     See the method [llvm::GlobalValue::getAlignment]. *)
 val alignment : llvalue -> int
 
 (** [set_alignment n g] sets the required alignment of the global value [g] to
     [n] bytes. See the method [llvm::GlobalValue::setAlignment]. *)
 val set_alignment : int -> llvalue -> unit
 
+(** [demangle s] is the demangled form of [s], obtained from [__cxa_demangle]. *)
+val demangle : string -> string
+
 
 (** {7 Operations on global variables} *)
 
 (** [declare_global ty name m] returns a new global variable of type [ty] and
     with name [name] in module [m] in the default address space (0). If such a
     global variable already exists, it is returned. If the type of the existing
     global differs, then a bitcast to [ty] is returned. *)
 val declare_global : lltype -> string -> llmodule -> llvalue

bindings/ocaml/llvm/llvm_ocaml.c

CAMLprim value llvm_get_debug_loc_line(LLVMValueRef Inst) {
   return Val_int(LLVMGetDebugLocLine(Inst));
 }
 
 /* llvalue -> int */
 CAMLprim value llvm_get_debug_loc_column(LLVMValueRef Inst) {
   return Val_int(LLVMGetDebugLocColumn(Inst));
 }
 
-
 /*--... Operations on metadata .............................................--*/
 
 /* llcontext -> string -> llvalue */
 CAMLprim LLVMValueRef llvm_mdstring(LLVMContextRef C, value S) {
   return LLVMMDStringInContext(C, String_val(S), caml_string_length(S));
 }
 
 /* llcontext -> llvalue array -> llvalue */

 }
 
 /* int -> llvalue -> unit */
 CAMLprim value llvm_set_alignment(value Bytes, LLVMValueRef Global) {
   LLVMSetAlignment(Global, Int_val(Bytes));
   return Val_unit;
 }
 
+extern char *__cxa_demangle(const char *, char *, size_t *, int *);
+
+/* string -> string */
+CAMLprim value llvm_demangle(value Mangled) {
+  int status;
+  char *demangled = __cxa_demangle(String_val(Mangled), NULL, NULL, &status);
+  if (demangled) {
+      return(caml_copy_string(demangled));
+  } else {
+    return caml_copy_string("");
+  }
+}
+
 /*--... Operations on uses .................................................--*/
 
 /* llvalue -> lluse option */
 CAMLprim value llvm_use_begin(LLVMValueRef Val) {
   CAMLparam0();
   LLVMUseRef First;
   if ((First = LLVMGetFirstUse(Val))) {
     value Option = alloc(1, 0);

 
 /* llvalue -> llvalue */
 CAMLprim LLVMValueRef llvm_instr_clone(LLVMValueRef Inst) {
   if (!LLVMIsAInstruction(Inst))
       failwith("Not an instruction");
   return LLVMInstructionClone(Inst);
 }
 
-
 /*--... Operations on call sites ...........................................--*/
 
 /* llvalue -> int */
 CAMLprim value llvm_instruction_call_conv(LLVMValueRef Inst) {
   return Val_int(LLVMGetInstructionCallConv(Inst));
 }
 
 /* int -> llvalue -> unit */

 }
 
 /* llbuilder -> llvalue -> unit */
 CAMLprim value llvm_set_inst_debug_location(value B, LLVMValueRef V) {
   LLVMSetInstDebugLocation(Builder_val(B), V);
   return Val_unit;
 }
 
-
 /*--... Terminators ........................................................--*/
 
 /* llbuilder -> llvalue */
 CAMLprim LLVMValueRef llvm_build_ret_void(value B) {
   return LLVMBuildRetVoid(Builder_val(B));
 }
 
 /* llvalue -> llbuilder -> llvalue */