static char * formCodePtr( _trmem_hdl hdl, char *ptr, _trmem_who who )
{
#ifdef __WINDOWS__
#pragma warning 579 9; // shut up pointer truncated warning for FP_OFF
GLOBALENTRY entry;
if( hdl->use_code_seg_num ) {
MEMSET( &entry, 0, sizeof( GLOBALENTRY ) );
entry.dwSize = sizeof( GLOBALENTRY );
if( GlobalEntryHandle( &entry, (HGLOBAL) GlobalHandle( FP_SEG( who ) ) ) ) {
if( entry.wType == GT_CODE ) {
who = (_trmem_who) MK_FP( entry.wData, FP_OFF( who ) );
}
}
}
#pragma warning 579 4; // reenable pointer truncated warning
#else
hdl = hdl;
#endif
#if defined( _M_I86LM ) || defined( _M_I86HM ) || defined( _M_I86MM )
return formFarPtr( ptr, who );
#else
return formHex( ptr, (memsize)who, sizeof( who ) );
#endif
}
BOOL MyGlobalEntryHandle( GLOBALENTRY *ge, HMODULE hmem )
{
ge->dwSize = sizeof( GLOBALENTRY );
return( GlobalEntryHandle( ge, hmem ) );
} /* MyGlobalEntryHandle */
void
IT_GLOBALENTRYHANDLE (ENV *envp,LONGPROC f)
{
DWORD retcode,dwSize;
UINT uSel,uIndex;
LPBYTE lpData;
GLOBALENTRY ge;
LPMODULEINFO lpModInfo;
extern MODULEINFO *lpModuleTable[];
lpData = (LPBYTE)GetAddress(GETWORD(SP+8), GETWORD(SP+6));
dwSize = GETDWORD(lpData);
if (dwSize != (3*DWORD_86 + HANDLE_86 + 3*WORD_86 + INT_86 +
HANDLE_86 + 2*WORD_86 + 2*DWORD_86))
retcode = 0;
else {
ge.dwSize = sizeof(GLOBALENTRY);
uSel = (UINT)GETWORD(SP+4);
if ((retcode = (DWORD)GlobalEntryHandle(&ge,GetSelectorHandle(uSel)))) {
PUTDWORD(lpData+4,ge.dwAddress);
PUTDWORD(lpData+8,ge.dwBlockSize);
PUTWORD(lpData+12,ge.hBlock);
PUTWORD(lpData+14,ge.wcLock);
PUTWORD(lpData+16,ge.wcPageLock);
PUTWORD(lpData+18,ge.wFlags);
PUTWORD(lpData+20,ge.wHeapPresent);
#ifdef LATER
PUTWORD(lpData+22,ge.hOwner);
#else
/* this is a kludge to run DELPHI */
if (!(uIndex = (UINT)GetModuleIndex(uSel)))
/* this is an index for KERNEL (maybe!) */
uIndex = 1;
lpModInfo = lpModuleTable[uIndex];
PUTWORD(lpData+22,lpModInfo->ObjHead.hObj);
#endif
PUTWORD(lpData+24,ge.wType);
PUTWORD(lpData+26,ge.wData);
PUTDWORD(lpData+28,ge.dwNext);
PUTDWORD(lpData+32,ge.dwNextAlt);
}
}
envp->reg.sp += LP_86 + HANDLE_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
/*
* GetRealCSIP - get the CS:IP of a stopped task, cuz microsoft only tells
* you that the task is stopped in the kernel (gee, that's
* useful!!)
*/
DWORD GetRealCSIP( HTASK htask, HMODULE *mod )
{
DWORD csip;
STACKTRACEENTRY se;
GLOBALENTRY ge;
TASKENTRY te;
te.dwSize = sizeof( te );
if( TaskFindHandle( &te, htask ) == NULL ) {
return( 0L );
}
if( mod != NULL ) {
*mod = te.hModule;
}
csip = TaskGetCSIP( htask );
if( csip == 0L ) {
return( 0L );
}
se.dwSize = sizeof( se );
if( !StackTraceFirst( &se, htask ) ) {
return( csip );
}
csip = MAKECSIP( se.wCS, se.wIP );
while( 1 ) {
se.dwSize = sizeof( se );
if( !StackTraceNext( &se ) ) {
break;
}
csip = MAKECSIP( se.wCS, se.wIP );
ge.dwSize = sizeof( ge );
if( GlobalEntryHandle( &ge, (HGLOBAL)se.wCS ) ) {
if( ge.hOwner == te.hModule ) {
break;
}
}
}
return( csip );
} /* GetRealCSIP */
/*
* memDumpHeader - put summary information at the top of a memory dump
*/
static void memDumpHeader( int hdl, MemWndInfo *info )
{
time_t tm;
char buf[80];
unsigned len;
unsigned type_index;
char *rcstr;
#ifndef __NT__
GLOBALENTRY ge;
descriptor desc;
char access[20];
#endif
tm = time( NULL );
RCsprintf( buf, MWND_MEM_DMP_CREATED, asctime( localtime( &tm ) ), &len );
write( hdl, buf, len );
#ifndef __NT__
if( info->isdpmi ) {
rcstr = AllocRCString( MWND_DPMI_ITEM );
len = strlen( rcstr );
write( hdl, rcstr, len );
FreeRCString( rcstr );
GetADescriptor( info->sel, &desc );
RCsprintf( buf, MWND_SELECTOR, info->sel, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BASE, GET_DESC_BASE( desc ), &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_LIMIT, GET_DESC_LIMIT( desc), &len );
write( hdl, buf, len );
if( desc.type == 2 ) {
RCsprintf( buf, MWND_TYPE_DATA, &len );
} else {
RCsprintf( buf, MWND_TYPE_CODE, &len );
}
write( hdl, buf, len );
sprintf( buf, "DPL: \t%1d\n%n", desc.dpl, &len );
write( hdl, buf, len );
if( desc.granularity ) {
RCsprintf( buf, MWND_GRANULARITY_PAGE, &len );
} else {
RCsprintf( buf, MWND_GRANULARITY_BYTE, &len );
}
write( hdl, buf, len );
createAccessString( access, &desc );
RCsprintf( buf, MWND_ACCESS, access, &len );
write( hdl, buf, len );
} else {
ge.dwSize = sizeof( GLOBALENTRY );
GlobalEntryHandle( &ge, (HGLOBAL)info->sel );
RCsprintf( buf, MWND_BLOCK_ADDR, ge.dwAddress, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BLOCK_HDL, ge.hBlock, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BLOCK_SIZE, ge.dwBlockSize, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_LOCK_CNT, ge.wcLock, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_PAGE_LOCK_CNT, ge.wcPageLock, &len );
write( hdl, buf, len );
}
#endif
type_index = info->disp_type - MEMINFO_BYTE;
rcstr = AllocRCString( Disp_Types[type_index] );
sprintf( buf, "%s\n\n%n", rcstr, &len );
FreeRCString( rcstr );
write( hdl, buf, len );
} /* MemDumpHeader */
