static void
ofpath_begin_mask(fz_device *dev, fz_rect bbox, int luminosity, fz_colorspace *colorspace, float *color)
{
NOT_IMPL();
}
static void
ofpath_clip_image_mask(fz_device *dev, fz_image *image, fz_rect *rect, fz_matrix ctm)
{
NOT_IMPL();
}
static void
ofpath_pop_clip(fz_device *dev)
{
NOT_IMPL();
}
int
guestfs_impl_add_domain (guestfs_h *g, const char *dom,
const struct guestfs_add_domain_argv *optargs)
{
NOT_IMPL(-1);
}
DEMO_ENTRY_NAME(ease, EaseBounceOutTest),
DEMO_ENTRY_NAME(ease, EaseElasticInOutTest),
DEMO_ENTRY_NAME(ease, EaseElasticInTest),
DEMO_ENTRY_NAME(ease, EaseElasticOutTest),
DEMO_ENTRY_NAME(ease, EaseExponentialInOutTest),
DEMO_ENTRY_NAME(ease, EaseExponentialInTest),
DEMO_ENTRY_NAME(ease, EaseExponentialOutTest),
DEMO_ENTRY_NAME(ease, EaseInOutTest),
DEMO_ENTRY_NAME(ease, EaseInTest),
DEMO_ENTRY_NAME(ease, EaseOutTest),
DEMO_ENTRY_NAME(ease, EaseSineInOutTest),
DEMO_ENTRY_NAME(ease, EaseSineInTest),
DEMO_ENTRY_NAME(ease, EaseSineOutTest),
},
{
NOT_IMPL(DEMO_ENTRY_NAME(event, AccelerometerTest)),
DEMO_ENTRY_NAME(event, CharacterMoveTest),
DEMO_ENTRY_NAME(event, ClickAndMoveTest),
DEMO_ENTRY_NAME(event, DoubleTapTest),
DEMO_ENTRY_NAME(event, GestureTest),
DEMO_ENTRY_NAME(event, KeyTest),
NOT_IMPL(DEMO_ENTRY_NAME(event, MultiTouchTest)),
DEMO_ENTRY_NAME(event, CustomBackTest),
},
{
DEMO_ENTRY_NAME(gridaction, GridFlipXTest),
DEMO_ENTRY_NAME(gridaction, GridFlipYTest),
DEMO_ENTRY_NAME(gridaction, JumpTiles3DTest),
DEMO_ENTRY_NAME(gridaction, Lens3DTest),
DEMO_ENTRY_NAME(gridaction, LineShrinkOutTest),
DEMO_ENTRY_NAME(gridaction, LiquidTest),
static void
ofpath_end_group(fz_device *dev)
{
NOT_IMPL();
}
static void
ofpath_end_tile(fz_device *dev)
{
NOT_IMPL();
}
static void
ofpath_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
{
NOT_IMPL();
}
static void
ofpath_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
{
NOT_IMPL();
}
static void
ofpath_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm)
{
NOT_IMPL();
}
static void
ofpath_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
NOT_IMPL();
}
static void
ofpath_clip_path(fz_device *dev, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm)
{
NOT_IMPL();
}
void *
mono_arch_create_method_pointer (MonoMethod *method)
{
MonoMethodSignature *sig;
MonoJitInfo *ji;
guint stack_size, code_size, stackval_arg_pos, local_pos;
guint i, local_start, reg_param = 0, stack_param, cpos, vt_cur;
guint32 align = 0;
guint32 *p, *code_buffer;
gint *vtbuf;
gint32 simpletype;
code_size = 1024; /* these should be calculated... */
stack_size = 1024;
stack_param = 0;
sig = method->signature;
p = code_buffer = g_malloc (code_size);
DEBUG(fprintf(stderr, "Delegate [start emiting] %s\n", method->name));
DEBUG(fprintf(stderr, "%s\n", sig_to_name(sig, FALSE)));
p = emit_prolog (p, sig, stack_size);
/* fill MonoInvocation */
sparc_st_imm_ptr (p, sparc_g0, sparc_sp,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex)));
sparc_st_imm_ptr (p, sparc_g0, sparc_sp,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex_handler)));
sparc_st_imm_ptr (p, sparc_g0, sparc_sp,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, parent)));
sparc_set_ptr (p, (void *)method, sparc_l0);
sparc_st_imm_ptr (p, sparc_l0, sparc_sp,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, method)));
stackval_arg_pos = MINV_POS + sizeof (MonoInvocation);
local_start = local_pos = stackval_arg_pos + (sig->param_count + 1) * sizeof (stackval);
if (sig->hasthis) {
sparc_st_imm_ptr (p, sparc_i0, sparc_sp,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, obj)));
reg_param = 1;
}
if (sig->param_count) {
gint save_count = MIN (OUT_REGS, sig->param_count + sig->hasthis);
for (i = reg_param; i < save_count; i++) {
sparc_st_imm_ptr (p, sparc_i0 + i, sparc_sp, local_pos);
local_pos += SLOT_SIZE;
}
}
/* prepare space for valuetypes */
vt_cur = local_pos;
vtbuf = alloca (sizeof(int)*sig->param_count);
cpos = 0;
for (i = 0; i < sig->param_count; i++) {
MonoType *type = sig->params [i];
vtbuf [i] = -1;
if (!sig->params[i]->byref && type->type == MONO_TYPE_VALUETYPE) {
MonoClass *klass = type->data.klass;
gint size;
if (klass->enumtype)
continue;
size = mono_class_native_size (klass, &align);
cpos += align - 1;
cpos &= ~(align - 1);
vtbuf [i] = cpos;
cpos += size;
}
}
cpos += SLOT_SIZE - 1;
cpos &= ~(SLOT_SIZE - 1);
local_pos += cpos;
/* set MonoInvocation::stack_args */
sparc_add_imm (p, 0, sparc_sp, stackval_arg_pos, sparc_l0);
sparc_st_imm_ptr (p, sparc_l0, sparc_sp,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, stack_args)));
/* add stackval arguments */
for (i=0; i < sig->param_count; i++) {
int stack_offset;
int type;
if (reg_param < OUT_REGS) {
stack_offset = local_start + i * SLOT_SIZE;
reg_param++;
} else {
stack_offset = stack_size + 8 + stack_param;
stack_param++;
}
if (!sig->params[i]->byref) {
type = sig->params[i]->type;
enum_arg:
switch (type) {
case MONO_TYPE_I8:
case MONO_TYPE_U8:
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_STRING:
case MONO_TYPE_OBJECT:
case MONO_TYPE_CLASS:
case MONO_TYPE_SZARRAY:
case MONO_TYPE_PTR:
case MONO_TYPE_R8:
break;
case MONO_TYPE_I4:
case MONO_TYPE_U4:
stack_offset += SLOT_SIZE - 4;
break;
case MONO_TYPE_CHAR:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
stack_offset += SLOT_SIZE - 2;
break;
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_BOOLEAN:
stack_offset += SLOT_SIZE - 1;
break;
case MONO_TYPE_VALUETYPE:
if (sig->params[i]->data.klass->enumtype) {
type = sig->params[i]->data.klass->enum_basetype->type;
goto enum_arg;
}
g_assert(vtbuf[i] >= 0);
break;
default:
g_error ("can not cope with delegate arg type %d", type);
}
}
sparc_add_imm (p, 0, sparc_sp, stack_offset, sparc_o2);
if (vtbuf[i] >= 0) {
sparc_add_imm (p, 0, sparc_sp, vt_cur, sparc_o1);
sparc_st_imm_ptr (p, sparc_o1, sparc_sp, stackval_arg_pos);
sparc_add_imm (p, 0, sparc_sp, stackval_arg_pos,
sparc_o1);
sparc_ld_imm_ptr (p, sparc_o2, 0, sparc_o2);
vt_cur += vtbuf[i];
} else {
sparc_add_imm (p, 0, sparc_sp, stackval_arg_pos,
sparc_o1);
}
sparc_set_ptr (p, (void *)sig->params[i], sparc_o0);
sparc_set (p, (guint32)sig->pinvoke, sparc_o3);
/* YOU make the CALL! */
sparc_set_ptr (p, (void *)stackval_from_data, sparc_l0);
sparc_jmpl_imm (p, sparc_l0, 0, sparc_callsite);
sparc_nop (p);
stackval_arg_pos += sizeof(stackval);
}
/* return value storage */
/* Align to dword */
stackval_arg_pos = (stackval_arg_pos + (8 - 1)) & (~(8 -1));
if (sig->param_count) {
sparc_add_imm (p, 0, sparc_sp, stackval_arg_pos, sparc_l0);
}
if (!sig->ret->byref && sig->ret->type == MONO_TYPE_VALUETYPE && !sig->ret->data.klass->enumtype) {
#if !SPARCV9
/* pass on callers buffer */
sparc_ld_imm_ptr (p, sparc_fp, 64, sparc_l1);
sparc_st_imm_ptr (p, sparc_l1, sparc_l0, 0);
#else
sparc_add_imm (p, 0, sparc_l0, sizeof(stackval), sparc_l1);
sparc_st_imm_ptr (p, sparc_l1, sparc_l0, 0);
#endif
}
sparc_st_imm_ptr (p, sparc_l0, sparc_sp,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval)));
/* call ves_exec_method */
sparc_add_imm (p, 0, sparc_sp, MINV_POS, sparc_o0);
sparc_set_ptr (p, (void *)ves_exec_method, sparc_l0);
sparc_jmpl_imm (p, sparc_l0, 0, sparc_callsite);
sparc_nop (p);
/* move retval from stackval to proper place (r3/r4/...) */
if (sig->ret->byref) {
sparc_ld_imm_ptr (p, sparc_sp, stackval_arg_pos, sparc_i0 );
} else {
enum_retvalue:
switch (sig->ret->type) {
case MONO_TYPE_VOID:
break;
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
case MONO_TYPE_I4:
case MONO_TYPE_U4:
sparc_ld_imm (p, sparc_sp, stackval_arg_pos, sparc_i0);
break;
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_OBJECT:
case MONO_TYPE_STRING:
case MONO_TYPE_CLASS:
sparc_ld_imm_ptr (p, sparc_sp, stackval_arg_pos, sparc_i0);
break;
case MONO_TYPE_I8:
case MONO_TYPE_U8:
#if SPARCV9
sparc_ldx_imm (p, sparc_sp, stackval_arg_pos, sparc_i0);
#else
sparc_ld_imm (p, sparc_sp, stackval_arg_pos, sparc_i0);
sparc_ld_imm (p, sparc_sp, stackval_arg_pos + 4, sparc_i1);
#endif
break;
case MONO_TYPE_R4:
sparc_lddf_imm (p, sparc_sp, stackval_arg_pos, sparc_f0);
sparc_fdtos(p, sparc_f0, sparc_f0);
break;
case MONO_TYPE_R8:
sparc_lddf_imm (p, sparc_sp, stackval_arg_pos, sparc_f0);
break;
case MONO_TYPE_VALUETYPE: {
gint size;
gint reg = sparc_i0;
if (sig->ret->data.klass->enumtype) {
simpletype = sig->ret->data.klass->enum_basetype->type;
goto enum_retvalue;
}
#if SPARCV9
size = mono_class_native_size (sig->ret->data.klass, NULL);
sparc_ldx_imm (p, sparc_sp, stackval_arg_pos, sparc_l0);
if (size <= 16) {
gint off = 0;
if (size >= 8) {
sparc_ldx_imm (p, sparc_l0, 0, reg);
size -= 8;
off += 8;
reg++;
}
if (size > 0)
sparc_ldx_imm (p, sparc_l0, off, reg);
} else
NOT_IMPL("value type as ret val from delegate");
#endif
break;
}
default:
g_error ("Type 0x%x not handled yet in thunk creation",
sig->ret->type);
break;
}
}
p = emit_epilog (p, sig, stack_size);
for (i = 0; i < ((p - code_buffer)/2); i++)
flushi((code_buffer + (i*8)));
ji = g_new0 (MonoJitInfo, 1);
ji->method = method;
ji->code_size = p - code_buffer;
ji->code_start = code_buffer;
mono_jit_info_table_add (mono_get_root_domain (), ji);
DEBUG(sparc_disassemble_code (code_buffer, p, method->name));
DEBUG(fprintf(stderr, "Delegate [end emiting] %s\n", method->name));
return ji->code_start;
}
void frm_isa_FCMP_impl(struct frm_thread_t *thread, struct frm_inst_t *inst)
{
NOT_IMPL();
}
static void
ofpath_end_mask(fz_device *dev)
{
NOT_IMPL();
}
static void
ofpath_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
{
NOT_IMPL();
}
static void
ofpath_begin_group(fz_device *dev, fz_rect bbox, int isolated, int knockout, int blendmode, float alpha)
{
NOT_IMPL();
}
static void
ofpath_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
{
NOT_IMPL();
}
static void
ofpath_begin_tile(fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
{
NOT_IMPL();
}
static void
ofpath_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
{
NOT_IMPL();
}
static void
ofpath_trm(fz_matrix trm)
{
NOT_IMPL();
}
static void
ofpath_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
NOT_IMPL();
}
int
guestfs_impl_add_libvirt_dom (guestfs_h *g, void *domvp,
const struct guestfs_add_libvirt_dom_argv *optargs)
{
NOT_IMPL(-1);
}
char *
guestfs__file_architecture (guestfs_h *g, const char *path)
{
NOT_IMPL(NULL);
}