Page MenuHomePhabricator

Please use GitHub pull requests for new patches. Avoid migrating existing patches. Phabricator shutdown timeline

Differential D136400 Diff 496489 llvm/bindings/ocaml/executionengine/executionengine_ocaml.c

Changeset View

Standalone View

View Options

llvm/bindings/ocaml/executionengine/executionengine_ocaml.c

/*===-- executionengine_ocaml.c - LLVM OCaml Glue ---------------*- C++ -*-===*\ /*===-- executionengine_ocaml.c - LLVM OCaml Glue ---------------*- C++ -*-===*\
|* *| |* *|
|* Part of the LLVM Project, under the Apache License v2.0 with LLVM *| |* Part of the LLVM Project, under the Apache License v2.0 with LLVM *|
|* Exceptions. *| |* Exceptions. *|
|* See https://llvm.org/LICENSE.txt for license information. *| |* See https://llvm.org/LICENSE.txt for license information. *|
|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *| |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *|
|* *| |* *|
|*===----------------------------------------------------------------------===*| |*===----------------------------------------------------------------------===*|
|* *| |* *|
|* This file glues LLVM's OCaml interface to its C interface. These functions *| |* This file glues LLVM's OCaml interface to its C interface. These functions *|
|* are by and large transparent wrappers to the corresponding C functions. *| |* are by and large transparent wrappers to the corresponding C functions. *|
|* *| |* *|
|* Note that these functions intentionally take liberties with the CAMLparamX *|
|* macros, since most of the parameters are not GC heap objects. *|
|* *|
\*===----------------------------------------------------------------------===*/ \*===----------------------------------------------------------------------===*/
#include <string.h>
#include <assert.h>
#include "llvm-c/Core.h"
#include "llvm-c/ExecutionEngine.h"
#include "llvm-c/Target.h"
#include "caml/alloc.h" #include "caml/alloc.h"
#include "caml/callback.h"
#include "caml/custom.h" #include "caml/custom.h"
#include "caml/fail.h" #include "caml/fail.h"
#include "caml/memory.h" #include "caml/memory.h"
#include "caml/callback.h" #include "llvm_ocaml.h"
#include "llvm-c/Core.h"
#include "llvm-c/ExecutionEngine.h"
#include "llvm-c/Target.h"
#include <assert.h>
#include <string.h>
#define ExecutionEngine_val(v) ((LLVMExecutionEngineRef)from_val(v))
void llvm_raise(value Prototype, char *Message); void llvm_raise(value Prototype, char *Message);
/* unit -> bool */ /* unit -> bool */
value llvm_ee_initialize(value Unit) { value llvm_ee_initialize(value Unit) {
LLVMLinkInMCJIT(); LLVMLinkInMCJIT();
return Val_bool(!LLVMInitializeNativeTarget() && return Val_bool(!LLVMInitializeNativeTarget() &&
!LLVMInitializeNativeAsmParser() && !LLVMInitializeNativeAsmParser() &&
!LLVMInitializeNativeAsmPrinter()); !LLVMInitializeNativeAsmPrinter());
} }
/* llmodule -> llcompileroption -> ExecutionEngine.t */ /* llcompileroption -> llmodule -> ExecutionEngine.t */
LLVMExecutionEngineRef llvm_ee_create(value OptRecordOpt, LLVMModuleRef M) { value llvm_ee_create(value OptRecordOpt, value M) {
value OptRecord; CAMLparam2(OptRecordOpt, M);
CAMLlocal1(OptRecord);
LLVMExecutionEngineRef MCJIT; LLVMExecutionEngineRef MCJIT;
char *Error; char *Error;
struct LLVMMCJITCompilerOptions Options; struct LLVMMCJITCompilerOptions Options;
LLVMInitializeMCJITCompilerOptions(&Options, sizeof(Options)); LLVMInitializeMCJITCompilerOptions(&Options, sizeof(Options));
if (OptRecordOpt != Val_int(0)) { if (OptRecordOpt != Val_int(0)) {
OptRecord = Field(OptRecordOpt, 0); OptRecord = Field(OptRecordOpt, 0);
Options.OptLevel = Int_val(Field(OptRecord, 0)); Options.OptLevel = Int_val(Field(OptRecord, 0));
Options.CodeModel = Int_val(Field(OptRecord, 1)); Options.CodeModel = Int_val(Field(OptRecord, 1));
Options.NoFramePointerElim = Int_val(Field(OptRecord, 2)); Options.NoFramePointerElim = Int_val(Field(OptRecord, 2));
Options.EnableFastISel = Int_val(Field(OptRecord, 3)); Options.EnableFastISel = Int_val(Field(OptRecord, 3));
Options.MCJMM = NULL; Options.MCJMM = NULL;
} }
if (LLVMCreateMCJITCompilerForModule(&MCJIT, M, &Options, sizeof(Options), if (LLVMCreateMCJITCompilerForModule(&MCJIT, Module_val(M), &Options,
&Error)) sizeof(Options), &Error))
llvm_raise(*caml_named_value("Llvm_executionengine.Error"), Error); llvm_raise(*caml_named_value("Llvm_executionengine.Error"), Error);
return MCJIT; CAMLreturn(to_val(MCJIT));
} }
/* ExecutionEngine.t -> unit */ /* ExecutionEngine.t -> unit */
value llvm_ee_dispose(LLVMExecutionEngineRef EE) { value llvm_ee_dispose(value EE) {
LLVMDisposeExecutionEngine(EE); CAMLparam1(EE);
return Val_unit; LLVMDisposeExecutionEngine(ExecutionEngine_val(EE));
CAMLreturn(Val_unit);
} }
/* llmodule -> ExecutionEngine.t -> unit */ /* llmodule -> ExecutionEngine.t -> unit */
value llvm_ee_add_module(LLVMModuleRef M, LLVMExecutionEngineRef EE) { value llvm_ee_add_module(value M, value EE) {
LLVMAddModule(EE, M); CAMLparam2(M, EE);
return Val_unit; LLVMAddModule(ExecutionEngine_val(EE), Module_val(M));
CAMLreturn(Val_unit);
} }
/* llmodule -> ExecutionEngine.t -> llmodule */ /* llmodule -> ExecutionEngine.t -> llmodule */
value llvm_ee_remove_module(LLVMModuleRef M, LLVMExecutionEngineRef EE) { value llvm_ee_remove_module(value M, value EE) {
CAMLparam2(M, EE);
LLVMModuleRef RemovedModule; LLVMModuleRef RemovedModule;
char *Error; char *Error;
if (LLVMRemoveModule(EE, M, &RemovedModule, &Error)) if (LLVMRemoveModule(ExecutionEngine_val(EE), Module_val(M), &RemovedModule,
&Error))
llvm_raise(*caml_named_value("Llvm_executionengine.Error"), Error); llvm_raise(*caml_named_value("Llvm_executionengine.Error"), Error);
return Val_unit; CAMLreturn(Val_unit);
} }
/* ExecutionEngine.t -> unit */ /* ExecutionEngine.t -> unit */
value llvm_ee_run_static_ctors(LLVMExecutionEngineRef EE) { value llvm_ee_run_static_ctors(value EE) {
LLVMRunStaticConstructors(EE); CAMLparam1(EE);
return Val_unit; LLVMRunStaticConstructors(ExecutionEngine_val(EE));
CAMLreturn(Val_unit);
} }
/* ExecutionEngine.t -> unit */ /* ExecutionEngine.t -> unit */
value llvm_ee_run_static_dtors(LLVMExecutionEngineRef EE) { value llvm_ee_run_static_dtors(value EE) {
LLVMRunStaticDestructors(EE); CAMLparam1(EE);
return Val_unit; LLVMRunStaticDestructors(ExecutionEngine_val(EE));
CAMLreturn(Val_unit);
} }
extern value llvm_alloc_data_layout(LLVMTargetDataRef TargetData); extern value llvm_alloc_data_layout(LLVMTargetDataRef TargetData);
/* ExecutionEngine.t -> Llvm_target.DataLayout.t */ /* ExecutionEngine.t -> Llvm_target.DataLayout.t */
value llvm_ee_get_data_layout(LLVMExecutionEngineRef EE) { value llvm_ee_get_data_layout(value EE) {
value DataLayout; CAMLparam1(EE);
CAMLlocal1(DataLayout);
jberdineUnsubmitted
Not Done
ReplyInline Actions

left over

jberdine: left over
LLVMTargetDataRef OrigDataLayout; LLVMTargetDataRef OrigDataLayout;
char *TargetDataCStr; char *TargetDataCStr;
OrigDataLayout = LLVMGetExecutionEngineTargetData(EE); OrigDataLayout = LLVMGetExecutionEngineTargetData(ExecutionEngine_val(EE));
TargetDataCStr = LLVMCopyStringRepOfTargetData(OrigDataLayout); TargetDataCStr = LLVMCopyStringRepOfTargetData(OrigDataLayout);
DataLayout = llvm_alloc_data_layout(LLVMCreateTargetData(TargetDataCStr)); DataLayout = llvm_alloc_data_layout(LLVMCreateTargetData(TargetDataCStr));
LLVMDisposeMessage(TargetDataCStr); LLVMDisposeMessage(TargetDataCStr);
return DataLayout; CAMLreturn(DataLayout);
} }
/* Llvm.llvalue -> int64 -> llexecutionengine -> unit */ /* Llvm.llvalue -> int64 -> llexecutionengine -> unit */
value llvm_ee_add_global_mapping(LLVMValueRef Global, value Ptr, value llvm_ee_add_global_mapping(value Global, value Ptr, value EE) {
LLVMExecutionEngineRef EE) { CAMLparam3(Global, Ptr, EE);
LLVMAddGlobalMapping(EE, Global, (void *)(Int64_val(Ptr))); LLVMAddGlobalMapping(ExecutionEngine_val(EE), Value_val(Global),
return Val_unit; (void *)(Int64_val(Ptr)));
} CAMLreturn(Val_unit);
}
value llvm_ee_get_global_value_address(value Name, LLVMExecutionEngineRef EE) {
return caml_copy_int64( value llvm_ee_get_global_value_address(value Name, value EE) {
(int64_t)LLVMGetGlobalValueAddress(EE, String_val(Name))); CAMLparam2(Name, EE);
} CAMLreturn(caml_copy_int64((int64_t)LLVMGetGlobalValueAddress(
ExecutionEngine_val(EE), String_val(Name))));
value llvm_ee_get_function_address(value Name, LLVMExecutionEngineRef EE) { }
return caml_copy_int64((int64_t)LLVMGetFunctionAddress(EE, String_val(Name)));
value llvm_ee_get_function_address(value Name, value EE) {
CAMLparam2(Name, EE);
CAMLreturn(caml_copy_int64((int64_t)LLVMGetFunctionAddress(
ExecutionEngine_val(EE), String_val(Name))));
} }