madman.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 2,275 行 · 第 1/5 页

/*
 *      Calling Conventions
 */


static mad_status DIGREGISTER DummyCallStackGrowsUp( void )
{
    return( MS_FAIL );
}

mad_status      MADCallStackGrowsUp( void )
{
    return( Active->rtns->MICallStackGrowsUp() );
}

static const mad_string *DIGREGISTER DummyCallTypeList( void )
{
    return( EmptyStrList );
}

const mad_string        *MADCallTypeList( void )
{
    return( Active->rtns->MICallTypeList() );
}

static mad_status DIGREGISTER DummyCallBuildFrame( mad_string ct, address ret, address rtn, const mad_registers *in, mad_registers *out )
{
    ct = ct;
    ret = ret;
    rtn = rtn;
    in = in;
    out = out;
    return( MS_UNSUPPORTED );
}

mad_status              MADCallBuildFrame( mad_string ct, address ret, address rtn, const mad_registers *in, mad_registers *out )
{
    return( Active->rtns->MICallBuildFrame( ct, ret, rtn, in, out ) );
}

static const mad_reg_info * DIGREGISTER DummyCallReturnReg( mad_string ct, address a )
{
    ct = ct;
    a = a;
    return( NULL );
}

const mad_reg_info      *MADCallReturnReg( mad_string ct, address a )
{
    return( Active->rtns->MICallReturnReg( ct, a ) );
}

static const mad_reg_info **DIGREGISTER DummyCallParmRegList( mad_string ct, address a )
{
    static const mad_reg_info *list[] = { NULL };

    ct = ct;
    a = a;
    return( list );
}

const mad_reg_info      **MADCallParmRegList( mad_string ct, address a )
{
    return( Active->rtns->MICallParmRegList( ct, a ) );
}

static unsigned DIGREGISTER DummyCallUpStackSize( void )
{
    return( 1 );
}

unsigned                MADCallUpStackSize( void )
{
    return( Active->rtns->MICallUpStackSize() );
}

static mad_status DIGREGISTER DummyCallUpStackInit( mad_call_up_data *cud, const mad_registers *mr )
{
    cud = cud;
    mr = mr;
    return MS_OK;
}

mad_status              MADCallUpStackInit( mad_call_up_data *cud, const mad_registers *mr )
{
    return( Active->rtns->MICallUpStackInit( cud, mr ) );
}

static mad_status DIGREGISTER DummyCallUpStackLevel( mad_call_up_data *cud, address const *start, unsigned rtn_characteristics, long return_disp, mad_registers const *in, address *execution, address *frame, address *stack, mad_registers **out )
{
    cud = cud;
    start = start;
    rtn_characteristics = rtn_characteristics;
    return_disp = return_disp;
    in = in;
    execution = execution;
    frame = frame;
    stack = stack;
    out = out;
    return( MS_FAIL );
}

mad_status              MADCallUpStackLevel( mad_call_up_data *cud, address const *start, unsigned rtn_characteristics, long return_disp, const mad_registers *in, address *execution, address *frame, address *stack, mad_registers **out )
{
    return( Active->rtns->MICallUpStackLevel( cud, start, rtn_characteristics,
                return_disp, in, execution, frame, stack, out ) );
}

/*
 *      Instruction Disassembly
 */

#define ILL_INSTR       "????"
#define INSTR_LEN       (sizeof( ILL_INSTR ) - 1)

static unsigned DIGREGISTER DummyDisasmDataSize( void )
{
    return( 1 );
}

unsigned                MADDisasmDataSize( void )
{
    return( Active->rtns->MIDisasmDataSize() );
}

static unsigned DIGREGISTER DummyDisasmNameMax( void )
{
    return( INSTR_LEN );
}

unsigned                MADDisasmNameMax( void )
{
    return( Active->rtns->MIDisasmNameMax() );
}

static mad_status DIGREGISTER DummyDisasm( mad_disasm_data *dd, address *a, int adj )
{
    dd = dd;
    a->mach.offset += adj;
    return( MS_OK );
}

mad_status              MADDisasm( mad_disasm_data *dd, address *a, int adj )
{
    return( Active->rtns->MIDisasm( dd, a, adj ) );
}

static unsigned DIGREGISTER DummyDisasmFormat( mad_disasm_data *dd, mad_disasm_piece dp, unsigned radix, unsigned max, char *buff )
{
    dd = dd;
    radix = radix;
    if( !(dp & MDP_INSTRUCTION) ) return( 0 );
    if( max > 0 ) {
        --max;
        if( max > INSTR_LEN ) max = INSTR_LEN;
        memcpy( buff, ILL_INSTR, max );
        buff[max] = '\0';
    }
    return( INSTR_LEN );
}

unsigned                MADDisasmFormat( mad_disasm_data *dd, mad_disasm_piece dp, unsigned radix, unsigned max, char *buff )
{
    return( Active->rtns->MIDisasmFormat( dd, dp, radix, max, buff ) );
}

static unsigned DIGREGISTER DummyDisasmInsSize( mad_disasm_data *dd )
{
    dd = dd;
    return( 1 );
}

unsigned                MADDisasmInsSize( mad_disasm_data *dd )
{
    return( Active->rtns->MIDisasmInsSize( dd ) );
}

static mad_status DIGREGISTER DummyDisasmInsUndoable( mad_disasm_data *dd )
{
    dd = dd;
    return( MS_FAIL );
}

mad_status              MADDisasmInsUndoable( mad_disasm_data *dd )
{
    return( Active->rtns->MIDisasmInsUndoable( dd ) );
}

static mad_disasm_control DIGREGISTER DummyDisasmControl( mad_disasm_data *dd, const mad_registers *mr )
{
    dd = dd;
    mr = mr;
    return( MDC_OPER | MDC_TAKEN );
}

mad_disasm_control      MADDisasmControl( mad_disasm_data *dd, const mad_registers *mr )
{
    return( Active->rtns->MIDisasmControl( dd, mr ) );
}

static mad_status DIGREGISTER DummyDisasmInsNext( mad_disasm_data *dd, const mad_registers *mr, address *a )
{
    dd = dd;
    mr = mr;
    a = a;
    return( MS_FAIL );
}

mad_status              MADDisasmInsNext( mad_disasm_data *dd, const mad_registers *mr, address *a )
{
    return( Active->rtns->MIDisasmInsNext( dd, mr, a ) );
}

static mad_status DIGREGISTER DummyDisasmInspectAddr( char *start, unsigned len, unsigned radix, const mad_registers *mr, address *a )
{
    start = start;
    len = len;
    radix = radix;
    mr = mr;
    a = a;
    return( MS_FAIL );
}

mad_status              MADDisasmInspectAddr( char *start, unsigned len, unsigned radix, const mad_registers *mr, address *a )
{
    return( Active->rtns->MIDisasmInspectAddr( start, len, radix, mr, a ) );
}

static walk_result DIGREGISTER DummyDisasmMemRefWalk( mad_disasm_data *dd, MI_MEMREF_WALKER *wk, const mad_registers *mr, void *d )
{
    dd = dd;
    wk = wk;
    mr = mr;
    d  = d;
    return( WR_CONTINUE );
}

struct memref_glue {
    MAD_MEMREF_WALKER   *wk;
    void                *d;
};

static walk_result DIGCLIENT MemRefGlue( address a, mad_type_handle th, mad_memref_kind mk, void *d )
{
    struct memref_glue  *gd = d;

    return( gd->wk( a, th, mk, gd->d ) );
}

walk_result             MADDisasmMemRefWalk( mad_disasm_data *dd, MAD_MEMREF_WALKER *wk, const mad_registers *mr, void *d )
{
    struct memref_glue  glue;

    glue.wk = wk;
    glue.d  = d;
    return( Active->rtns->MIDisasmMemRefWalk( dd, MemRefGlue, mr, &glue ) );
}

static const mad_toggle_strings *DIGREGISTER DummyDisasmToggleList( void )
{
    return( EmptyToggleList );
}

const mad_toggle_strings        *MADDisasmToggleList( void )
{
    return( Active->rtns->MIDisasmToggleList() );
}

static unsigned DIGREGISTER DummyDisasmToggle( unsigned on, unsigned off )
{
    on = on;
    off = off;
    return( 0 );
}

unsigned                MADDisasmToggle( unsigned on, unsigned off )
{
    return( Active->rtns->MIDisasmToggle( on, off ) );
}


/*
 *      Instruction Tracing
 */

static unsigned DIGREGISTER DummyTraceSize( void )
{
    return( 1 );
}

unsigned        MADTraceSize( void )
{
    return( Active->rtns->MITraceSize() );
}

static void DIGREGISTER DummyTraceInit( mad_trace_data *td, const mad_registers *mr )
{
    td = td;
    mr = mr;
}

void            MADTraceInit( mad_trace_data *td, const mad_registers *mr )
{
    Active->rtns->MITraceInit( td, mr );
}

static mad_trace_how DIGREGISTER DummyTraceOne( mad_trace_data *td, mad_disasm_data *dd, mad_trace_kind tk, const mad_registers *mr, address *a )
{
    td = td;
    dd = dd;
    tk = tk;
    mr = mr;
    a  = a;
    return( MTRH_STOP );
}

mad_trace_how   MADTraceOne( mad_trace_data *td, mad_disasm_data *dd, mad_trace_kind tk, const mad_registers *mr, address *a )
{
    return( Active->rtns->MITraceOne( td, dd, tk, mr, a ) );
}

static mad_status DIGREGISTER DummyTraceHaveRecursed( address a, const mad_registers *mr )
{
    a = a;
    mr = mr;
    return( MS_FAIL );
}

mad_status      MADTraceHaveRecursed( address a, const mad_registers *mr )
{
    return( Active->rtns->MITraceHaveRecursed( a, mr ) );
}

static mad_status DIGREGISTER DummyTraceSimulate( mad_trace_data *td, mad_disasm_data *dd, const mad_registers *in, mad_registers *out )
{
    td = td;
    dd = dd;
    in = in;
    out=out;
    return( MS_OK );
}

mad_status      MADTraceSimulate( mad_trace_data *td, mad_disasm_data *dd, const mad_registers *in, mad_registers *out )
{
    return( Active->rtns->MITraceSimulate( td, dd, in, out ) );
}

static void DIGREGISTER DummyTraceFini( mad_trace_data *td )
{
    td = td;
}

void            MADTraceFini( mad_trace_data *td )
{
    Active->rtns->MITraceFini( td );
}

static mad_status DIGREGISTER DummyUnexpectedBreak( mad_registers *mr, unsigned *max, char *buff )
{
    mr = mr;

    if( *max > 0 ) *buff = '\0';
    *max = 0;
    return( MS_FAIL );
}

mad_status      MADUnexpectedBreak( mad_registers *mr, unsigned *max, char *buff )
{
    return( Active->rtns->MIUnexpectedBreak( mr, max, buff ) );
}


static mad_imp_routines DummyRtns = {
    MAD_MAJOR,
    MAD_MINOR,
    sizeof( DummyRtns ),

    DummyInit,
    DummyFini,
    DummyStateSize,
    DummyStateInit,
    DummyStateSet,
    DummyStateCopy,

    DummyAddrAdd,
    DummyAddrComp,
    DummyAddrDiff,
    DummyAddrMap,
    DummyAddrFlat,
    DummyAddrInterrupt,

    DummyTypeWalk,
    DummyTypeName,
    DummyTypePreferredRadix,
    DummyTypeForDIPType,
    DummyTypeInfo,
    DummyTypeDefault,
    DummyTypeConvert,
    DummyTypeToString,

    DummyRegistersSize,
    DummyRegistersHost,
    DummyRegistersTarget,
    DummyRegSetWalk,
    DummyRegSetName,
    DummyRegSetLevel,
    DummyRegSetDisplayGrouping,
    DummyRegSetDisplayGetPiece,
    DummyRegSetDisplayModify,
    DummyRegSetDisplayToggleList,
    DummyRegSetDisplayToggle,
    DummyRegModified,
    DummyRegInspectAddr,
    DummyRegWalk,
    DummyRegSpecialGet,
    DummyRegSpecialSet,
    DummyRegSpecialName,
    DummyRegFromContextItem,
    DummyRegUpdateStart,
    DummyRegUpdateEnd,

    DummyCallStackGrowsUp,
    DummyCallTypeList,
    DummyCallBuildFrame,
    DummyCallReturnReg,
    DummyCallParmRegList,
    NULL,

    DummyDisasmDataSize,
    DummyDisasmNameMax,
    DummyDisasm,
    DummyDisasmFormat,
    DummyDisasmInsSize,
    DummyDisasmInsUndoable,
    DummyDisasmControl,
    DummyDisasmInspectAddr,
    DummyDisasmMemRefWalk,
    DummyDisasmToggleList,
    DummyDisasmToggle,

    DummyTraceSize,
    DummyTraceInit,
    DummyTraceOne,
    DummyTraceHaveRecursed,
    DummyTraceSimulate,
    DummyTraceFini,

    DummyUnexpectedBreak,
    DummyDisasmInsNext,
    DummyCallUpStackSize,
    DummyCallUpStackInit,
    DummyCallUpStackLevel,
};