Exemplo n.º 1
0
struct pvm_object
pvm_copy_object( struct pvm_object in_object )
{
    // TODO ERROR throw!
    if(in_object.data->_flags & PHANTOM_OBJECT_STORAGE_FLAG_IS_INTERNAL)
        panic("internal object copy?!");

    //ref_inc_o( in_object.data->_class );  //increment if class is refcounted
    struct pvm_object in_class = in_object.data->_class;
    int da_size = in_object.data->_da_size;

    struct pvm_object out = pvm_object_create_dynamic( in_class, da_size );

    int i = da_size/sizeof(struct pvm_object);
    for(; i >= 0; i-- )
    {
        if(da_po_ptr((in_object.data)->da)[i].data)
            ref_inc_o( da_po_ptr((in_object.data)->da)[i] );
    }

    memcpy( out.data->da, in_object.data->da, da_size );
    // TODO: check for special cases - copy c'tor?

    return out;
}
Exemplo n.º 2
0
struct pvm_object     pvm_create_interface_object( int n_methods, struct pvm_object parent_class )
{
    struct pvm_object	ret = create_interface_worker( n_methods );
    struct pvm_object * data_area = (struct pvm_object *)ret.data->da;

    if(pvm_is_null( parent_class ))
        pvm_exec_panic( "create interface: parent is null" );

    struct pvm_object_storage *base_i =  ((struct data_area_4_class*)parent_class.data->da)->object_default_interface.data;

    int base_icount = da_po_limit(base_i);

    if(base_icount > n_methods)
    {
        // root classes have N_SYS_METHODS slots in interface, don't cry about that
        if( n_methods > N_SYS_METHODS )
            printf( " create interface: child has less methods (%d) than parent (%d)\n", n_methods, base_icount );
        base_icount = n_methods;
    }

    int i = 0;
    // copy methods from parent
    for( ; i < base_icount; i++ )
    {
        pvm_object_t baseMethod = (da_po_ptr(base_i->da))[i];
        ref_inc_o(baseMethod);
        data_area[i] = baseMethod;
    }

    // fill others with nulls
    for( ; i < n_methods; i++ )
        data_area[i] = pvm_get_null_object(); // null

    return ret;
}
Exemplo n.º 3
0
struct pvm_object
pvm_get_class_name( struct pvm_object o )
{
    struct pvm_object c = o.data->_class;
    if(c.data->_flags & PHANTOM_OBJECT_STORAGE_FLAG_IS_CLASS)
    {
        struct data_area_4_class *da = (struct data_area_4_class *)&(c.data->da);
        ref_inc_o( da->class_name );
        return da->class_name;
    }
    else
        return pvm_create_string_object("(class corrupt?)");
}
Exemplo n.º 4
0
struct pvm_object     pvm_create_thread_object(struct pvm_object start_cf )
{
	struct pvm_object ret = pvm_object_create_fixed( pvm_get_thread_class() );
	struct data_area_4_thread *da = (struct data_area_4_thread *)ret.data->da;

	da->call_frame = start_cf;
	da->stack_depth = 1;

	pvm_exec_load_fast_acc(da);

	// add to system threads list
	pvm_append_array(pvm_root.threads_list.data, ret);
	ref_inc_o(ret);

	// not for each and every one
	//phantom_activate_thread(ret);

	return ret;
}
Exemplo n.º 5
0
struct pvm_object pvm_weakref_get_object(struct pvm_object wr )
{
    struct data_area_4_weakref *da = pvm_object_da( wr, weakref );
    struct pvm_object out;

    // still crashes :(

    // HACK HACK HACK BUG - wiring target too. TODO need wire size parameter for page cross situations!
    wire_page_for_addr( &(da->object) );
    wire_page_for_addr( da->object.data );

    // All we do is return new reference to our object,
    // incrementing refcount before

#if WEAKREF_SPIN
    wire_page_for_addr( &da->lock );
    int ie = hal_save_cli();
    hal_spin_lock( &da->lock );
#else
    hal_mutex_lock( &da->mutex );
#endif

    // TODO should we check refcount before and return null if zero?
    if( 0 == da->object.data->_ah.refCount )
        printf("zero object in pvm_weakref_get_object\n");

    out = ref_inc_o( da->object );

#if WEAKREF_SPIN
    hal_spin_unlock( &da->lock );
    if( ie ) hal_sti();
    unwire_page_for_addr( &da->lock );
#else
    hal_mutex_unlock( &da->mutex );
#endif

    unwire_page_for_addr( da->object.data );
    unwire_page_for_addr( &(da->object) );

    return out;
}
Exemplo n.º 6
0
errno_t jit_compile_method(struct pvm_code_handler *code)
{

    struct jit_out      jo;
    struct jit_out      *j = &jo;

    //struct data_area_4_thread *da = (struct data_area_4_thread *)&(current_thread.data->da);
    // TODO: check for current_thread to be thread for real

    // JITted code supposed to be called with da in BX

    //jit_gen_push( j, JIT_R_BX );
    //jit_gen_call( j, JIT_F_LOAD_F_ACC );
    //pvm_exec_load_fast_acc(da); // For any case

    {
#warning resleep?
    // Thread was snapped sleeping - resleep it
        //if(da->sleep_flag)        phantom_thread_sleep_worker( da );
        /*
        jit_load_thread_field( j, offsetof(da->sleep_flag) ); // to AX, gen flags
        jit_label jl = jit_get_label( j );
        jit_jz( jl );

        jit_gen_push( j, JIT_R_BX );
        jit_gen_call( j, JIT_F_THREAD_SLEEP_WORKER );
        jit_mark_label( j, jl );
        */
    }

    while(1)
    {

        /*
        if(phantom_virtual_machine_snap_request)
        {
            pvm_exec_save_fast_acc(da); // Before snap
            phantom_thread_wait_4_snap();
            //pvm_exec_load_fast_acc(da); // We don't need this, if we die, we will enter again from above :)
        }
        */

        {
            jit_check_snap_request( j );
            /*
            jit_label jl = jit_get_label( j );
            jit_jz( jl );

            //jit_gen_push( j, JIT_R_BX );
            jit_gen_call( j, JIT_F_WAIT_SNAP );
            jit_mark_label( j, jl );
            */
        }


        jit_mark_possible_label(j);

        unsigned char instruction = pvm_code_get_byte(code);
        //printf("instr 0x%02X ", instruction);


        switch(instruction)
        {
        case opcode_nop:
            //if( debug_print_instr ) printf("nop; ");
            break;

        case opcode_debug:

            {
                int type = pvm_code_get_byte(code); //cf->cs.get_instr( cf->IP );

                //printf("\n\nDebug 0x%02X", type );
                if( type & 0x80 )
                {
                    //printf(" (" );
                    pvm_object_t o = pvm_code_get_string(code);
                    //pvm_object_print(o);
                    ref_dec_o(o);
                    //printf(")" );
                }

                if( type & 0x01 ) debug_print_instr = 1;
                if( type & 0x02 ) debug_print_instr = 0;

                /*
                if( is_empty() ) printf(", istack empty");
                else                    printf(",\n\tistack top = %d", is_top() );
                if( os_empty() ) printf(", ostack empty");
                else
                {
                    printf(",\n\tostack top = {" );
                    pvm_object_print( os_top() );
                    printf("}" );
                }
                printf(";\n\n");
                */
            }

            break;


            // int stack ops ---------------------------------------

        case opcode_is_dup:
            if( debug_print_instr ) printf("is dup; ");
            jit_is_push( j, jit_is_top( j ) );
            break;

        case opcode_is_drop:
            if( debug_print_instr ) printf("is drop; ");
            jit_is_pop( j );
            break;

        case opcode_iconst_0:
            if( debug_print_instr ) printf("iconst 0; ");
            jit_is_push( j, jit_iconst( j, 0 ) );
            break;

        case opcode_iconst_1:
            if( debug_print_instr ) printf("iconst 1; ");
            jit_is_push( j, jit_iconst( j, 1 ) );
            break;

        case opcode_iconst_8bit:
            {
                int v = pvm_code_get_byte(code);
                jit_is_push( j, jit_iconst( j, v ) );
                if( debug_print_instr ) printf("iconst8 = %d; ", v);
                break;
            }

        case opcode_iconst_32bit:
            {
                int v = pvm_code_get_int32(code);
                jit_is_push( j, jit_iconst( j, v ) );
                if( debug_print_instr ) printf("iconst32 = %d; ", v);
                break;
            }


        case opcode_isum:
            if( debug_print_instr ) printf("isum; ");
            jit_binary_op( j, jit_gen_add );
            break;

        case opcode_imul:
            if( debug_print_instr ) printf("imul; ");
            {
                //int mul = is_pop();
                //is_push( is_pop() * mul );
                jit_binary_op( j, jit_gen_mul );
            }
            break;

        case opcode_isubul:
            if( debug_print_instr ) printf("isubul; ");
            {
                jit_value_t u = jit_is_pop( j );
                jit_value_t l = jit_is_pop( j );
                jit_value_t r = jit_gen_sub( j, u, l );
                jit_is_push( j, r );
            }
            break;

        case opcode_isublu:
            if( debug_print_instr ) printf("isublu; ");
            {
                jit_value_t u = jit_is_pop( j );
                jit_value_t l = jit_is_pop( j );
                jit_value_t r = jit_gen_sub( j, l, u );
                jit_is_push( j, r );
            }
            break;

        case opcode_idivul:
            if( debug_print_instr ) printf("idivul; ");
            {
                jit_value_t u = jit_is_pop( j );
                jit_value_t l = jit_is_pop( j );
                jit_value_t r = jit_gen_div( j, u, l );
                jit_is_push( j, r );
            }
            break;

        case opcode_idivlu:
            if( debug_print_instr ) printf("idivlu; ");
            {
                jit_value_t u = jit_is_pop( j );
                jit_value_t l = jit_is_pop( j );
                jit_value_t r = jit_gen_div( j, l, u );
                jit_is_push( j, r );
            }
            break;

        case opcode_ior:
            if( debug_print_instr ) printf("ior; ");
            //{ int operand = is_pop();	is_push( is_pop() | operand ); }
            jit_binary_op( j, jit_gen_binor );
            break;

        case opcode_iand:
            if( debug_print_instr ) printf("iand; ");
            //{ int operand = is_pop();	is_push( is_pop() & operand ); }
            jit_binary_op( j, jit_gen_binand );
            break;

        case opcode_ixor:
            if( debug_print_instr ) printf("ixor; ");
            //{ int operand = is_pop();	is_push( is_pop() ^ operand ); }
            jit_binary_op( j, jit_gen_binxor );
            break;

        case opcode_inot:
            if( debug_print_instr ) printf("inot; ");
            jit_unary_op( j, jit_gen_binnot );
            break;



        case opcode_log_or:
            if( debug_print_instr ) printf("lor; ");
            jit_binary_op( j, jit_gen_logor );
            break;

        case opcode_log_and:
            if( debug_print_instr ) printf("land; ");
            jit_binary_op( j, jit_gen_logand );
            break;

        case opcode_log_xor:
            if( debug_print_instr ) printf("lxor; ");
            jit_binary_op( j, jit_gen_logxor );
            break;

        case opcode_log_not:
            if( debug_print_instr ) printf("lnot; ");
            jit_unary_op( j, jit_gen_lognot );
            break;


        case opcode_ige:	// >=
            if( debug_print_instr ) printf("ige; ");
            jit_binary_op( j, jit_gen_ige );
            break;
        case opcode_ile:	// <=
            if( debug_print_instr ) printf("ile; ");
            jit_binary_op( j, jit_gen_ile );
            break;
        case opcode_igt:	// >
            if( debug_print_instr ) printf("igt; ");
            jit_binary_op( j, jit_gen_igt );
            break;
        case opcode_ilt:	// <
            if( debug_print_instr ) printf("ilt; ");
            jit_binary_op( j, jit_gen_ilt );
            break;



        case opcode_i2o:
            if( debug_print_instr ) printf("i2o; ");
            jit_push_arg( j, jit_is_pop( j ) );
            jit_os_push( j, jit_gen_call( j, JIT_F_CREATE_INT_OBJ ) );
            break;

        case opcode_o2i:
            if( debug_print_instr ) printf("o2i; ");
            {
                jit_is_push( j, jit_o2int( j, jit_os_pop( j ) ) );// push AX
                //jit_refdec( j ); // TODO jit_o2int must refdec?
            }
            break;


        case opcode_os_eq:
            if( debug_print_instr ) printf("os eq; ");
            {
                jit_value_t v1 = jit_os_pop( j );
                jit_value_t v2 = jit_os_pop( j );

                jit_is_push( j, jit_gen_cmp( j, v1, v2 ) );

                jit_refdec( j, v1 );
                jit_refdec( j, v2 );

                break;
            }

        case opcode_os_neq:
            if( debug_print_instr ) printf("os neq; ");
            {
                jit_value_t v1 = jit_os_pop( j );
                jit_value_t v2 = jit_os_pop( j );

                jit_is_push( j, jit_gen_lognot( j, jit_gen_cmp( j, v1, v2 )) );

                jit_refdec( j, v1 );
                jit_refdec( j, v2 );

                break;
            }

        case opcode_os_isnull:
            if( debug_print_instr ) printf("isnull; ");
            {
                jit_value_t o1 = jit_os_pop( j );
                jit_is_push( j, jit_is_null( j, o1 ) );
                jit_refdec( j, o1 );
                break;
            }

        case opcode_os_push_null:
        case opcode_summon_null:
            if( debug_print_instr ) printf("push null; ");
            {
                jit_os_push( j, jit_get_null( j ) );
                break;
            }

            // summoning, special ----------------------------------------------------

        case opcode_summon_thread:
            if( debug_print_instr ) printf("summon thread; ");
            jit_os_push( j, jit_get_thread( j ) );
            break;

        case opcode_summon_this:
            if( debug_print_instr ) printf("summon this; ");
            jit_os_push( j, jit_refinc( j, jit_get_this( j ) ) );
            break;

        case opcode_summon_class_class:
            if( debug_print_instr ) printf("summon class class; ");
            jit_os_push( j, jit_get_class_class( j ) );
            break;

        case opcode_summon_interface_class:
            if( debug_print_instr ) printf("summon interface class; ");
            // locked refcnt
            jit_os_push( j, jit_get_iface_class( j ) );
            break;

        case opcode_summon_code_class:
            if( debug_print_instr ) printf("summon code class; ");
            // locked refcnt
            jit_os_push( j, jit_get_code_class( j ) );
            break;

        case opcode_summon_int_class:
            if( debug_print_instr ) printf("summon int class; ");
            // locked refcnt
            jit_os_push( j, jit_get_int_class( j ) );
            break;

        case opcode_summon_string_class:
            if( debug_print_instr ) printf("summon string class; ");
            // locked refcnt
            jit_os_push( j, jit_get_string_class( j ) );
            break;

        case opcode_summon_array_class:
            if( debug_print_instr ) printf("summon array class; ");
            // locked refcnt
            jit_os_push( j, jit_get_array_class( j ) );
            break;

            // TODO we can turn class to const, but the we have to keep refcount for it in
            // const space and release when we release compiled code
            // TODO const list is just an array? easy to release all

        case opcode_summon_by_name:
            {
                if( debug_print_instr ) printf("summon by name; ");

                struct pvm_object name = pvm_code_get_string(code);
                struct pvm_object cl = pvm_exec_lookup_class_by_name( name ); // TODO XXX must inc ref
                ref_dec_o(name);

                // Need throw here?

                if( pvm_is_null( cl ) ) {
                    printf("JIT: summon by name: null class\n");
                    return ENOENT;

                    // TODO XXX generate summon in run time?

                }
                int cid = jit_alloc_const( j, cl );
                jit_os_push( j, jit_get_const( j, cid ) );

            }
            break;

            /**
             * A BIG NOTE for object creation
             *
             * We must be SURE that it is NOT ever possible to pass
             * non-internal object as init data to internal and vice versa!
             * It would be a securily hole!
             *
             **/


        case opcode_new:
            if( debug_print_instr ) printf("new; ");
            {
                //pvm_object_t cl = os_pop();
                //os_push( pvm_create_object( cl ) );
                //ref_dec_o( cl );  // object keep class ref

                jit_os_pop( j );// pop AX, DX
                jit_os_push( j, jit_gen_call( j, JIT_F_CREATE_OBJ ) );// push AX, DX
            }
            break;

        case opcode_copy:
            if( debug_print_instr ) printf("copy; ");
            {
                jit_push_arg( j, jit_os_pop( j ) );
                jit_os_push( j, jit_gen_call( j, JIT_F_COPY_OBJ ) );
                // jit_refdec( j, JIT_R_CX ); XXX TODO need?
            }
            break;

            // if you want to enable these, work out refcount
            // and security issues first!
            // compose/decompose
#if 0
        case opcode_os_compose32:
            if( debug_print_instr ) printf(" compose32; ");
            {
                int num = pvm_code_get_int32(code);
                struct pvm_object in_class = os_pop();
                os_push( pvm_exec_compose_object( in_class, da->_ostack, num ) );
            }
            break;

        case opcode_os_decompose:
            if( debug_print_instr ) printf(" decompose; ");
            {
                struct pvm_object to_decomp = os_pop();
                int num = da_po_limit(to_decomp.data);
                is_push( num );
                while( num )
                {
                    num--;
                    struct pvm_object o = pvm_get_ofield( to_decomp, num);
                    os_push( ref_inc_o( o ) );
                }
                os_push(to_decomp.data->_class);
            }
            break;
#endif
            // string ----------------------------------------------------------------

        case opcode_sconst_bin:
            if( debug_print_instr ) printf("sconst bin; ");
            //os_push(pvm_code_get_string(code));
            {
                int constid = jit_alloc_const( j, pvm_code_get_string( code ) );
                jit_os_push( j, jit_get_const( j, constid ) );
            }
            break;


            // flow ------------------------------------------------------------------

        case opcode_jmp:
            {
                int newip = pvm_code_get_rel_IP_as_abs(code);
                if( debug_print_instr ) printf("jmp %d; ", newip );
                //da->code.IP = pvm_code_get_rel_IP_as_abs(code);
                jit_jump( j, newip );
            }
            break;


        case opcode_djnz:
            {
                if( debug_print_instr ) printf("djnz " );
                int newip = pvm_code_get_rel_IP_as_abs(code);

                //is_push( is_pop() - 1 );
                jit_decrement( j, jit_is_top(j) );
                jit_jnz( j, newip, jit_is_top(j) );

                //if( debug_print_instr ) printf("(%d) -> %d; ", is_top() , new_IP );
            }
            break;

        case opcode_jz:
            {
                if( debug_print_instr ) printf("jz " );
                int newip = pvm_code_get_rel_IP_as_abs(code);
                jit_jz( j, newip, jit_is_pop(j) );
            }
            break;


        case opcode_switch:
            {
#warning impl
                /*
                if( debug_print_instr ) printf("switch ");
                unsigned int tabsize    = pvm_code_get_int32(code);
                int shift               = pvm_code_get_int32(code);
                unsigned int divisor    = pvm_code_get_int32(code);
                int stack_top = is_pop();

                if( debug_print_instr ) printf("(%d+%d)/%d, ", stack_top, shift, divisor );


                unsigned int start_table_IP = da->code.IP;
                unsigned int displ = (stack_top+shift)/divisor;
                unsigned int new_IP = start_table_IP+(tabsize*4); // default

                if( debug_print_instr ) printf("displ %d, etab addr %d ", displ, new_IP );


                if( displ < tabsize )
                {
                    da->code.IP = start_table_IP+(displ*4); // BUG! 4!
                    if( debug_print_instr ) printf("load from %d, ", da->code.IP );
                    new_IP = pvm_code_get_rel_IP_as_abs(code);
                }
                da->code.IP = new_IP;

                if( debug_print_instr ) printf("switch(%d) ->%d; ", displ, new_IP );
                */
                printf("no switch yet");
                return ENXIO;
            }
            break;


        case opcode_ret:
            {
                if( debug_print_instr ) printf( "\nret\n" );
                jit_ret(j);
            }
            break;

            // exceptions are like ret ---------------------------------------------------

        case opcode_throw:
            if( debug_print_instr ) printf( "\nthrow\n" );
            jit_throw(j, jit_os_pop(j) );
            break;

        case opcode_push_catcher:
            {
                unsigned addr = pvm_code_get_rel_IP_as_abs(code);
                if( debug_print_instr ) printf("push catcher %u; ", addr );
                jit_es_push( j, jit_os_pop(j), addr );
            }
            break;

        case opcode_pop_catcher:
            if( debug_print_instr ) printf("pop catcher; ");
            jit_refdec( j, jit_es_pop(j) );
            break;

            // ok, now method calls ------------------------------------------------------

            // these 4 are parameter-less calls!
        case opcode_short_call_0:
            jit_os_push( j, jit_call_method( j, 0, 0, 1) );
            break;
        case opcode_short_call_1:
            jit_os_push( j, jit_call_method( j, 1, 0, 1) );
            break;
        case opcode_short_call_2:
            jit_os_push( j, jit_call_method( j, 2, 0, 1) );
            break;
        case opcode_short_call_3:
            jit_os_push( j, jit_call_method( j, 3, 0, 1) );
            break;

        case opcode_call_8bit:
            {
                unsigned int method_index = pvm_code_get_byte(code);
                unsigned int n_param = pvm_code_get_int32(code);
                jit_os_push( j, jit_call_method( j, method_index, n_param, 1) ); // optimization for soon return
            }
            break;
        case opcode_call_32bit:
            {
                unsigned int method_index = pvm_code_get_int32(code);
                unsigned int n_param = pvm_code_get_int32(code);
                jit_os_push( j, jit_call_method( j, method_index, n_param, 1) ); // optimization for soon return
            }
            break;


            // object stack --------------------------------------------------------------

        case opcode_os_dup:
            if( debug_print_instr ) printf("os dup; ");
            jit_os_push( j, jit_refinc( j, jit_os_top( j ) ) );
            break;

        case opcode_os_drop:
            if( debug_print_instr ) printf("os drop; ");
            jit_refdec( j, jit_os_pop( j ) );
            break;

        case opcode_os_pull32:
            if( debug_print_instr ) printf("os pull; ");
            {
                int pos = pvm_code_get_int32(code);
                jit_os_push( j, jit_refinc( j, jit_os_pull( j, pos ) )  ); // TODO XXX load must refinc!
            }
            break;

        case opcode_os_load8:
            {
                int slot = pvm_code_get_byte(code);
                jit_os_push( j, jit_os_load( j, slot ) ); // TODO XXX load must refinc!
            }
            break;

        case opcode_os_load32:
            {
                int slot = pvm_code_get_int32(code);
                jit_os_push( j, jit_os_load( j, slot ) ); // TODO XXX load must refinc!
                break;
            }

        case opcode_os_save8:
            {
                int slot = pvm_code_get_byte(code);
                jit_os_save( j, slot, jit_os_pop( j ) );
            }
            break;

        case opcode_os_save32:
            {
                int slot = pvm_code_get_int32(code);
                jit_os_save( j, slot, jit_os_pop( j ) );
            }
            break;

        case opcode_is_load8:
            //pvm_exec_iload(da, pvm_code_get_byte(code));
            {
                int slot = pvm_code_get_byte(code);
                jit_value_t ov = jit_os_load( j, slot );
                jit_value_t iv = jit_o2int( j, ov ); // TODO XXX jit_o2int must gen refdec
                jit_is_push( j, iv );
            }
            break;

        case opcode_is_save8:
            {
                int slot = pvm_code_get_byte(code);
                jit_push_arg( j, jit_is_pop( j ) ); // TODO arg is int?
                // pvm_create_int_object
                jit_os_save( j, slot, jit_gen_call( j, JIT_F_CREATE_INT_OBJ ) );
            }
            break;

        case opcode_os_get32:
            {
                int pos = pvm_code_get_int32(code);
                jit_value_t v = jit_os_absget( j, pos ); // AX, DX = obj
                //jit_refinc( j, v ); // TODO XXX must not be needed - absget must inc!
                jit_os_push( j, v );
            }
            break;

        case opcode_os_set32:
            {
                int pos = pvm_code_get_int32(code);
                jit_os_absset( j, pos, jit_os_pop( j ) );
            }
            break;

        case opcode_is_get32:
            {
                int pos = pvm_code_get_int32(code);
                jit_is_push( j, jit_is_absget( j, pos ) );
            }
            break;
        case opcode_is_set32:
            {
                int pos = pvm_code_get_int32(code);
                jit_is_absset( j, pos, jit_is_pop( j ) );
            }
            break;

        default:
            if( (instruction & 0xF0 ) == opcode_sys_0 )
            {
                jit_sys( j, instruction & 0x0F);
                /*
    sys_sleep:
                // Only sys can put thread asleep
                // If we are snapped here we, possibly, will continue from
                // the entry to this func. So save fasc acc and recheck
                // sleep condition on the func entry.
                if(da->sleep_flag)
                {
                    pvm_exec_save_fast_acc(da); // Before snap
                    phantom_thread_sleep_worker( da );
                }
                break;
                */
            }

            if( instruction  == opcode_sys_8bit )
            {
                jit_sys( j, pvm_code_get_byte(code)); 
                //goto sys_sleep;
                break;
            }

            if( (instruction & 0xE0 ) == opcode_call_00 )
            {
                unsigned int n_param = pvm_code_get_byte(code);
                jit_os_push( j, jit_call_method( j, instruction & 0x1F, n_param, 0) ); //no optimization for soon return
                break;
            }

            printf("JIT: Unknown op code 0x%X\n", instruction );

            return ENOENT;
        }
    }
}