void jit_bind_fn(const char *name, void *ptr)
{
if (using_jit) {
LLVMValueRef fn;
if (LLVMFindFunction(exec_engine, name, &fn))
return;
LLVMAddGlobalMapping(exec_engine, fn, ptr);
}
}
SWIGEXPORT void JNICALL Java_org_jllvm_bindings_ExecutionEngineJNI_LLVMAddGlobalMapping(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) {
LLVMExecutionEngineRef arg1 = (LLVMExecutionEngineRef) 0 ;
LLVMValueRef arg2 = (LLVMValueRef) 0 ;
void *arg3 = (void *) 0 ;
(void)jenv;
(void)jcls;
arg1 = *(LLVMExecutionEngineRef *)&jarg1;
arg2 = *(LLVMValueRef *)&jarg2;
arg3 = *(void **)&jarg3;
LLVMAddGlobalMapping(arg1,arg2,arg3);
}
/**
* lp_build_assert.
*
* Build an assertion in LLVM IR by building a function call to the
* lp_assert() function above.
*
* \param condition should be an 'i1' or 'i32' value
* \param msg a string to print if the assertion fails.
*/
LLVMValueRef
lp_build_assert(LLVMBuilderRef builder, LLVMValueRef condition,
const char *msg)
{
LLVMModuleRef module;
LLVMTypeRef arg_types[2];
LLVMValueRef msg_string, assert_func, params[2], r;
module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(
LLVMGetInsertBlock(builder)));
msg_string = lp_build_const_string_variable(module, msg, strlen(msg) + 1);
arg_types[0] = LLVMInt32Type();
arg_types[1] = LLVMPointerType(LLVMInt8Type(), 0);
/* lookup the lp_assert function */
assert_func = LLVMGetNamedFunction(module, "lp_assert");
/* Create the assertion function if not found */
if (!assert_func) {
LLVMTypeRef func_type =
LLVMFunctionType(LLVMVoidType(), arg_types, 2, 0);
assert_func = LLVMAddFunction(module, "lp_assert", func_type);
LLVMSetFunctionCallConv(assert_func, LLVMCCallConv);
LLVMSetLinkage(assert_func, LLVMExternalLinkage);
LLVMAddGlobalMapping(lp_build_engine, assert_func,
func_to_pointer((func_pointer)lp_assert));
}
assert(assert_func);
/* build function call param list */
params[0] = LLVMBuildZExt(builder, condition, arg_types[0], "");
params[1] = LLVMBuildBitCast(builder, msg_string, arg_types[1], "");
/* check arg types */
assert(LLVMTypeOf(params[0]) == arg_types[0]);
assert(LLVMTypeOf(params[1]) == arg_types[1]);
r = LLVMBuildCall(builder, assert_func, params, 2, "");
return r;
}
static LLVMValueRef zephir_get_add_function(zephir_context *context)
{
LLVMValueRef function;
LLVMTypeRef arg_tys[3];
function = LLVMGetNamedFunction(context->module, "add_function");
if (!function) {
arg_tys[0] = context->types.zval_pointer_type;
arg_tys[1] = context->types.zval_pointer_type;
arg_tys[2] = context->types.zval_pointer_type;
function = LLVMAddFunction(context->module, "add_function", LLVMFunctionType(LLVMVoidType(), arg_tys, 3, 0));
if (!function) {
zend_error(E_ERROR, "Cannot register add_function");
}
LLVMAddGlobalMapping(context->engine, function, add_function);
LLVMSetFunctionCallConv(function, LLVMCCallConv);
LLVMAddFunctionAttr(function, LLVMNoUnwindAttribute);
}
return function;
}
oFunctionOverloadRef _oFunctionOverloadRegisterNative(oThreadContextRef ctx,
oSignatureRef sig,
oArrayRef attributes,
pointer fn) {
oFunctionOverloadRef overload;
char* un;
// Allocate in shared heap
overload = (oFunctionOverloadRef)o_bootstrap_object_alloc(ctx->runtime, ctx->runtime->builtInTypes.functionOverload, sizeof(oFunctionOverload));
if(overload == NULL) {
ctx->error = ctx->runtime->builtInErrors.outOfMemory;
return NULL;
}
if(attributes) {
overload->attributes = _oHeapCopyObjectShared(ctx, attributes);
if(overload->attributes == NULL) {
return NULL;
}
}
overload->signature = _oHeapCopyObjectShared(ctx, sig);
if(overload->signature == NULL) {
return NULL;
}
overload->code = fn;
un = oGenUniqueName(ctx);
if(un == NULL) {
ctx->error = ctx->runtime->builtInErrors.outOfMemory;
return NULL;
}
overload->llvmFunction = LLVMAddFunction(ctx->runtime->llvmModule, un, llvmTypeForSignature(ctx, sig));
oFree(un);
LLVMAddGlobalMapping(ctx->runtime->llvmEE, overload->llvmFunction, fn);
return overload;
}
/* Llvm.llvalue -> int64 -> llexecutionengine -> unit */
CAMLprim value llvm_ee_add_global_mapping(LLVMValueRef Global, value Ptr,
LLVMExecutionEngineRef EE) {
LLVMAddGlobalMapping(EE, Global, (void*) (Int64_val(Ptr)));
return Val_unit;
}