jvmacc.c

开放源码的编译器open watcom 1.6.0版的源代码

    lo = 0;
    while( lo <= hi ) {
        target = (lo + hi) >> 1;
        pc = ln_tbl[target].pc;
        if( FindLineInfo.a.addr < pc ) {
            hi = target - 1;
        } else if( FindLineInfo.a.addr > pc ) {
            lo = target + 1;
        } else {                  /* exact match */
            info->line_index = target;
            info->ret = SR_EXACT;
            return;
        }
    }
    if( hi < 0 ) return;
    info->line_index = hi;
    info->ret = SR_CLOSEST;
}

unsigned ReqRead_mem()
/********************/
{
    read_mem_req        *acc;
    char                *data;
    int                 length;
    ClassClass          *cb;
    char                buff[512], *p;

    acc = GetInPtr(0);
    data = GetOutPtr( 0 );
    length = acc->len;
    switch( acc->mem_addr.segment ) {
    case MAD_JVM_USER_MEM_SELECTOR:
    case MAD_JVM_UNKNOWN_SELECTOR:
    case MAD_JVM_DIP_MEM_SELECTOR:
    default:
        return( DoRead( acc->mem_addr.offset, data, length ) );
    case MAD_JVM_FINDCLASS_SELECTOR:
        DoRead( acc->mem_addr.offset, buff, sizeof( buff ) );
        p = strchr( buff, ';' );
        if( p ) *p = '\0';
        cb = FindClass( EE(), buff, FALSE );
        if( length < sizeof( cb ) ) return( 0 );
        memcpy( data, (char const*)&cb, sizeof( cb ) );
        return( sizeof( cb ) );
    case MAD_JVM_FINDLINECUE_SELECTOR:
        if( length < sizeof( mad_jvm_findline_ret ) ) return( 0 );
        LineNumLookup( (mad_jvm_findline_ret*)data );
        return( sizeof( mad_jvm_findline_ret ) );
    case MAD_JVM_FINDADDRCUE_SELECTOR:
        if( length < sizeof( mad_jvm_findline_ret ) ) return( 0 );
        LineAddrLookup( (mad_jvm_findline_ret*)data );
        return( sizeof( mad_jvm_findline_ret ) );
    }
}

unsigned ReqWrite_mem( void )
/***************************/
{
    DWORD               offset;
    DWORD               length,len;
    LPSTR               data;
    write_mem_req       *acc;
    write_mem_ret       *ret;

    acc = GetInPtr(0);
    ret = GetOutPtr(0);

    ret->len = 0;
    offset = acc->mem_addr.offset;
    len = length = GetTotalSize() - sizeof( *acc );
    data = (LPSTR) GetInPtr( sizeof( *acc ) );
    switch( acc->mem_addr.segment ) {
    case MAD_JVM_FINDLINECUE_SELECTOR:
        FindLineInfo.l = *(mad_jvm_findlinecue_acc*)data;
        ret->len = sizeof( mad_jvm_findlinecue_acc );
        break;
    case MAD_JVM_FINDADDRCUE_SELECTOR:
        FindLineInfo.a = *(mad_jvm_findaddrcue_acc*)data;
        ret->len = sizeof( mad_jvm_findaddrcue_acc );
        break;
    default:
        ret->len = DoWrite( offset, data, length );
        break;
    }
    return( sizeof( *ret ) );
}

unsigned ReqRead_io()
/*******************/
{
    // never called
    return( 0 );
}


unsigned ReqWrite_io()
/********************/
{
    write_io_ret        *ret;

    ret = GetOutPtr(0);
    ret->len = 0;
    return( sizeof( *ret ) );
}

static void GetRegs( unsigned_32 *pc,
                     unsigned_32 *frame,
                     unsigned_32 *optop,
                     unsigned_32 *vars )
/**************************************/
{
    ExecEnv             *ee;

    if( CurrThread == NULL ) {
        if( pc ) *pc = 0;
        if( frame ) *frame = 0;
        if( optop ) *optop = 0;
        if( vars ) *vars = 0;
        return;
    }
    ee = (ExecEnv*)CurrThread->eetop;
    if( pc ) *pc = (unsigned_32)ee->current_frame->lastpc;
    if( optop ) *optop = (unsigned_32)ee->current_frame->optop;
    if( vars ) *vars = (unsigned_32)ee->current_frame->vars;
    if( frame ) *frame = (unsigned_32)ee->current_frame;
}

unsigned ReqRead_regs( void )
/***************************/
{
    mad_registers       _WCUNALIGNED *mr;

    mr = GetOutPtr( 0 );
    memset( mr, 0, sizeof( mr->jvm ) );
    GetRegs( &mr->jvm.pc, &mr->jvm.frame, &mr->jvm.optop, &mr->jvm.vars );
    return( sizeof( mr->jvm ) );
}

unsigned ReqWrite_regs( void )
/****************************/
{
    mad_registers       _WCUNALIGNED *mr;

    if( CurrThread == NULL ) {
        return( 0 );
    }
    mr = GetInPtr( sizeof( write_regs_req ) );
    // NYI: cannot write registers
    return( 0 );
}

static struct methodblock *
FindMethod(ClassClass *cb, char *name, char *sig)
/***********************************************/
{
    int i = cb->methods_count;
    struct methodblock *mb = cbMethods(cb);

    while (--i >= 0) {
        struct fieldblock *fb = &mb->fb;
        if (strcmp(fieldname(fb), name) == 0 &&
            strcmp(fieldsig(fb), sig) == 0) {
            return mb;
        }
        mb++;
    }
    return NULL;
}

/*
 * Build argument array to be passed to "main"
 */
static HArrayOfString *
BuildArguments( char **argv, struct execenv *ee)
/**********************************************/
{
    int argc;
    HArrayOfString *args;

    for( argc = 0; argv[argc] != NULL; ++argc ) ;
    args = (HArrayOfString *)ArrayAlloc(T_CLASS, argc);
    if (args == NULL) {
        return NULL;
    }
    /* Give the array a "type" */
    unhand((HArrayOfObject *)args)->body[argc] =
                        (JHandle *)FindClass(ee, JAVAPKG "String", TRUE);
    while (--argc >= 0) {
        char *s = argv[argc];
        if ((unhand(args)->body[argc] = makeJavaString(s, strlen(s))) == NULL) {
            return NULL;
        }
    }
    return args;
}

static int SplitParms( char *p, char *args[], unsigned len )
/**********************************************************/
{
    int     i;
    char    endc;

    i = 0;
    if( len == 1 ) goto done;
    for( ;; ) {
        for( ;; ) {
            if( len == 0 ) goto done;
            if( *p != ' ' && *p != '\t' ) break;
            ++p;
            --len;
        }
        if( len == 0 ) goto done;
        if( *p == '"' ) {
            --len;
            ++p;
            endc = '"';
        } else {
            endc = ' ';
        }
        if( args != NULL ) args[i] = p;
        ++i;
        for( ;; ) {
            if( len == 0 ) goto done;
            if( *p == endc
                || *p == '\0'
                || (endc == ' ' && *p == '\t' ) ) {
                if( args != NULL ) {
                    *p = '\0';  //TODO: not a good idea, should make a copy
                }
                ++p;
                --len;
                if( len == 0 ) goto done;
                break;
            }
            ++p;
            --len;
        }
    }
done:
    return( i );
}

#pragma aux (cdecl) PlantAppletBreak "Java_sun_tools_debug_jvmhelp_PlantAppletBreak_stub" export
stack_item *PlantAppletBreak( stack_item *p, ExecEnv *ee )
/********************************************************/
{
    int         len;
    Classjava_lang_String *applet;
    char        *dst;
    unicode     *src;
    char        *buff;
    ClassClass  *cb;
    struct methodblock  *mb;
    char        *dot;

    applet  = unhand((HString*)p[0].h);
    len = obj_length(applet->value);
    buff = __alloca( len + 1 );
    dst = buff;
    src = unhand(applet->value)->body;
    while( *src ) {
        if( --len < 0 ) break;
        *dst++ = *src++;
    }
    *dst = '\0';
    dst = buff;
    for( ;; ) {
        dot = strchr( dst, '.' );
        if( dot == NULL ) break;
        if( stricmp( dot, ".class" ) == 0 ) {
            *dot = '\0';
            break;
        }
        dst = dot+1;
    }
    cb = FindClass(ee, buff, TRUE);
    if( cb == NULL ) return( p );
    mb = FindMethod(cb, "init", "()V");
    if( mb == NULL ) return( p );
    AddStartingBreakpoint( (unsigned)mb->code );
    ++AppsLoaded;
    return( p );
}

#pragma aux (cdecl) LoadCallBack "Java_sun_tools_debug_jvmhelp_LoadCallBack_stub" export
stack_item *LoadCallBack( stack_item *p, ExecEnv *ee )
/****************************************************/
{
    prog_load_req       *acc;
    prog_load_ret       *ret;
    char                *parm;
    char                *parms;
    int                 i,len;
    char                *parm_start;
    char                **args;
    struct methodblock  *mb;
    bool                html;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    /* the IS_STARTED flag is to stop the "go main" in the profile. We're
       already at main */
    ret->flags = LD_FLAG_IS_STARTED | LD_FLAG_IGNORE_SEGMENTS | LD_FLAG_HAVE_RUNTIME_DLLS;
    parm = GetInPtr( sizeof( *acc ) );
    parms = (char *)GetInPtr( sizeof( *acc ) );
    parm_start = parms;
    len = GetTotalSize() - sizeof( *acc );
    if( acc->true_argv ) {
        i = 1;
        for( ;; ) {
            if( len == 0 ) break;
            if( *parms == '\0' ) {
                i++;
            }
            ++parms;
            --len;
        }
        args = __alloca( i * sizeof( *args ) );
        parms = parm_start;
        len = GetTotalSize() - sizeof( *acc );
        i = 1;
        for( ;; ) {
            if( len == 0 ) break;
            if( *parms == '\0' ) {
                args[ i++ ] = parms + 1;
            }
            ++parms;
            --len;
        }
        args[ i-1 ] = NULL;
    } else {
        while( *parms != '\0' ) {
            ++parms;
            --len;
        }
        ++parms;
        --len;
        i = SplitParms( parms, NULL, len );
        args = __alloca( (i+3) * sizeof( *args ) );
        args[ SplitParms( parms, &args[1], len ) + 1 ] = NULL;
    }
    args[0] = parm_start;

    html = FALSE;
    CbMain = FindClass(ee, parm, TRUE);
    if (CbMain == NULL) {
        html = TRUE;
        CbMain = FindClass( ee, "sun/applet/AppletViewer", TRUE );
        if( CbMain == NULL ) {
            ret->err = ERR_JVM_CANT_FIND_APPLETVIEWER;
            Event( 0 );
            return( p );
        }
    }
    mb = FindMethod(CbMain, "main", "([Ljava/lang/String;)V");
    if (mb == NULL) {
        ret->err = ERR_JVM_CANT_FIND_MAIN;
        Event( 0 );
        return( p );
    }
    if( html ) {
        execute_java_static_method(0, cbCallJava, "ParseHTML", "([Ljava/lang/String;)V", BuildArguments( args, ee ) );
    } else {
        ++AppsLoaded;
        AddStartingBreakpoint( (unsigned)mb->code );
    }
    ret->task_id = 1;
    ret->mod_handle = -1; // not an index!
    do_execute_java_method( ee, CbMain, 0, 0, mb, TRUE, (JHandle *) BuildArguments( args, ee ) );
    if( html ) {
        TheBigSleep();
    } else {
        CurrThreadIdx = -1;
        NumThreads = 0;
        Event( COND_TERMINATE );
    }
    return( p );
}

unsigned ReqProg_load()
/*********************/
{
    prog_load_ret       *ret;

    ret = GetOutPtr( 0 );
    AppsLoaded = 0;
    execute_java_static_method(0, cbCallJava, "Load", "()V", NULL );
    WaitForEvent();
    if( AppsLoaded == 0 ) {
        if( ret->err == 0 ) {
            ret->err = ERR_JVM_CANT_LOAD;
        }
    }
    return( sizeof( prog_load_ret ) );
}

unsigned ReqProg_kill()
/*********************/
{
    prog_kill_ret       *ret;

    AppsLoaded = 0;
    ret = GetOutPtr( 0 );
    ret->err = 0;
    return( sizeof( *ret ) );
}


unsigned ReqSet_watch()
/*********************/
{
    // nyi
    return( 0 );
}

unsigned ReqClear_watch()
/***********************/
{
    // nyi
    return( 0 );
}

unsigned ReqSet_break()
/*********************/
{
    set_break_req       *acc;
    set_break_ret       *ret;
    brk                 *new;
    char                ch;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );

    DoRead( acc->break_addr.offset, &ch, sizeof(ch) );
    ret->old = ch;
    new = LocalAlloc( LMEM_FIXED, sizeof( *new ) );
    new->next = BPList;
    BPList = new;
    new->pc = acc->break_addr.offset;
    new->saved = ch;
    DoWrite( acc->break_addr.offset, OP_BREAK, 1 );
    return( sizeof( *ret ) );
}

unsigned ReqClear_break()
/***********************/
{