msjacc.c

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

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include <windows.h>
#include <malloc.h>
#include <string.h>
#include "trpimp.h"
#define MD_jvm
#include "madregs.h"
#include "msjerr.h"
#include "control.h"
#include "dipshim.h"
#include "msjutil.h"
#include "readwr.h"

static bool     TaskLoaded;
HANDLE          FakeHandle;

HWND            DebuggerWindow;

trap_version TRAPENTRY TrapInit( char *parm, char *err, bool remote )
/*******************************************************************/
{
    trap_version        ver;

    MSJMemInit();
    remote = remote; parm = parm;
    ver.major = TRAP_MAJOR_VERSION;
    ver.minor = TRAP_MINOR_VERSION;
    ver.remote = FALSE;
    TaskLoaded = FALSE;
    if( InitProc() ) {
        err[0] = '\0'; /* all ok */
    } else {
        strcpy( err, "unable to connect to debug manager" );
    }
    FakeHandle = (HANDLE)&TrapInit;
    return ver;
}

void TRAPENTRY TrapFini()
/***********************/
{
    FiniProc();
    MSJMemFini();
}

unsigned ReqGet_sys_config( void )
/********************************/
{
    get_sys_config_ret *ret;

    ret = GetOutPtr(0);
    ret->sys.cpu = 0;
    ret->sys.fpu = 0;
    ret->sys.mad = MAD_MSJ;
    ret->sys.huge_shift = 3;
    if( !TaskLoaded ) {
        ret->sys.os = OS_IDUNNO;
        ret->sys.osmajor = 0;
        ret->sys.osminor = 0;
    } else {
        ret->sys.os = OS_NT;
        ret->sys.osmajor = 1;
        ret->sys.osminor = 0;
    }
    return sizeof( *ret );
}

unsigned ReqMap_addr( void )
/**************************/
{
    map_addr_req *      acc;
    map_addr_ret *      ret;

    acc = GetInPtr(0);
    ret = GetOutPtr(0);
    ret->out_addr = acc->in_addr;
    ret->lo_bound = 0;
    ret->hi_bound = ~(addr48_off)0;
    return sizeof( *ret );
}

unsigned ReqAddr_info( void )
/***************************/
{
    addr_info_ret *     ret;

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

unsigned ReqChecksum_mem( void )
/******************************/
{
    unsigned_8 *        buffer;
    checksum_mem_req *  acc;
    checksum_mem_ret *  ret;
    unsigned            actual;
    unsigned            sum;

    ret = GetOutPtr( 0 );
    ret->result = 0;
    if( TaskLoaded ) {
        acc = GetInPtr(0);
        buffer = (unsigned_8 *) alloca( acc->len );
        if( buffer != NULL ) {
            sum = 0;
            actual = ReadMemory( &acc->in_addr, buffer, acc->len );
            while( actual > 0 ) {
                sum += *buffer;
                buffer++;
                actual--;
            }
            ret->result = sum;
        }
    }
    return sizeof( *ret );
}

unsigned DoRead( int addr, char *buff, unsigned length )
/******************************************************/
{
    DWORD               bytes;

    ReadProcessMemory( GetCurrentProcess(), (LPVOID)addr, buff,
                        length, (LPDWORD) &bytes );
    return( bytes );
}

unsigned ReqRead_mem( void )
/**************************/
{
    read_mem_req *acc;

    if( !TaskLoaded ) return 0;
    acc = GetInPtr(0);
    switch( acc->mem_addr.segment ) {
    case JVM_DIP_GETCUE_SELECTOR:
        return( DipCue( acc->mem_addr.offset, GetOutPtr(0) ) );
    case JVM_DIP_GETFILE_SELECTOR:
        return( DipFileName( acc->mem_addr.offset, GetOutPtr(0) ) );
    case JVM_DIP_GETMODNAME_SELECTOR:
        return( DipModName( acc->mem_addr.offset, GetOutPtr(0) ) );
    case JVM_DIP_GETMODBASE_SELECTOR:
        return( DipModBase( acc->mem_addr.offset, GetOutPtr(0) ) );
    case JVM_DIP_GETMODEND_SELECTOR:
        return( DipModEnd( acc->mem_addr.offset, GetOutPtr(0) ) );
    case JVM_MAD_UPSTACK_SELECTOR:
        return( MadUpStack( &acc->mem_addr, GetOutPtr(0) ) );
    case JVM_DIP_READMEM_SELECTOR:
        return( DoRead( acc->mem_addr.offset, GetOutPtr(0), acc->len ) );
    default:
        return( ReadMemory( &acc->mem_addr, GetOutPtr(0), acc->len ) );
    }
}

unsigned DoWrite( int addr, char *buff, unsigned length )
/*******************************************************/
{
    DWORD               bytes;

    WriteProcessMemory( GetCurrentProcess(), (LPVOID)addr, buff,
                        length, (LPDWORD) &bytes );
    return( bytes );
}

unsigned ReqWrite_mem( void )
/***************************/
{
    write_mem_ret *     ret;
    write_mem_req *     acc;
    unsigned            length;
    void *              data;

    ret = GetOutPtr( 0 );
    ret->len = 0;
    if( TaskLoaded ) {
        acc = GetInPtr(0);
        length = GetTotalSize() - sizeof(*acc);
        data = GetInPtr( sizeof(*acc) );
        switch( acc->mem_addr.segment ) {
        case JVM_DIP_READMEM_SELECTOR:
            ret->len = DoRead( acc->mem_addr.offset, GetOutPtr(0), length );
            break;
        default:
            ret->len = WriteMemory( &acc->mem_addr, data, length );
            break;
        }
    }
    return sizeof( *ret );
}

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

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

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

// OBSOLETE - use ReqRead_regs

unsigned ReqRead_cpu( void )
/**************************/
{
    read_cpu_ret *ret;

    ret = GetOutPtr(0);
    memset( ret, 0, sizeof( *ret ) );
    return sizeof( *ret );
}

unsigned ReqRead_fpu( void )
/**************************/
{
    read_fpu_ret * ret;

    ret = GetOutPtr(0);
    memset( ret, 0, sizeof( *ret ) );
    return sizeof( *ret );
}

unsigned ReqWrite_cpu( void )
/***************************/
{
    return 0;
}

unsigned ReqWrite_fpu( void )
/***************************/
{
    return 0;
}

static unsigned runProg( bool single_step )
/*****************************************/
{
    prog_go_ret *       ret;

    ret = GetOutPtr( 0 );
    if( !TaskLoaded ) {
        ret = GetOutPtr( 0 );
        ret->conditions = COND_TERMINATE;
        return sizeof( *ret );
    }
    if( single_step ) {
        TraceProc( &ret->program_counter );
    } else {
        ResumeProc( &ret->program_counter );
    }
    ret->conditions = ReadFlags() | COND_LIBRARIES;
    ret->stack_pointer.segment = 0;
    ret->stack_pointer.offset = 0;
    return sizeof( *ret );
}

unsigned ReqProg_go( void )
/*************************/
{
    return runProg( FALSE );
}

unsigned ReqProg_step( void )
/***************************/
{
    return runProg( TRUE );
}

static char * TrimName( char * name )
/***********************************/
{
    char * endptr;

    while( isspace( *name ) ) {
        name++;
    }
    endptr = name + strlen(name) - 1;
    while( isspace(*endptr) ) {
        *endptr = '\0';
        endptr--;
    }
    return name;
}

unsigned ReqProg_load( void )
/***************************/
{
    prog_load_ret *     ret;
    prog_load_req *     acc;
    char *              parm;
    char *              clname;
    unsigned            len;
    char                buff[_MAX_PATH*2];
    char                *dst,*src,ch;
    char                *name;

    ret = GetOutPtr( 0 );
    acc = GetInPtr( 0 );
    parm = GetInPtr( sizeof( prog_load_req ) );
    ret->err = ERR_MSJ_CANT_LOAD;
    if( parm == NULL ) return sizeof( *ret );
    strcpy( buff, parm );
    dst = &buff[strlen(buff)];
    src = parm;
    while( *src != 0 ) {
        ++src;
    }
    len = &parm[ GetTotalSize() - sizeof( *acc ) ] - src;
    for( ;; ) {