trap_retval ReqProg_load( void )
/***************************/
{
char *src;
char *dst;
char *name;
char ch;
prog_load_ret *ret;
unsigned len;
int rc;
char cmdl[128];
_DBG1( "AccLoadProg\r\n" );
ret = GetOutPtr( 0 );
src = name = GetInPtr( sizeof( prog_load_req ) );
while( *src++ != '\0' ) {}
len = GetTotalSize() - ( src - name ) - sizeof( prog_load_req );
if( len > 126 )
len = 126;
dst = cmdl + 1;
for( ; len > 0; --len ) {
ch = *src++;
if( ch == '\0' ) {
if( len == 1 )
break;
ch = ' ';
}
*dst++ = ch;
}
*dst = '\0';
*cmdl = dst - cmdl - 1;
rc = DebugLoad( name, cmdl );
_DBG1( "back from debugload - %d\r\n", rc );
ret->flags = LD_FLAG_IS_BIG | LD_FLAG_IS_PROT | LD_FLAG_DISPLAY_DAMAGED | LD_FLAG_HAVE_RUNTIME_DLLS;
ret->mod_handle = 0;
if( rc == 0 ) {
ret->err = 0;
ret->task_id = DebugPSP;
AddModsInfo( name, (epsp_t *)GetModuleHandle( DebugPSP ) );
} else {
ret->task_id = 0;
if( rc == 1 ) {
ret->err = ERR_ACCESS_DENIED;
} else if( rc == 2 ) {
ret->err = ERR_INVALID_FORMAT;
} else if( rc == 3 ) {
ret->err = ERR_INSUFFICIENT_MEMORY;
} else {
ret->err = rc;
}
}
_DBG1( "done AccLoadProg\r\n" );
return( sizeof( *ret ) );
}
unsigned ReqProg_load()
{
char *src;
char *dst;
char *name;
char ch;
prog_load_ret *ret;
unsigned len;
_DBG1(( "AccLoadProg\r\n" ));
AtEnd = FALSE;
dst = UtilBuff;
src = name = GetInPtr( sizeof( prog_load_req ) );
ret = GetOutPtr( 0 );
while( *src++ != '\0' ) {};
len = GetTotalSize() - (src - name) - sizeof( prog_load_req );
if( len > 126 )
len = 126;
for( ; len > 0; --len ) {
ch = *src++;
if( ch == '\0' ) {
if( len == 1 )
break;
ch = ' ';
}
*dst++ = ch;
}
*dst = '\0';
_DBG1(( "about to debugload\r\n" ));
_DBG1(( "Name :" ));
_DBG1(( name ));
_DBG1(( "\r\n" ));
_DBG1(( "UtilBuff :" ));
_DBG1(( UtilBuff ));
_DBG1(( "\r\n" ));
GetObjectInfo( name );
ret->err = D32DebugLoad( name, UtilBuff, &Proc );
_DBG1(( "back from debugload - %d\r\n", ret->err ));
ret->flags = LD_FLAG_IS_32 | LD_FLAG_IS_PROT | LD_FLAG_DISPLAY_DAMAGED;
if( ret->err == 0 ) {
ret->task_id = Proc.es;
} else {
ret->task_id = 0;
}
ret->mod_handle = 0;
Proc.int_id = -1;
_DBG1(( "done AccLoadProg\r\n" ));
return( sizeof( *ret ) );
}
trap_retval ReqChecksum_mem( void )
/******************************/
{
trap_elen len;
int i;
trap_elen read;
checksum_mem_req *acc;
checksum_mem_ret *ret;
char buffer[256];
_DBG1(( "AccChkSum\n" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
len = acc->len;
ret->result = 0;
while( len >= sizeof( buffer ) ) {
read = ReadMemory( &acc->in_addr, buffer, sizeof( buffer ) );
for( i = 0; i < read; ++i ) {
ret->result += buffer[ i ];
}
if( read != sizeof( buffer ) )
return( sizeof( *ret ) );
len -= sizeof( buffer );
acc->in_addr.offset += sizeof( buffer );
}
if( len != 0 ) {
read = ReadMemory( &acc->in_addr, buffer, len );
for( i = 0; i < read; ++i ) {
ret->result += buffer[ i ];
}
}
return( sizeof( ret ) );
}
static unsigned ProgRun( bool step )
/**********************************/
{
prog_go_ret *ret;
unsigned status;
epsp_t *epsp;
_DBG1( "AccRunProg %X:%X\n", DebugRegs.CS, DebugRegs.EIP );
ret = GetOutPtr( 0 );
status = Execute( step );
//handle module load/unload
if( status & ST_LOAD_MODULE ) {
epsp = (epsp_t *)DebugRegs.EDI;
if( epsp->EntryCS != 0 ) {
epsp->EntryCS = flatCode; // set debugee flat selector for init routine
}
AddModHandle( NULL, epsp );
} else if( status & ST_UNLOAD_MODULE ) {
RemoveModHandle( (epsp_t *)DebugRegs.EDI );
}
ret->conditions = MapStateToCond( status );
ret->conditions |= COND_CONFIG;
// Now setup return value to reflect why we stopped execution.
ret->program_counter.offset = DebugRegs.EIP;
ret->program_counter.segment = DebugRegs.CS;
ret->stack_pointer.offset = DebugRegs.ESP;
ret->stack_pointer.segment = DebugRegs.SS;
return( sizeof( *ret ) );
}
unsigned ReqClear_watch()
{
_DBG1(( "AccRestoreWatch\n" ));
/* assume all watches removed at same time */
WatchCount = 0;
return( 0 );
}
unsigned ReqSet_watch()
{
watch *curr;
set_watch_req *acc;
set_watch_ret *ret;
int i;
int needed;
_DBG1(( "AccSetWatch\n" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
ret->multiplier = 5000;
ret->err = 0;
curr = WatchPoints + WatchCount;
curr->addr.segment = acc->watch_addr.segment;
curr->addr.offset = acc->watch_addr.offset;
curr->linear = DPMIGetSegmentBaseAddress( curr->addr.segment ) + curr->addr.offset;
curr->len = acc->size;
curr->dregs = ( curr->linear & (curr->len-1) ) ? 2 : 1;
curr->handle = -1;
curr->handle2 = -1;
curr->value = 0;
ReadMemory( (addr48_ptr *)&acc->watch_addr, (byte far *)&curr->value, curr->len );
++WatchCount;
needed = 0;
for( i = 0; i < WatchCount; ++i ) {
needed += WatchPoints[ i ].dregs;
}
if( needed <= 4 ) ret->multiplier |= USING_DEBUG_REG;
return( sizeof( *ret ) );
}
unsigned ReqChecksum_mem()
{
unsigned short len;
int i;
unsigned short read;
checksum_mem_req *acc;
checksum_mem_ret *ret;
_DBG1(( "AccChkSum\n" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
len = acc->len;
ret->result = 0;
while( len >= BUFF_SIZE ) {
read = ReadMemory( (addr48_ptr *)&acc->in_addr, &UtilBuff, BUFF_SIZE );
for( i = 0; i < read; ++i ) {
ret->result += UtilBuff[ i ];
}
if( read != BUFF_SIZE ) return( sizeof( *ret ) );
len -= BUFF_SIZE;
}
if( len != 0 ) {
read = ReadMemory( (addr48_ptr *)&acc->in_addr, &UtilBuff, len );
if( read == len ) {
for( i = 0; i < len; ++i ) {
ret->result += UtilBuff[ i ];
}
}
}
return( sizeof( ret ) );
}
trap_retval ReqChecksum_mem( void )
{
unsigned len;
int i;
int read;
checksum_mem_req *acc;
checksum_mem_ret *ret;
_DBG1(( "AccChkSum" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
len = acc->len;
ret->result = 0;
while( len >= BUFF_SIZE ) {
read = ReadMemory( &acc->in_addr, (byte *)&UtilBuff, BUFF_SIZE );
acc->in_addr.offset += BUFF_SIZE;
for( i = 0; i < read; ++i ) {
ret->result += UtilBuff[ i ];
}
if( read != BUFF_SIZE ) return( sizeof( *ret ) );
len -= BUFF_SIZE;
}
if( len != 0 ) {
read = ReadMemory( &acc->in_addr, (byte *)&UtilBuff, len );
if( read == len ) {
for( i = 0; i < len; ++i ) {
ret->result += UtilBuff[ i ];
}
}
}
return( sizeof( *ret ) );
}
trap_version TRAPENTRY TrapInit( char *parm, char *err, bool remote )
{
trap_version ver;
int error_num;
extern int hotkey_int;
_DBG1(( "TrapInit\n" ));
remote = remote; parm = parm;
err[0] = '\0'; /* all ok */
ver.major = TRAP_MAJOR_VERSION;
ver.minor = TRAP_MINOR_VERSION;
ver.remote = FALSE;
RedirectInit();
RealNPXType = NPXType();
WatchCount = 0;
FakeBreak = FALSE;
hotkey_int = 5;
error_num = D32DebugInit( &Proc );
if( error_num ) {
_DBG(("D32DebugInit() failed:\n"));
exit(1);
}
Proc.int_id = -1;
D32DebugBreakOp(&Break); /* Get the 1 byte break op */
return( ver );
}
//OBSOLETE - use ReqMachine_data
trap_retval ReqAddr_info( void )
{
addr_info_ret *ret;
_DBG1(( "AccAddrInfo" ));
ret = GetOutPtr( 0 );
ret->is_big = 1;
return( sizeof( *ret ) );
}
unsigned ReqProg_kill()
{
prog_kill_ret *ret;
_DBG1(( "AccKillProg\n" ));
ret = GetOutPtr( 0 );
RedirectFini();
AtEnd = TRUE;
ret->err = 0;
return( sizeof( *ret ) );
}
trap_retval ReqClear_break( void )
{
clear_break_req *acc;
opcode_type brk_opcode;
acc = GetInPtr( 0 );
brk_opcode = acc->old;
WriteMemory( &acc->break_addr, &brk_opcode, sizeof( brk_opcode ) );
_DBG1(( "AccRestoreBreak" ));
return( 0 );
}
trap_retval ReqWrite_mem( void )
{
write_mem_req *acc;
write_mem_ret *ret;
_DBG1(( "WriteMem" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
ret->len = WriteMemory( &acc->mem_addr, GetInPtr( sizeof(*acc) ),
GetTotalSize() - sizeof(*acc) );
return( sizeof( *ret ) );
}
trap_retval ReqRead_mem( void )
{
read_mem_req *acc;
void *ret;
unsigned len;
_DBG1(( "ReadMem" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
len = ReadMemory( &acc->mem_addr, ret, acc->len );
return( len );
}
unsigned ReqRead_mem()
{
read_mem_req *acc;
void far *buff;
unsigned short len;
_DBG1(( "ReadMem\n" ));
acc = GetInPtr( 0 );
buff = GetOutPtr( 0 );
len = ReadMemory( (addr48_ptr *)&acc->mem_addr, buff, acc->len );
return( len );
}
unsigned ReqClear_break()
{
clear_break_req *acc;
char dummy;
acc = GetInPtr( 0 );
_DBG1(( "AccRestoreBreak\n" ));
/* assume all breaks removed at same time */
D32DebugSetBreak( acc->break_addr.offset, acc->break_addr.segment,
FALSE, (byte *)&acc->old, &dummy );
return( 0 );
}
unsigned ReqWrite_mem()
{
write_mem_req *acc;
write_mem_ret *ret;
_DBG1(( "WriteMem\n" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
ret->len = WriteMemory( (addr48_ptr *)&acc->mem_addr,
GetInPtr( sizeof(*acc) ),
GetTotalSize() - sizeof(*acc) );
return( sizeof( *ret ) );
}
unsigned ReqSet_break()
{
set_break_req *acc;
set_break_ret *ret;
_DBG1(( "AccSetBreak\n" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
D32DebugSetBreak( acc->break_addr.offset, acc->break_addr.segment,
FALSE, &Break, (byte *)&ret->old );
return( sizeof( *ret ) );
}
trap_retval ReqMap_addr( void )
/**************************/
{
map_addr_req *acc;
map_addr_ret *ret;
unsigned_16 seg;
seg_t *seginfo;
addr_off off;
mod_t *mod;
int i;
_DBG1( "AccMapAddr\r\n" );
acc = GetInPtr(0);
ret = GetOutPtr(0);
ret->out_addr.offset = 0;
ret->out_addr.segment = 0;
ret->lo_bound = 0;
ret->hi_bound = 0;
if( acc->handle < NumModHandles && ModHandles[acc->handle].loaded ) {
mod = &ModHandles[acc->handle];
seg = acc->in_addr.segment;
off = acc->in_addr.offset;
ret->hi_bound = ~0;
if( seg == MAP_FLAT_CODE_SELECTOR || seg == MAP_FLAT_DATA_SELECTOR ) {
seg = 1;
off += mod->ObjInfo[0].base;
for( i = 0; i < mod->SegCount; ++i ) {
seginfo = &mod->ObjInfo[i];
if( seginfo->base <= off && ( seginfo->base + seginfo->size ) > off ) {
seg = i + 1;
off -= seginfo->base;
ret->lo_bound = seginfo->new_base + mod->epsp->MemBase;
ret->hi_bound = ret->lo_bound + seginfo->size - 1;
break;
}
}
}
--seg;
// convert segment index to selector
if( mod->ObjInfo[seg].flags & OBJ_BIG ) {
ret->out_addr.segment = ( mod->ObjInfo[seg].flags & OBJ_EXECUTABLE ) ? flatCode : flatData ;
} else {
ret->out_addr.segment = ( mod->epsp->SegBase + seg * 8 ) | 3;
}
// convert offset
ret->out_addr.offset = off + mod->ObjInfo[seg].new_base + mod->epsp->MemBase;
_DBG( "Map_addr: module=%d %X:%X -> %X:%X\n", acc->handle, acc->in_addr.segment, acc->in_addr.offset, ret->out_addr.segment, ret->out_addr.offset );
}
return( sizeof( *ret ) );
}
trap_retval ReqGet_sys_config( void )
{
get_sys_config_ret *ret;
_DBG1(( "AccGetConfig" ));
ret = GetOutPtr(0);
ret->sys.os = MAD_OS_AUTOCAD;
ret->sys.osmajor = _osmajor;
ret->sys.osminor = _osminor;
ret->sys.cpu = X86CPUType();
ret->sys.huge_shift = 12;
ret->sys.fpu = RealNPXType;
ret->sys.mad = MAD_X86;
return( sizeof( *ret ) );
}
trap_retval ReqProg_kill( void )
{
prog_kill_ret *ret;
_DBG1(( "AccKillProg" ));
ret = GetOutPtr( 0 );
RedirectFini();
AtEnd = TRUE;
if( !DoneAutoCAD ) {
AtEnd = TRUE;
cputs( "*** Please quit AUTOCAD in order to restart debugger ***\r\n" );
MyRunProg();
}
ret->err = 0;
return( sizeof( *ret ) );
}
//OBSOLETE - use ReqMachine_data
unsigned ReqAddr_info()
{
addr_info_req *acc;
addr_info_ret *ret;
_DBG1(( "AccAddrInfo\n" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
ret->is_32 = 0;
if( D32AddressCheck( acc->in_addr.segment, 0, 1, NULL ) ) {
if( GetLAR( acc->in_addr.segment ) & 0x400000 ) {
ret->is_32 = 1;
}
}
return( sizeof( *ret ) );
}
trap_retval ReqSet_break( void )
{
set_break_req *acc;
set_break_ret *ret;
opcode_type brk_opcode; /* cause maybe SS != DS */
_DBG1(( "AccSetBreak" ));
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
if( ReadMemory( &acc->break_addr, &brk_opcode, sizeof( brk_opcode ) ) == 0 ) {
ret->old = 0;
} else {
ret->old = brk_opcode;
brk_opcode = BRKPOINT;
WriteMemory( &acc->break_addr, &brk_opcode, sizeof( brk_opcode ) );
}
return( sizeof( *ret ) );
}
unsigned ReqGet_sys_config()
{
get_sys_config_ret *ret;
_DBG1(( "AccGetConfig\n" ));
ret = GetOutPtr(0);
ret->sys.os = OS_RATIONAL;
ret->sys.osmajor = _osmajor;
ret->sys.osminor = _osminor;
ret->sys.cpu = X86CPUType();
ret->sys.huge_shift = 12;
if( !AtEnd && HAVE_EMU ) {
ret->sys.fpu = X86_EMU;
} else {
ret->sys.fpu = RealNPXType;
}
ret->sys.mad = MAD_X86;
return( sizeof( *ret ) );
}
trap_retval ReqGet_err_text( void )
{
static char *DosErrMsgs[] = {
#define pick(a,b) b,
#include "dosmsgs.h"
#undef pick
};
get_err_text_req *acc;
char *err_txt;
_DBG1(( "AccErrText" ));
acc = GetInPtr( 0 );
err_txt = GetOutPtr( 0 );
if( acc->err < ERR_LAST ) {
strcpy( err_txt, DosErrMsgs[ acc->err ] );
} else {
strcpy( err_txt, TRP_ERR_unknown_system_error );
ultoa( acc->err, err_txt + strlen( err_txt ), 16 );
}
return( strlen( err_txt ) + 1 );
}
unsigned ReqMap_addr()
{
Fptr32 fp;
map_addr_req *acc;
map_addr_ret *ret;
unsigned i;
_DBG1(( "AccMapAddr\n" ));
acc = GetInPtr(0);
ret = GetOutPtr(0);
ret->lo_bound = 0;
ret->hi_bound = ~(addr48_off)0;
fp.off = acc->in_addr.offset;
fp.sel = acc->in_addr.segment;
switch( fp.sel ) {
case MAP_FLAT_CODE_SELECTOR:
case MAP_FLAT_DATA_SELECTOR:
fp.sel = 1;
fp.off += ObjInfo[0].start;
for( i = 0; i < NumObjects; ++i ) {
if( ObjInfo[i].start <= fp.off
&& (ObjInfo[i].start + ObjInfo[i].size) > fp.off ) {
fp.sel = i + 1;
fp.off -= ObjInfo[i].start;
ret->lo_bound = ObjInfo[i].start - ObjInfo[0].start;
ret->hi_bound = ret->lo_bound + ObjInfo[i].size - 1;
break;
}
}
break;
}
D32Relocate(&fp);
ret->out_addr.segment = fp.sel;
ret->out_addr.offset = fp.off;
return( sizeof( *ret ) );
}
void TRAPENTRY TrapFini( void )
{
_DBG1(( "TrapFini\n" ));
D32DebugTerm();
}
static unsigned ProgRun( bool step )
{
watch *wp;
long trace;
int i;
dword value;
prog_go_ret *ret;
_DBG1(( "ProgRun" ));
ret = GetOutPtr( 0 );
ret->conditions = COND_CONFIG;
trace = step ? TRACE_BIT : 0;
Regs.EFL |= trace;
if( AtEnd ) {
_DBG2(("No RunProg"));
;
} else if( !trace && WatchCount != 0 ) {
_DBG2(("All that trace goop"));
if( SetDebugRegs() ) {
MyRunProg();
SysRegs.dr6 = 0;
SysRegs.dr7 = 0;
} else {
for( ;; ) {
Regs.EFL |= TRACE_BIT;
MyRunProg();
if( DoneAutoCAD ) break;
if( IntNum != 1 ) break;
if( !( SysRegs.dr6 & DR6_BS ) ) break;
for( wp = WatchPoints, i = WatchCount; i > 0; ++wp, --i ) {
ReadMemory( &wp->addr, (void *)&value, 4 );
if( value != wp->value ) {
ret->conditions |= COND_WATCH;
goto leave;
}
}
}
}
} else {
MyRunProg();
}
if( AtEnd ) {
ret->conditions |= COND_TERMINATE;
} else if( DoneAutoCAD ) {
ret->conditions = COND_TERMINATE;
AtEnd = TRUE;
} else if( IntNum == 1 ) {
if( trace ) {
ret->conditions |= COND_TRACE;
} else {
ret->conditions |= COND_WATCH;
}
} else if( IntNum == 3 ) {
ret->conditions |= COND_BREAK;
Regs.EIP--;
} else {
ret->conditions |= COND_EXCEPTION;
}
leave:
Regs.EFL &= ~trace;
ret->program_counter.offset = Regs.EIP;
ret->program_counter.segment = Regs.CS;
ret->stack_pointer.offset = Regs.ESP;
ret->stack_pointer.segment = Regs.SS;
WatchCount = 0;
return( sizeof( *ret ) );
}
static unsigned ProgRun( bool step )
{
prog_go_ret *ret;
byte int_buff[3];
addr48_ptr addr;
_DBG1(( "AccRunProg\n" ));
ret = GetOutPtr( 0 );
if( step ) {
Proc.eflags |= 0x100;
ret->conditions = DoRun();
Proc.eflags &= ~0x100;
} else if( WatchCount != 0 ) {
if( SetDebugRegs() ) {
ret->conditions = DoRun();
ClearDebugRegs();
if( ret->conditions & COND_TRACE ) {
ret->conditions |= COND_WATCH;
ret->conditions &= ~COND_TRACE;
}
} else {
for( ;; ) {
addr.segment = Proc.cs;
addr.offset = Proc.eip;
if( ReadMemory( &addr, int_buff, 3 ) == 3
&& int_buff[0] == 0xcd ) {
/* have to breakpoint across software interrupts because Intel
doesn't know how to design chips */
addr.offset = Proc.eip + 2;
int_buff[0] = 0xcc;
WriteMemory( &addr, int_buff, 1 );
} else {
Proc.eflags |= 0x100;
int_buff[0] = 0;
}
ret->conditions = DoRun();
if( int_buff[0] != 0 ) {
addr.offset = Proc.eip;
WriteMemory( &addr, &int_buff[2], 1 );
} else {
Proc.eflags &= ~0x100;
}
if( !(ret->conditions & (COND_TRACE|COND_BREAK)) ) break;
if( CheckWatchPoints() ) {
ret->conditions |= COND_WATCH;
ret->conditions &= ~(COND_TRACE|COND_BREAK);
break;
}
}
}
} else {
ret->conditions = DoRun();
}
ret->conditions |= COND_CONFIG;
ret->program_counter.offset = Proc.eip;
ret->program_counter.segment = Proc.cs;
ret->stack_pointer.offset = Proc.esp;
ret->stack_pointer.segment = Proc.ss;
return( sizeof( *ret ) );
}
