os2v2acc.c

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

{
    Buff.Cmd = DBG_C_ReadMemBuf;
    Buff.Addr = lin;
    Buff.Buffer = (ULONG)data;
    Buff.Len = size;
    CallDosDebug(&Buff);
}

void WriteLinear( char *data, ULONG lin, USHORT size )
{
    Buff.Cmd    = DBG_C_WriteMemBuf;
    Buff.Addr   = lin;
    Buff.Buffer = (ULONG)data;
    Buff.Len    = size;
    CallDosDebug(&Buff);
}

USHORT WriteBuffer( char *data, USHORT segv, ULONG offv, USHORT size )
{
    USHORT      length;
    bool        iugs;
    USHORT      resdata;
    ULONG       flat;

    if( segv < 4 ) {
        return( 0 );
    }

    length = size;
    if( Pid != 0 ) {
        iugs = IsUnknownGDTSeg( segv );
        if( !iugs ) {
            flat = MakeItFlatNumberOne( segv, offv );
            WriteLinear( data, flat, size );
            if( Buff.Cmd == DBG_N_Success ) {
                return( size );
            }
        }
        while( length != 0 ) {
            Buff.Cmd = DBG_C_WriteMem_D;
            if( length == 1 ) {
                /* Don't want to write anything in the kernel area - that means no breakpoints! */
                if( iugs /*|| offv > KERNEL_MEM_OFFSET*/ ) {
                    if( !TaskReadWord( segv, offv, &resdata ) ) {
                        break;
                    }
                    resdata &= 0xff00;
                    resdata |= *data;
                    if( !TaskWriteWord( segv, offv, resdata ) ) {
                        break;
                    }
                } else {
                    Buff.Cmd = DBG_C_ReadMem_D;
                    Buff.Addr = MakeItFlatNumberOne( segv, offv );
                    CallDosDebug( &Buff );
                    Buff.Cmd = DBG_C_WriteMem_D;
                    Buff.Addr = MakeItFlatNumberOne( segv, offv );
                    Buff.Value &= 0xff00;
                    Buff.Value |= *data;
                    CallDosDebug( &Buff );
                    if( Buff.Cmd != DBG_N_Success ) {
                        break;
                    }
                }
                data++;
                length--;
                offv++;
            } else {
                resdata = *data;
                data++;
                resdata |= *data << 8;
                data++;
                if( iugs ) {
                    if( !TaskWriteWord( segv, offv, resdata ) ) {
                        break;
                    }
                } else {
                    Buff.Value = resdata;
                    Buff.Addr = MakeItFlatNumberOne( segv, offv );
                    CallDosDebug( &Buff );
                    if( Buff.Cmd != DBG_N_Success ) {
                        break;
                    }
                }
                length -= 2;
                offv += 2;
            }
        }
    }
    return( size - length ); /* return amount written */
}


static USHORT ReadBuffer( char *data, USHORT segv, ULONG offv, USHORT size )
{
    USHORT      length;
    bool        iugs;
    USHORT      resdata;
    ULONG       flat;

    if( segv < 4 ) {
        return( 0 );
    }
    length = size;
    if( Pid != 0 ) {
        iugs = IsUnknownGDTSeg( segv );
        if( !iugs ) {
            flat = MakeItFlatNumberOne( segv, offv );
            ReadLinear( data, flat, size );
            if( Buff.Cmd == DBG_N_Success ) {
                return( size );
            }
        }
        while( length != 0 ) {
            if( iugs || offv > KERNEL_MEM_OFFSET ) {
                if( !TaskReadWord( segv, offv, &resdata ) ) {
                    break;
                }
            } else {
                Buff.Cmd = DBG_C_ReadMem_D;
                Buff.Addr = MakeItFlatNumberOne( segv, offv );
                CallDosDebug(&Buff);
                if( Buff.Cmd != DBG_N_Success ) {
                    break;
                }
                resdata = Buff.Value;
            }
            *data = resdata & 0xff;
            data++;
            offv++;
            length--;
            if( length != 0 ) {
                *data = resdata >> 8;
                data++;
                offv++;
                length--;
            }
        }
    }
    return( size - length );
}


unsigned ReqGet_sys_config( void )
{
    ULONG               version[2];
    uDB_t               buff;
    char                tmp[DBG_LEN_387];
    get_sys_config_ret  *ret;

    ret = GetOutPtr( 0 );
    ret->sys.os = OS_OS2;
    DosQuerySysInfo( QSV_VERSION_MAJOR, QSV_VERSION_MINOR, &version, sizeof( version ) );
    ret->sys.osminor = version[1];
    ret->sys.osmajor = version[0];
    ret->sys.cpu     = X86CPUType();
    ret->sys.fpu     = ret->sys.cpu & X86_CPU_MASK;
    WriteRegs(&Buff);

    buff.Cmd    = DBG_C_ReadCoRegs;
    buff.Buffer = (ULONG)tmp;
    buff.Tid    = 1;
    buff.Pid    = Pid;
    buff.Value  = DBG_CO_387;       /* for 2.0: DBG_CO_387 */
    buff.Len    = DBG_LEN_387;      /* for 2.0: size of register state */
    buff.Index  = 0;                /* for 2.0: must be 0 */
    CallDosDebug( &buff );
    if( buff.Cmd != DBG_N_Success ) {
        ret->sys.fpu = X86_NO;
    }
    ret->sys.huge_shift = 3;
    ret->sys.mad = MAD_X86;
    return( sizeof( *ret ) );
}


unsigned ReqMap_addr( void )
{
    USHORT              seg;
    ULONG               flags;
    map_addr_req        *acc;
    map_addr_ret        *ret;
    unsigned            i;
    addr_off            off;

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

    GetObjectInfo( ModHandles[acc->handle] );

    seg = acc->in_addr.segment;
    off = acc->in_addr.offset;
    switch( seg ) {
        case MAP_FLAT_CODE_SELECTOR:
        case MAP_FLAT_DATA_SELECTOR:
            seg = 1;
            off += ObjInfo[0].addr;
            for( i = 0; i < NumObjects; ++i ) {
                if( ObjInfo[i].addr <= off
                        && ( ObjInfo[i].addr + ObjInfo[i].size ) > off ) {
                    seg = i + 1;
                    off -= ObjInfo[i].addr;
                    ret->lo_bound = ObjInfo[i].addr - ObjInfo[0].addr;
                    ret->hi_bound = ret->lo_bound + ObjInfo[i].size - 1;
                    break;
                }
            }
            break;
    }

    Buff.MTE = ModHandles[acc->handle];
    Buff.Cmd = DBG_C_NumToAddr;
    Buff.Value = seg;
    CallDosDebug(&Buff);
    Buff.MTE = ModHandles[0];
    flags = ObjInfo[seg - 1].flags;
    if( flags & OBJECT_IS_BIG ) {
        ret->out_addr.segment = ( flags & OBJECT_IS_CODE ) ? FlatCS : FlatDS;
        ret->out_addr.offset = Buff.Addr + off;
    } else {
        Buff.Cmd = DBG_C_LinToSel;
        CallDosDebug( &Buff );
        ret->out_addr.segment = Buff.Value;
        ret->out_addr.offset  = Buff.Index + off;
    }
    return( sizeof( *ret ) );
}

unsigned ReqAddr_info( void )
{
    addr_info_req       *acc;
    addr_info_ret       *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->is_32 = Is32BitSeg( acc->in_addr.segment );
    return( sizeof( *ret ) );
}

unsigned ReqMachine_data( void )
{
    machine_data_req    *acc;
    machine_data_ret    *ret;
    unsigned_8          *data;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    data = GetOutPtr( sizeof( *ret ) );
    ret->cache_start = 0;
    ret->cache_end = ~(addr_off)0;
    *data = 0;
    if( Is32BitSeg( acc->addr.segment ) )
        *data |= X86AC_BIG;
    return( sizeof( *ret ) + sizeof( *data ) );
}

unsigned ReqChecksum_mem( void )
{
    ULONG         offset;
    USHORT        length;
    ULONG         sum;
    checksum_mem_req    *acc;
    checksum_mem_ret    *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    length = acc->len;
    sum = 0;
    if( Pid != 0 ) {
        offset = acc->in_addr.offset;
        while( length != 0 ) {
            Buff.Cmd  = DBG_C_ReadMem_D;
            Buff.Addr = MakeItFlatNumberOne( acc->in_addr.segment, offset );
            CallDosDebug( &Buff );
            if( Buff.Cmd != DBG_N_Success ) {
                break;
            }
            sum += Buff.Value & 0xff;
            offset++;
            length--;
            if( length != 0 ) {
                sum += Buff.Value >> 8;
                offset++;
                length--;
            }
        }
    }
    ret->result = sum;
    return( sizeof( *ret ) );
}


unsigned ReqRead_mem( void )
{
    read_mem_req        *acc;
    void                *ret;
    unsigned            len;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    len = ReadBuffer( ret, acc->mem_addr.segment, acc->mem_addr.offset, acc->len );
    return( len );
}


unsigned ReqWrite_mem( void )
{
    write_mem_req       *acc;
    write_mem_ret       *ret;
    unsigned            len;

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

    len = GetTotalSize() - sizeof( *acc );

    ret->len = WriteBuffer( GetInPtr( sizeof( *acc ) ),
                           acc->mem_addr.segment, acc->mem_addr.offset, len );
    return( sizeof( *ret ) );
}

static void ReadCPU( struct x86_cpu *r )
{
    r->eax = Buff.EAX;
    r->ebx = Buff.EBX;
    r->ecx = Buff.ECX;
    r->edx = Buff.EDX;
    r->esi = Buff.ESI;
    r->edi = Buff.EDI;
    r->esp = Buff.ESP;
    r->ebp = Buff.EBP;
    r->ds  = Buff.DS;
    r->cs  = Buff.CS;
    r->es  = Buff.ES;
    r->ss  = Buff.SS;
    r->fs  = Buff.FS;
    r->gs  = Buff.GS;
    r->eip = Buff.EIP;
    r->efl = Buff.EFlags;
    if( !Is32BitSeg( Buff.CS ) ) {
        r->eip &= 0xffff;
    }
    if( !Is32BitSeg( Buff.SS ) ) {
        r->esp &= 0xffff;
        r->ebp &= 0xffff;
    }
}

static void WriteCPU( struct x86_cpu *r )
{
    Buff.EAX = r->eax ;
    Buff.EBX = r->ebx ;
    Buff.ECX = r->ecx ;
    Buff.EDX = r->edx ;
    Buff.ESI = r->esi ;
    Buff.EDI = r->edi ;
    Buff.ESP = r->esp ;
    Buff.EBP = r->ebp ;
    Buff.DS  = r->ds ;
    Buff.CS  = r->cs ;
    Buff.ES  = r->es ;
    Buff.SS  = r->ss ;
    Buff.FS  = r->fs ;
    Buff.GS  = r->gs ;
    Buff.EIP = r->eip ;
    Buff.EFlags = r->efl ;
    lastSS  = Buff.SS;
    lastESP = Buff.ESP;
    lastCS  = Buff.CS;
    lastEIP = Buff.EIP;
}

unsigned ReqRead_cpu( void )
{
    trap_cpu_regs *regs;

    regs = GetOutPtr( 0 );
    memset( regs, 0, sizeof( trap_cpu_regs ) );
    if( Pid != 0 ) {
        ReadRegs( &Buff );
        ReadCPU( (struct x86_cpu *)regs );
    }
    return( sizeof( *regs ) );
}

unsigned ReqRead_fpu( void )
{
    Buff.Cmd    = DBG_C_ReadCoRegs;
    Buff.Buffer = (ULONG)GetOutPtr(0);
    Buff.Value  = DBG_CO_387;       /* for 2.0: DBG_CO_387 */
    Buff.Len    = DBG_LEN_387;      /* for 2.0: size of register state */
    Buff.Index  = 0;                /* for 2.0: must be 0 */
    CallDosDebug( &Buff );
    if( Buff.Cmd == DBG_N_CoError ) {
        return( 0 );
    } else {
        return( DBG_LEN_387 );
    }
}

unsigned ReqWrite_cpu( void )
{
    trap_cpu_regs       *regs;

    regs = GetInPtr( sizeof( write_cpu_req ) );
    if( Pid != 0 ) {
        WriteCPU( (struct x86_cpu *)regs );
        WriteRegs( &Buff );
    }
    return( 0 );
}

unsigned ReqWrite_fpu( void )
{
    Buff.Cmd    = DBG_C_WriteCoRegs;
    Buff.Buffer = (ULONG)GetInPtr(sizeof(write_fpu_req));
    Buff.Value  = DBG_CO_387;       /* for 2.0: DBG_CO_387 */
    Buff.Len    = DBG_LEN_387;      /* for 2.0: buffer size */
    Buff.Index  = 0;                /* for 2.0: must be zero */
    CallDosDebug( &Buff );
    return( 0 );
}

unsigned ReqRead_regs( void )
{
    mad_registers       *mr;

    mr = GetOutPtr( 0 );
    memset( mr, 0, sizeof( mr->x86 ) );
    if( Pid != 0 ) {
        ReadRegs( &Buff );
        ReadCPU( &mr->x86.cpu );
        Buff.Cmd    = DBG_C_ReadCoRegs;
        Buff.Buffer = (ULONG)&mr->x86.fpu;
        Buff.Value  = DBG_CO_387;       /* for 2.0: DBG_CO_387 */
        Buff.Len    = DBG_LEN_387;      /* for 2.0: size of register state */
        Buff.Index  = 0;                /* for 2.0: must be 0 */
        CallDosDebug( &Buff );
        ReadXMMRegs( &mr->x86.xmm );
    }
    return( sizeof( mr->x86 ) );
}

unsigned ReqWrite_regs( void )