nlmacc.c

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

    if( ReadMemory( &acc->break_addr, 1UL, &l ) != 0 ) {
        ret->old = 0;
    } else {
        ch = 0xCC;
        WriteMemory( &acc->break_addr, 1UL, &ch );
        ret->old = l;
    }
    return( sizeof( *ret ) );
}

unsigned ReqClear_break( void )
{
    clear_break_req     *acc;

    acc = GetInPtr( 0 );
    WriteMemory( &acc->break_addr, 1UL, &acc->old );
    return( 0 );
}

static void ClearDebugRegs( void )
{
    int     i;

    for( i = 0; i < NUM_DREG; ++i ) {
        if( DR[i].type != NO_DREG ) {
            DR[i].type = NO_DREG;
            _DBG_DR(( "unreserve %d\r\n", i ));
            UnReserveABreakpoint( i );
        }
    }
}


static void ActivateDebugRegs( void )
{
    int         i;

    for( i = 0; i < NUM_DREG; ++i ) {
        if( DR[i].type != NO_DREG ) {
            _DBG_DR(( "set %d, addr=%8x, typ=%d, siz=%d\r\n", i, DR[i].address, DR[i].type, DR[i].size ));
           CSetABreakpoint( i, DR[i].address, DR[i].type, DR[i].size );
        }
    }
}

static bool SetDR( unsigned address, int len )
{
    int     i;
    i = DoReserveBreakpoint();
    _DBG_DR(( "reserved %d addr=%8x\r\n", i, address ));
    if( i < 0 ) {
        ClearDebugRegs();
        return( FALSE );
    }
    DR[i].address = address;
    DR[i].type = DR7_BWR;
    DR[i].size = len;
    return( TRUE );
}

static bool SetDebugRegs( void )
{
    int         i;
    unsigned    address;
    watch       *wp;

    for( i = WatchCount, wp = WatchPoints; i != 0; --i, ++wp ) {
        address = wp->addr.offset;
        _DBG_DR(( "offset = %8x, addr=%8x\r\n", wp->addr.offset, address ));
        if( !SetDR( wp->linear, wp->len ) )
            return( FALSE );
        if( wp->dregs == 2 ) {
            if( !SetDR( wp->linear+wp->len, wp->len ) )
                return( FALSE );
        }
    }
    return( TRUE );
}

static unsigned ProgRun( bool step )
{
    watch       *wp;
    int         i;
    dword       value;
    prog_go_ret *ret;

    ret = GetOutPtr( 0 );
    ret->conditions = COND_THREAD;
    if( MSB == NULL ) {
        ret->conditions = COND_TERMINATE;
    } else if( step ) {
        MSB->cpu.EFL |= FLG_T;
        TrapInt1 = TRUE;
        ret->conditions |= Execute( MSB );
        TrapInt1 = FALSE;
    } else if( WatchCount != 0 ) {
        if( SetDebugRegs() ) {
            TrapInt1 = TRUE;
            ret->conditions |= Execute( NULL );
            TrapInt1 = FALSE;
        } else {
            for( ;; ) {
                MSB->cpu.EFL |= FLG_T;
                TrapInt1 = TRUE;
                ret->conditions |= Execute( MSB );
                TrapInt1 = FALSE;
                if( ret->conditions & COND_TERMINATE )
                    break;
                if( MSB->xnum != 1 )
                    break;
                if( !( MSB->errnum & DR6_BS ) )
                    break;
                for( wp = WatchPoints, i = WatchCount; i > 0; ++wp, --i ) {
                    ReadMemory( &wp->addr, 4UL, &value );
                    if( value != wp->value ) {
                        ret->conditions |= COND_WATCH;
                        goto leave;
                    }
                }
            }
        }
    } else {
        ret->conditions |= Execute( NULL );
    }
leave:
    if( MSB == NULL ) {
        ret->program_counter.offset = 0;
        ret->program_counter.segment = 0;
        ret->stack_pointer.offset = 0;
        ret->stack_pointer.segment = 0;
    } else {
        MSB->cpu.EFL &= ~FLG_T;
        ret->program_counter.offset = MSB->cpu.EIP;
        ret->program_counter.segment = MSB->cpu.CS;
        ret->stack_pointer.offset = MSB->cpu.ESP;
        ret->stack_pointer.segment = MSB->cpu.SS;
    }
    WatchCount = 0;
    return( sizeof( *ret ) );
}

unsigned ReqProg_go( void )
{
    return( ProgRun( FALSE ) );
}

unsigned ReqProg_step( void )
{
    return( ProgRun( TRUE ) );
}

unsigned ReqGet_next_alias( void )
{
    get_next_alias_ret  *ret;

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

static msb *LocateTid( dword tid )
{
    msb *m;

    m = MSBHead;
    for( ;; ) {
        if( m == NULL )
            return( NULL );
        if( m->dbg_id == tid )
            return( m );
        m = m->next;
    }
}


unsigned ReqThread_get_next( void )
{
    msb             *m;
    thread_get_next_req *acc;
    thread_get_next_ret *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    if( acc->thread == 0 ) {
        m = MSBHead;
    } else {
        m = LocateTid( acc->thread );
        if( m != NULL )
            m = m->next;
    }
    if( m != NULL ) {
        ret->thread = m->dbg_id;
        ret->state = m->frozen ? THREAD_FROZEN : THREAD_THAWED;
    } else {
        ret->thread = 0;
    }
    return( sizeof( *ret ) );
}


unsigned ReqThread_set( void )
{
    msb            *m;
    thread_set_req      *acc;
    thread_set_ret      *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->err = 0;
    if( MSB != NULL ) {
        ret->old_thread = MSB->dbg_id;
    } else {
        ret->old_thread = 0;
    }
    if( acc->thread != 0 ) {
        m = LocateTid( acc->thread );
        if( m != NULL && m->asleep ) {
            _DBG_THREAD(( "AccSetThread to=%d (MSB=%8x) -- \r\n", m->dbg_id, m ));
            MSB = m;
        } else {
            ret->err = 1;
        }
    }
    return( sizeof( *ret ) );
}


unsigned ReqThread_freeze( void )
{
    msb               *m;
    thread_freeze_req   *acc;
    thread_freeze_ret   *ret;

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

    m = LocateTid( acc->thread );
    if( m == NULL ) {
        ret->err = 1;  // Failed
    } else {
        _DBG_THREAD(( "freezing %8x\r\n", m ));
        m->frozen = TRUE;
        ret->err = 0;
    }
    return( sizeof( *ret ) );
}

unsigned ReqThread_thaw( void )
{
    msb             *m;
    thread_thaw_req     *acc;
    thread_thaw_ret     *ret;

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

    m = LocateTid( acc->thread );
    if( m == NULL ) {
        ret->err = 1;  // Failed
    } else {
        _DBG_THREAD(( "thawing %8x\r\n", m ));
        m->frozen = FALSE;
        ret->err = 0;
    }
    return( sizeof( *ret ) );
}


unsigned ReqThread_get_extra( void )
{
    msb              *m;
    char             *name;
    thread_get_extra_req        *acc;

    acc = GetInPtr( 0 );
    name = GetOutPtr( 0 );
    if( acc->thread == 0 ) {
        strcpy( name, "name" );
    } else {
        m = LocateTid( acc->thread );
        if( m == NULL ) {
            *name = '\0';
        } else {
            strcpy( name, GetPIDName( m->os_id ) );
        }
    }
    return( strlen( name ) + 1 );
}

unsigned ReqGet_err_text( void )
{
    char        *err;

    /* NYI */
    err = GetOutPtr( 0 );
    strcpy( err, TRP_ERR_unknown_system_error );
    return( strlen( err ) + 1 );
}

unsigned ReqGet_message_text( void )
{
    get_message_text_ret        *ret;
    char                        *err_txt;

    ret = GetOutPtr( 0 );
    err_txt = GetOutPtr( sizeof(*ret) );
    if( MSB->description != NULL ) {
        strcpy( err_txt, MSB->description );
    } else {
        err_txt[0] = '\0';
    }
    ret->flags = MSG_NEWLINE | MSG_ERROR;
    return( sizeof( *ret ) + strlen( err_txt ) + 1 );
}

#if 0
static LoadedListHandle GetLoadedListHandle( struct LoadDefinitionStructure *ld )
{
    LoadedListHandle    nlm;

    if( ld == NULL )
        return( 0 );
    nlm = GetNextLoadedListEntry( 0 );
    while( nlm != 0 ) {
        if( ld == ValidateModuleHandle( nlm ) ) {
            return( nlm );
        }
        nlm = GetNextLoadedListEntry( nlm );
    }
    return( 0 );
}
#endif

unsigned ReqGet_lib_name( void )
{
    int             len;
    get_lib_name_req    *acc;
    get_lib_name_ret    *ret;
    char            *name;
    nlm_entry           *curr;

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

    if( acc->handle == 0 ) {
        curr = NLMList;
    } else {
        curr = ((nlm_entry *)acc->handle)->next;
    }
    if( curr == LastNLMListEntry ) {
        LastNLMListEntry = NLMList;
        ret->handle = 0;
        return( sizeof( *ret ) );
    }
    ret->handle = (unsigned long)curr;
    name = GetOutPtr(sizeof(*ret));
    len = curr->ld.LDFileName[0];
    memcpy( name, &curr->ld.LDFileName[1], len );
    name[len] = '\0';
    if( curr->is_load ) {
        _DBG_MISC(("Loaded an NLM %s\r\n", name));
        return( sizeof( *ret ) + len + 1 );
    } else {
        _DBG_MISC(("UnLoaded NLM %s\r\n", name));
        name[0] = '\0';
        return( sizeof( *ret ) + 1 );
    }
}

unsigned ReqRedirect_stdin( void )
{
    redirect_stdin_ret  *ret;

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

unsigned ReqRedirect_stdout( void )
{
    redirect_stdout_ret *ret;

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


unsigned ReqSet_user_screen( void )
{
    /* NOT IMPLEMENTED */
    return( 0 );
}


unsigned ReqSet_debug_screen( void )
{
    /* NOT IMPLEMENTED */
    return( 0 );
}


unsigned ReqRead_user_keyboard( void )
{
    /* NOT IMPLEMENTED */
    read_user_keyboard_ret      *ret;

    ret = GetOutPtr( 0 );
    ret->key = '\0';
    return( sizeof( *ret ) );
}

unsigned ReqSplit_cmd( void )
{
    char             *cmd;
    char             *start;
    split_cmd_ret       *ret;
    unsigned            len;

    cmd = GetInPtr( sizeof( split_cmd_req ) );
    start = cmd;
    ret = GetOutPtr( 0 );
    len = GetTotalSize() - sizeof( split_cmd_req );

    for( ;; ) {
        if( len == 0 )
            goto done;
        switch( *cmd ) {
        case '\0':
            goto done;
        case ' ':
        case '\t':
            ret->parm_start = cmd - start + 1;
            ret->cmd_end = cmd - start;
            return( sizeof( *ret ) );
        }
        ++cmd;
        --len;
    }
done:
    ret->parm_start = cmd - start;
    ret->cmd_end = cmd - start;
    return( sizeof( *ret ) );
}


trap_version TRAPENTRY TrapInit( char *parm, char *err, bool remote )
{
    trap_version        ver;
    extern              struct LoadDefinitionStructure *MyNLMHandle;

#if defined ( __NW40__ )
    ImportCLIBSymbols();
#endif
    remote = remote; parm = parm;
    err[0] = '\0'; /* all ok */
    ver.major = TRAP_MAJOR_VERSION;
    ver.minor = TRAP_MINOR_VERSION;
    ver.remote = FALSE;
    FakeBreak = FALSE;
    RealNPXType = NPXType();
    WatchCount = 0;
#if defined ( _USE_NEW_KERNEL )
    kDebugSem = kSemaphoreAlloc( NULL, 0 );
    kHelperSem = kSemaphoreAlloc( NULL, 0 );
#else
    DebugSem = CAllocSemaphore( 0, SemaphoreTag );
    HelperSem = CAllocSemaphore( 0, SemaphoreTag );
#endif
    DebuggerLoadedNLM = NULL;
    NLMState = NLM_NONE;
    DebuggerRunning = TRUE;
    ExpectingEvent = FALSE;
    TrapInt1 = FALSE;
    DbgStruct.ddRTag = DebugTag;
    RegisterDebuggerRTag( &DbgStruct, ALWAYS_AT_FIRST );
    return( ver );
}

void TRAPENTRY TrapFini( void )
{
    UnRegisterDebugger( &DbgStruct );
    ExpectingEvent = FALSE;
    while( MSBHead )
        FreeThread( MSBHead );
#if defined ( _USE_NEW_KERNEL )
    if( kDebugSem )
        KernelSemaphoreReleaseAll( kDebugSem );
    kDebugSem = NULL;
    if( kHelperSem )
        KernelSemaphoreReleaseAll( kHelperSem );
    kHelperSem = 0;
#else
    if( DebugSem )
        CSemaphoreReleaseAll( DebugSem );
    DebugSem = 0;
    if( HelperSem )
        CSemaphoreReleaseAll( HelperSem );
    HelperSem = 0;
#endif
    while( NLMList != NULL ) {
        FreeAnNLMListEntry();
    }
    LastNLMListEntry = NULL;
}