static void pointer_offset(compile_t* c, reach_type_t* t, reach_type_t* t_elem)
{
FIND_METHOD("_offset");
LLVMTypeRef params[3];
params[0] = t->use_type;
params[1] = c->intptr;
start_function(c, m, t->use_type, params, 2);
// Set up a constant integer for the allocation size.
size_t size = (size_t)LLVMABISizeOfType(c->target_data, t_elem->use_type);
LLVMValueRef l_size = LLVMConstInt(c->intptr, size, false);
LLVMValueRef ptr = LLVMGetParam(m->func, 0);
LLVMValueRef n = LLVMGetParam(m->func, 1);
// Return ptr + (n * sizeof(len)).
LLVMValueRef src = LLVMBuildPtrToInt(c->builder, ptr, c->intptr, "");
LLVMValueRef offset = LLVMBuildMul(c->builder, n, l_size, "");
LLVMValueRef result = LLVMBuildAdd(c->builder, src, offset, "");
result = LLVMBuildIntToPtr(c->builder, result, t->use_type, "");
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
BOX_FUNCTION();
}
static void pointer_alloc(compile_t* c, reach_type_t* t,
reach_type_t* t_elem)
{
FIND_METHOD("_alloc");
LLVMTypeRef params[2];
params[0] = t->use_type;
params[1] = c->intptr;
start_function(c, m, t->use_type, params, 2);
// Set up a constant integer for the allocation size.
size_t size = (size_t)LLVMABISizeOfType(c->target_data, t_elem->use_type);
LLVMValueRef l_size = LLVMConstInt(c->intptr, size, false);
LLVMValueRef len = LLVMGetParam(m->func, 1);
LLVMValueRef args[2];
args[0] = codegen_ctx(c);
args[1] = LLVMBuildMul(c->builder, len, l_size, "");
LLVMValueRef result = gencall_runtime(c, "pony_alloc", args, 2, "");
result = LLVMBuildBitCast(c->builder, result, t->use_type, "");
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
}
static void maybe_none(compile_t* c, reach_type_t* t)
{
FIND_METHOD("none");
start_function(c, m, t->use_type, &t->use_type, 1);
LLVMBuildRet(c->builder, LLVMConstNull(t->use_type));
codegen_finishfun(c);
}
static void pointer_unsafe(compile_t* c, reach_type_t* t)
{
FIND_METHOD("_unsafe");
start_function(c, m, t->use_type, &t->use_type, 1);
LLVMBuildRet(c->builder, LLVMGetParam(m->func, 0));
codegen_finishfun(c);
}
static void number_conversion(compile_t* c, num_conv_t* from, num_conv_t* to,
bool native128)
{
if(!native128 &&
((from->is_float && (to->size > 64)) ||
(to->is_float && (from->size > 64)))
)
{
return;
}
reach_type_t* t = reach_type_name(c->reach, from->type_name);
if(t == NULL)
return;
FIND_METHOD(to->fun_name);
start_function(c, m, to->type, &from->type, 1);
LLVMValueRef arg = LLVMGetParam(m->func, 0);
LLVMValueRef result;
if(from->is_float)
{
if(to->is_float)
{
if(from->size < to->size)
result = LLVMBuildFPExt(c->builder, arg, to->type, "");
else if(from->size > to->size)
result = LLVMBuildFPTrunc(c->builder, arg, to->type, "");
else
result = arg;
} else if(to->is_signed) {
result = LLVMBuildFPToSI(c->builder, arg, to->type, "");
} else {
result = LLVMBuildFPToUI(c->builder, arg, to->type, "");
}
} else if(to->is_float) {
if(from->is_signed)
result = LLVMBuildSIToFP(c->builder, arg, to->type, "");
else
result = LLVMBuildUIToFP(c->builder, arg, to->type, "");
} else if(from->size > to->size) {
result = LLVMBuildTrunc(c->builder, arg, to->type, "");
} else if(from->size < to->size) {
if(from->is_signed)
result = LLVMBuildSExt(c->builder, arg, to->type, "");
else
result = LLVMBuildZExt(c->builder, arg, to->type, "");
} else {
result = arg;
}
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
BOX_FUNCTION();
}
static void f64__nan(compile_t* c, reach_type_t* t)
{
FIND_METHOD("_nan");
start_function(c, m, c->f64, &c->f64, 1);
LLVMValueRef result = LLVMConstNaN(c->f64);
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
}
static void pointer_create(compile_t* c, reach_type_t* t)
{
FIND_METHOD("create");
start_function(c, m, t->use_type, &t->use_type, 1);
LLVMValueRef result = LLVMConstNull(t->use_type);
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
}
static void pointer_usize(compile_t* c, reach_type_t* t)
{
FIND_METHOD("usize");
start_function(c, m, c->intptr, &t->use_type, 1);
LLVMValueRef ptr = LLVMGetParam(m->func, 0);
LLVMValueRef result = LLVMBuildPtrToInt(c->builder, ptr, c->intptr, "");
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
}
static void platform_debug(compile_t* c, reach_type_t* t)
{
FIND_METHOD("debug");
start_function(c, m, c->ibool, &t->use_type, 1);
LLVMValueRef result = LLVMConstInt(c->ibool, !c->opt->release, false);
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
BOX_FUNCTION();
}
static void f64_bits(compile_t* c, reach_type_t* t)
{
FIND_METHOD("bits");
start_function(c, m, c->i64, &c->f64, 1);
LLVMValueRef result = LLVMBuildBitCast(c->builder, LLVMGetParam(m->func, 0),
c->i64, "");
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
BOX_FUNCTION();
}
static void platform_x86(compile_t* c, reach_type_t* t)
{
FIND_METHOD("x86");
start_function(c, m, c->ibool, &t->use_type, 1);
LLVMValueRef result =
LLVMConstInt(c->ibool, target_is_x86(c->opt->triple), false);
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
BOX_FUNCTION();
}
static void maybe_create(compile_t* c, reach_type_t* t, reach_type_t* t_elem)
{
FIND_METHOD("create");
LLVMTypeRef params[2];
params[0] = t->use_type;
params[1] = t_elem->use_type;
start_function(c, m, t->use_type, params, 2);
LLVMValueRef param = LLVMGetParam(m->func, 1);
LLVMValueRef result = LLVMBuildBitCast(c->builder, param, t->use_type, "");
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
}
static void f64_from_bits(compile_t* c, reach_type_t* t)
{
FIND_METHOD("from_bits");
LLVMTypeRef params[2];
params[0] = c->f64;
params[1] = c->i64;
start_function(c, m, c->f64, params, 2);
LLVMValueRef result = LLVMBuildBitCast(c->builder, LLVMGetParam(m->func, 1),
c->f64, "");
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
}
static void maybe_is_none(compile_t* c, reach_type_t* t)
{
// Returns true if the receiver is null.
FIND_METHOD("is_none");
start_function(c, m, c->ibool, &t->use_type, 1);
LLVMValueRef receiver = LLVMGetParam(m->func, 0);
LLVMValueRef test = LLVMBuildIsNull(c->builder, receiver, "");
LLVMValueRef value = LLVMBuildZExt(c->builder, test, c->ibool, "");
LLVMBuildRet(c->builder, value);
codegen_finishfun(c);
BOX_FUNCTION();
}
static void donotoptimise_observe(compile_t* c, reach_type_t* t)
{
FIND_METHOD("observe");
start_function(c, m, m->result->use_type, &t->use_type, 1);
LLVMTypeRef void_fn = LLVMFunctionType(c->void_type, NULL, 0, false);
LLVMValueRef asmstr = LLVMConstInlineAsm(void_fn, "", "~{memory}", true,
false);
LLVMBuildCall(c->builder, asmstr, NULL, 0, "");
LLVMBuildRet(c->builder, m->result->instance);
codegen_finishfun(c);
BOX_FUNCTION();
}
static void pointer_delete(compile_t* c, reach_type_t* t, reach_type_t* t_elem)
{
FIND_METHOD("_delete");
LLVMTypeRef params[3];
params[0] = t->use_type;
params[1] = c->intptr;
params[2] = c->intptr;
start_function(c, m, t_elem->use_type, params, 3);
// Set up a constant integer for the allocation size.
size_t size = (size_t)LLVMABISizeOfType(c->target_data, t_elem->use_type);
LLVMValueRef l_size = LLVMConstInt(c->intptr, size, false);
LLVMValueRef ptr = LLVMGetParam(m->func, 0);
LLVMValueRef n = LLVMGetParam(m->func, 1);
LLVMValueRef len = LLVMGetParam(m->func, 2);
LLVMValueRef elem_ptr = LLVMBuildBitCast(c->builder, ptr,
LLVMPointerType(t_elem->use_type, 0), "");
LLVMValueRef result = LLVMBuildLoad(c->builder, elem_ptr, "");
LLVMValueRef dst = LLVMBuildPtrToInt(c->builder, elem_ptr, c->intptr, "");
LLVMValueRef offset = LLVMBuildMul(c->builder, n, l_size, "");
LLVMValueRef src = LLVMBuildAdd(c->builder, dst, offset, "");
LLVMValueRef elen = LLVMBuildMul(c->builder, len, l_size, "");
LLVMValueRef args[5];
args[0] = LLVMBuildIntToPtr(c->builder, dst, c->void_ptr, "");
args[1] = LLVMBuildIntToPtr(c->builder, src, c->void_ptr, "");
args[2] = elen;
args[3] = LLVMConstInt(c->i32, 1, false);
args[4] = LLVMConstInt(c->i1, 0, false);
// llvm.memmove.*(ptr, ptr + (n * sizeof(elem)), len * sizeof(elem))
if(target_is_ilp32(c->opt->triple))
{
gencall_runtime(c, "llvm.memmove.p0i8.p0i8.i32", args, 5, "");
} else {
gencall_runtime(c, "llvm.memmove.p0i8.p0i8.i64", args, 5, "");
}
// Return ptr[0].
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
}
static void pointer_copy_to(compile_t* c, reach_type_t* t,
reach_type_t* t_elem)
{
FIND_METHOD("_copy_to");
LLVMTypeRef params[3];
params[0] = t->use_type;
params[1] = t->use_type;
params[2] = c->intptr;
start_function(c, m, t->use_type, params, 3);
// Set up a constant integer for the allocation size.
size_t size = (size_t)LLVMABISizeOfType(c->target_data, t_elem->use_type);
LLVMValueRef l_size = LLVMConstInt(c->intptr, size, false);
LLVMValueRef ptr = LLVMGetParam(m->func, 0);
LLVMValueRef ptr2 = LLVMGetParam(m->func, 1);
LLVMValueRef n = LLVMGetParam(m->func, 2);
LLVMValueRef elen = LLVMBuildMul(c->builder, n, l_size, "");
LLVMValueRef args[5];
args[0] = LLVMBuildBitCast(c->builder, ptr2, c->void_ptr, "");
args[1] = LLVMBuildBitCast(c->builder, ptr, c->void_ptr, "");
args[2] = elen;
args[3] = LLVMConstInt(c->i32, 1, false);
args[4] = LLVMConstInt(c->i1, 0, false);
// llvm.memcpy.*(ptr2, ptr, n * sizeof(elem), 1, 0)
if(target_is_ilp32(c->opt->triple))
{
gencall_runtime(c, "llvm.memcpy.p0i8.p0i8.i32", args, 5, "");
} else {
gencall_runtime(c, "llvm.memcpy.p0i8.p0i8.i64", args, 5, "");
}
LLVMBuildRet(c->builder, ptr);
codegen_finishfun(c);
BOX_FUNCTION();
}
static void pointer_update(compile_t* c, reach_type_t* t, reach_type_t* t_elem)
{
FIND_METHOD("_update");
LLVMTypeRef params[3];
params[0] = t->use_type;
params[1] = c->intptr;
params[2] = t_elem->use_type;
start_function(c, m, t_elem->use_type, params, 3);
LLVMValueRef ptr = LLVMGetParam(m->func, 0);
LLVMValueRef index = LLVMGetParam(m->func, 1);
LLVMValueRef elem_ptr = LLVMBuildBitCast(c->builder, ptr,
LLVMPointerType(t_elem->use_type, 0), "");
LLVMValueRef loc = LLVMBuildGEP(c->builder, elem_ptr, &index, 1, "");
LLVMValueRef result = LLVMBuildLoad(c->builder, loc, "");
LLVMBuildStore(c->builder, LLVMGetParam(m->func, 2), loc);
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
}
static void maybe_apply(compile_t* c, reach_type_t* t, reach_type_t* t_elem)
{
// Returns the receiver if it isn't null.
FIND_METHOD("apply");
start_function(c, m, t_elem->use_type, &t->use_type, 1);
LLVMValueRef result = LLVMGetParam(m->func, 0);
LLVMValueRef test = LLVMBuildIsNull(c->builder, result, "");
LLVMBasicBlockRef is_false = codegen_block(c, "");
LLVMBasicBlockRef is_true = codegen_block(c, "");
LLVMBuildCondBr(c->builder, test, is_true, is_false);
LLVMPositionBuilderAtEnd(c->builder, is_false);
result = LLVMBuildBitCast(c->builder, result, t_elem->use_type, "");
LLVMBuildRet(c->builder, result);
LLVMPositionBuilderAtEnd(c->builder, is_true);
gencall_throw(c);
codegen_finishfun(c);
BOX_FUNCTION();
}
void JNI::create(JNIEnv *env, jobject self, jobject asset_manager,
jobject egl, jobject egl_display,
jobject at, jint audio_sample_rate, jint audio_buffer_size) {
LOGI(Cabal::getFullVersion());
assert(!_system);
pause = false;
// initial value of zero!
sem_init(&pause_sem, 0, 0);
_asset_archive = new AndroidAssetArchive(asset_manager);
assert(_asset_archive);
_system = new OSystem_Android(audio_sample_rate, audio_buffer_size);
assert(_system);
// weak global ref to allow class to be unloaded
// ... except dalvik implements NewWeakGlobalRef only on froyo
//_jobj = env->NewWeakGlobalRef(self);
_jobj = env->NewGlobalRef(self);
jclass cls = env->GetObjectClass(_jobj);
#define FIND_METHOD(prefix, name, signature) do { \
_MID_ ## prefix ## name = env->GetMethodID(cls, #name, signature); \
if (_MID_ ## prefix ## name == 0) \
return; \
} while (0)
FIND_METHOD(, setWindowCaption, "(Ljava/lang/String;)V");
FIND_METHOD(, getDPI, "([F)V");
FIND_METHOD(, displayMessageOnOSD, "(Ljava/lang/String;)V");
FIND_METHOD(, showVirtualKeyboard, "(Z)V");
FIND_METHOD(, getSysArchives, "()[Ljava/lang/String;");
FIND_METHOD(, initSurface, "()Ljavax/microedition/khronos/egl/EGLSurface;");
FIND_METHOD(, deinitSurface, "()V");
_jobj_egl = env->NewGlobalRef(egl);
_jobj_egl_display = env->NewGlobalRef(egl_display);
cls = env->GetObjectClass(_jobj_egl);
FIND_METHOD(EGL10_, eglSwapBuffers,
"(Ljavax/microedition/khronos/egl/EGLDisplay;"
"Ljavax/microedition/khronos/egl/EGLSurface;)Z");
_jobj_audio_track = env->NewGlobalRef(at);
cls = env->GetObjectClass(_jobj_audio_track);
FIND_METHOD(AudioTrack_, flush, "()V");
FIND_METHOD(AudioTrack_, pause, "()V");
FIND_METHOD(AudioTrack_, play, "()V");
FIND_METHOD(AudioTrack_, stop, "()V");
FIND_METHOD(AudioTrack_, write, "([BII)I");
#undef FIND_METHOD
g_system = _system;
}
