Made the winedbg an external and WineLib program.

Centralized output handling (preparation for console usage).
Fixed a few debug information reading options (stabs and sym).
Started a framework to hold debugger's internal variables.
This commit is contained in:
Eric Pouech 2000-04-13 19:31:58 +00:00 committed by Alexandre Julliard
parent 5f6419fafa
commit e5efa0ceb6
24 changed files with 1053 additions and 1159 deletions

View File

@ -28,7 +28,6 @@ TOOLSUBDIRS = tools
LIBSUBDIRS = \
controls \
console \
debugger \
dlls/advapi32 \
dlls/crtdll \
dlls/display \
@ -60,17 +59,25 @@ EMUSUBDIRS = \
miscemu \
server
PROGSUBDIRS = libtest programs
PROGSUBDIRS = \
debugger \
libtest \
programs
DOCSUBDIRS = documentation
INCSUBDIRS = include
# Stand-alone programs
PROGRAMS = \
loader/dos/dosmod \
server/wineserver \
windows/x11drv/wineclipsrv
# Programs that link with libwine
LIBPROGRAMS = \
debugger/winedbg
# Sub-directories to run make into
SUBDIRS = \
$(TOOLSUBDIRS) \
@ -90,7 +97,6 @@ LINTSUBDIRS = $(LIBSUBDIRS) $(DLLDIR) $(EMUSUBDIRS) $(DOCSUBDIRS)
LIBOBJS = \
controls/controls.o \
console/console.o \
debugger/debugger.o \
dlls/advapi32/advapi32.o \
dlls/crtdll/crtdll.o \
dlls/display/display.o \
@ -126,7 +132,7 @@ EXTRA_OBJS = $(LIBOBJS)
EMU_TARGET = @EMU_TARGET@
all: Make.rules $(PROGRAMS) $(EMU_TARGET)
all: Make.rules $(PROGRAMS) $(LIBPROGRAMS) $(EMU_TARGET)
@echo "Wine build complete."
LIBLINTS = $(LIBOBJS:.o=.ln)
@ -167,15 +173,16 @@ install_wine: wine
[ -f wine.sym ] && $(INSTALL_DATA) wine.sym $(libdir)/wine.sym
$(INSTALL_PROGRAM) wine $(bindir)/wine
install:: $(PROGRAMS) $(EMU_TARGET:%=install_%) $(LIBEXT:%=install_%)
install:: $(PROGRAMS) $(LIBPROGRAMS) $(EMU_TARGET:%=install_%) $(LIBEXT:%=install_%)
[ -d $(bindir) ] || $(MKDIR) $(bindir)
$(INSTALL_PROGRAM) server/wineserver $(bindir)/wineserver
$(INSTALL_PROGRAM) windows/x11drv/wineclipsrv $(bindir)/wineclipsrv
$(INSTALL_PROGRAM) loader/dos/dosmod $(bindir)/dosmod
$(INSTALL_PROGRAM) debugger/winedbg $(bindir)/winedbg
uninstall::
cd $(libdir) && $(RM) libwine.a libwine.so libwine.so.$(SOVERSION) wine.sym
cd $(bindir) && $(RM) wine wineserver wineclipsrv dosmod
cd $(bindir) && $(RM) wine wineserver wineclipsrv dosmod winedbg
lib$(MODULE).so.$(SOVERSION): $(OBJS) Makefile.in Make.rules.in
$(LDSHARED) $(OBJS) -o $@
@ -191,9 +198,11 @@ lib$(MODULE).a: $(OBJS) Makefile.in Make.rules.in
checklink::
$(CC) -o checklink $(TOPSRCDIR)/library/checklink.c -L. -lwine $(LDOPTIONS) $(X_LIBS) $(XLIB) $(LIBS) && $(RM) checklink
$(EMUOBJS) $(LIBOBJS) $(DLLOBJS) $(PROGRAMS): $(TOOLSUBDIRS) dummy
$(EMUOBJS) $(LIBOBJS) $(DLLOBJS) $(PROGRAMS) $(LIBPROGRAMS): $(TOOLSUBDIRS) dummy
@cd `dirname $@` && $(MAKE) `basename $@`
$(LIBPROGRAMS): lib$(MODULE).$(LIBEXT) $(DLLOBJS)
$(LIBLINTS) $(EMULINTS): dummy
@cd `dirname $@` && $(MAKE) lint

View File

@ -1,4 +1,6 @@
Makefile
lex.yy.c
winedbg
winedbg.spec.c
y.tab.c
y.tab.h

View File

@ -1,9 +1,12 @@
DEFS = -D__WINE__ -DLIBDIR="\"$(libdir)\""
DEFS = -DWINELIB
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = debugger
MODULE = none
PROGRAMS = winedbg
ALL_LIBS = $(WINELIB) $(X_LIBS) $(XLIB) $(LIBS)
WRCEXTRA = -A -p $*
C_SRCS = \
break.c \
@ -24,19 +27,15 @@ C_SRCS = \
types.c \
winedbg.c
SPEC_SRCS = winedbg.spec
EXTRA_SRCS = dbg.y debug.l
EXTRA_OBJS = y.tab.o lex.yy.o
all: $(MODULE).o
all: $(PROGRAMS)
depend: y.tab.h
#
# This is a special test program that helps debug the internal debugger.
#
debug: $(MODULE).o dbgmain.o ../misc/xmalloc.o
$(CC) -o debug $(MODULE).o dbgmain.o ../misc/xmalloc.o
@MAKE_RULES@
y.tab.c y.tab.h: dbg.y
@ -45,4 +44,7 @@ y.tab.c y.tab.h: dbg.y
lex.yy.c: debug.l
$(LEX) -8 -I $(SRCDIR)/debug.l
winedbg: $(OBJS)
$(CC) -o $@ $(OBJS) $(LDOPTIONS) $(ALL_LIBS)
### Dependencies:

View File

@ -185,7 +185,7 @@ void DEBUG_SetBreakpoints( BOOL set )
if (!DEBUG_WRITE_MEM( (void*)DEBUG_ToLinear(&breakpoints[i].addr),
&ch, sizeof(ch) ))
{
fprintf(stderr, "Invalid address for breakpoint %d, disabling it\n", i);
DEBUG_Printf(DBG_CHN_MESG, "Invalid address for breakpoint %d, disabling it\n", i);
breakpoints[i].enabled = FALSE;
}
}
@ -291,7 +291,7 @@ static int DEBUG_InitXPoint(int type, DBG_ADDR* addr)
}
}
fprintf( stderr, "Too many breakpoints. Please delete some.\n" );
DEBUG_Printf( DBG_CHN_MESG, "Too many breakpoints. Please delete some.\n" );
return -1;
}
@ -361,10 +361,10 @@ void DEBUG_AddBreakpoint( const DBG_VALUE *_value )
breakpoints[num].u.opcode = ch;
fprintf( stderr, "Breakpoint %d at ", num );
DEBUG_Printf( DBG_CHN_MESG, "Breakpoint %d at ", num );
DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].is32 ? 32 : 16,
TRUE );
fprintf( stderr, "\n" );
DEBUG_Printf( DBG_CHN_MESG, "\n" );
}
@ -382,7 +382,9 @@ void DEBUG_AddWatchpoint( const DBG_VALUE *_value, BOOL is_write )
assert(_value->cookie == DV_TARGET || _value->cookie == DV_HOST);
DEBUG_FixAddress( &value.addr, CS_reg(&DEBUG_context) );
#ifdef __i386__
DEBUG_FixAddress( &value.addr, DEBUG_context.SegCs );
#endif
if ( value.type != NULL && value.type == DEBUG_TypeIntConst )
{
@ -408,7 +410,7 @@ void DEBUG_AddWatchpoint( const DBG_VALUE *_value, BOOL is_write )
for (reg = 0; reg < 4 && (mask & (1 << reg)); reg++);
if (reg == 4)
{
fprintf(stderr, "All i386 hardware watchpoints have been set. Delete some\n");
DEBUG_Printf(DBG_CHN_MESG, "All i386 hardware watchpoints have been set. Delete some\n");
return;
}
#endif
@ -422,16 +424,16 @@ void DEBUG_AddWatchpoint( const DBG_VALUE *_value, BOOL is_write )
if (!DEBUG_GetWatchedValue( num, &breakpoints[num].u.w.oldval))
{
fprintf(stderr, "Bad address. Watchpoint not set\n");
DEBUG_Printf(DBG_CHN_MESG, "Bad address. Watchpoint not set\n");
breakpoints[num].refcount = 0;
}
breakpoints[num].u.w.rw = (is_write) ? TRUE : FALSE;
breakpoints[reg].u.w.reg = reg;
fprintf( stderr, "Watchpoint %d at ", num );
DEBUG_Printf( DBG_CHN_MESG, "Watchpoint %d at ", num );
DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].is32 ? 32:16, TRUE );
fprintf( stderr, "\n" );
DEBUG_Printf( DBG_CHN_MESG, "\n" );
}
/***********************************************************************
@ -443,7 +445,7 @@ void DEBUG_DelBreakpoint( int num )
{
if ((num <= 0) || (num >= next_bp) || breakpoints[num].refcount == 0)
{
fprintf( stderr, "Invalid breakpoint number %d\n", num );
DEBUG_Printf( DBG_CHN_MESG, "Invalid breakpoint number %d\n", num );
return;
}
@ -470,7 +472,7 @@ void DEBUG_EnableBreakpoint( int num, BOOL enable )
{
if ((num <= 0) || (num >= next_bp) || breakpoints[num].refcount == 0)
{
fprintf( stderr, "Invalid breakpoint number %d\n", num );
DEBUG_Printf( DBG_CHN_MESG, "Invalid breakpoint number %d\n", num );
return;
}
breakpoints[num].enabled = (enable) ? TRUE : FALSE;
@ -557,40 +559,40 @@ void DEBUG_InfoBreakpoints(void)
{
int i;
fprintf( stderr, "Breakpoints:\n" );
DEBUG_Printf( DBG_CHN_MESG, "Breakpoints:\n" );
for (i = 1; i < next_bp; i++)
{
if (breakpoints[i].refcount && breakpoints[i].type == DBG_BREAK)
{
fprintf( stderr, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
DEBUG_Printf( DBG_CHN_MESG, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
DEBUG_PrintAddress( &breakpoints[i].addr,
breakpoints[i].is32 ? 32 : 16, TRUE);
fprintf( stderr, " (%u)\n", breakpoints[i].refcount );
DEBUG_Printf( DBG_CHN_MESG, " (%u)\n", breakpoints[i].refcount );
if( breakpoints[i].condition != NULL )
{
fprintf(stderr, "\t\tstop when ");
DEBUG_Printf(DBG_CHN_MESG, "\t\tstop when ");
DEBUG_DisplayExpr(breakpoints[i].condition);
fprintf(stderr, "\n");
DEBUG_Printf(DBG_CHN_MESG, "\n");
}
}
}
fprintf( stderr, "Watchpoints:\n" );
DEBUG_Printf( DBG_CHN_MESG, "Watchpoints:\n" );
for (i = 1; i < next_bp; i++)
{
if (breakpoints[i].refcount && breakpoints[i].type == DBG_WATCH)
{
fprintf( stderr, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
DEBUG_Printf( DBG_CHN_MESG, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
DEBUG_PrintAddress( &breakpoints[i].addr,
breakpoints[i].is32 ? 32 : 16, TRUE);
fprintf( stderr, " on %d byte%s (%c)\n",
DEBUG_Printf( DBG_CHN_MESG, " on %d byte%s (%c)\n",
breakpoints[i].u.w.len + 1,
breakpoints[i].u.w.len > 0 ? "s" : "",
breakpoints[i].u.w.rw ? 'W' : 'R');
if( breakpoints[i].condition != NULL )
{
fprintf(stderr, "\t\tstop when ");
DEBUG_Printf(DBG_CHN_MESG, "\t\tstop when ");
DEBUG_DisplayExpr(breakpoints[i].condition);
fprintf(stderr, "\n");
DEBUG_Printf(DBG_CHN_MESG, "\n");
}
}
}
@ -613,9 +615,9 @@ static BOOL DEBUG_ShallBreak( int bpnum )
/*
* Something wrong - unable to evaluate this expression.
*/
fprintf(stderr, "Unable to evaluate expression ");
DEBUG_Printf(DBG_CHN_MESG, "Unable to evaluate expression ");
DEBUG_DisplayExpr(breakpoints[bpnum].condition);
fprintf(stderr, "\nTurning off condition\n");
DEBUG_Printf(DBG_CHN_MESG, "\nTurning off condition\n");
DEBUG_AddBPCondition(bpnum, NULL);
}
else if( !DEBUG_GetExprValue( &value, NULL) )
@ -658,10 +660,10 @@ BOOL DEBUG_ShouldContinue( DWORD code, enum exec_mode mode, int * count )
{
if (!DEBUG_ShallBreak(bpnum)) return TRUE;
fprintf( stderr, "Stopped on breakpoint %d at ", bpnum );
DEBUG_Printf( DBG_CHN_MESG, "Stopped on breakpoint %d at ", bpnum );
syminfo = DEBUG_PrintAddress( &breakpoints[bpnum].addr,
breakpoints[bpnum].is32 ? 32 : 16, TRUE );
fprintf( stderr, "\n" );
DEBUG_Printf( DBG_CHN_MESG, "\n" );
if( syminfo.list.sourcefile != NULL )
DEBUG_List(&syminfo.list, NULL, 0);
@ -674,16 +676,18 @@ BOOL DEBUG_ShouldContinue( DWORD code, enum exec_mode mode, int * count )
/* If not single-stepping, do not back up over the int3 instruction */
if (code == EXCEPTION_BREAKPOINT)
{
EIP_reg(&DEBUG_context)++;
#ifdef __i386__
DEBUG_context.Eip++;
addr.off++;
#endif
}
if (!DEBUG_ShallBreak(wpnum)) return TRUE;
fprintf(stderr, "Stopped on watchpoint %d at ", wpnum);
DEBUG_Printf(DBG_CHN_MESG, "Stopped on watchpoint %d at ", wpnum);
syminfo = DEBUG_PrintAddress( &addr, !addr.seg ? 32 :
DEBUG_GetSelectorType( addr.seg ), TRUE );
fprintf(stderr, " values: old=%lu new=%lu\n",
DEBUG_Printf(DBG_CHN_MESG, " values: old=%lu new=%lu\n",
oldval, breakpoints[wpnum].u.w.oldval);
if (syminfo.list.sourcefile != NULL)
DEBUG_List(&syminfo.list, NULL, 0);
@ -740,7 +744,7 @@ BOOL DEBUG_ShouldContinue( DWORD code, enum exec_mode mode, int * count )
}
/***********************************************************************
* DEBUG_RestartExecution
* DEBUG_SuspendExecution
*
* Remove all breakpoints before entering the debug loop
*/
@ -791,7 +795,7 @@ enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count )
{
if( mode == EXEC_CONT && count > 1 )
{
fprintf(stderr, "Not stopped at any breakpoint; argument ignored.\n");
DEBUG_Printf(DBG_CHN_MESG, "Not stopped at any breakpoint; argument ignored.\n");
}
}
@ -823,7 +827,7 @@ enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count )
&& status == FUNC_IS_TRAMPOLINE )
{
#if 0
fprintf(stderr, "Not stepping into trampoline at %x (no lines)\n",
DEBUG_Printf(DBG_CHN_MESG, "Not stepping into trampoline at %x (no lines)\n",
addr2.off);
#endif
mode = EXEC_STEP_OVER_TRAMPOLINE;
@ -832,7 +836,7 @@ enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count )
if( mode == EXEC_STEP_INSTR && status == FUNC_HAS_NO_LINES )
{
#if 0
fprintf(stderr, "Not stepping into function at %x (no lines)\n",
DEBUG_Printf(DBG_CHN_MESG, "Not stepping into function at %x (no lines)\n",
addr2.off);
#endif
mode = EXEC_STEP_OVER;
@ -844,8 +848,8 @@ enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count )
{
if( DEBUG_CheckLinenoStatus(&addr) == FUNC_HAS_NO_LINES )
{
fprintf(stderr, "Single stepping until exit from function, \n");
fprintf(stderr, "which has no line number information.\n");
DEBUG_Printf(DBG_CHN_MESG, "Single stepping until exit from function, \n");
DEBUG_Printf(DBG_CHN_MESG, "which has no line number information.\n");
ret_mode = mode = EXEC_FINISH;
}
@ -909,6 +913,8 @@ enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count )
DEBUG_context.EFlags |= STEP_FLAG;
#endif
break;
case EXEC_KILL:
break;
default:
RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
}
@ -921,7 +927,7 @@ DEBUG_AddBPCondition(int num, struct expr * exp)
{
if ((num <= 0) || (num >= next_bp) || !breakpoints[num].refcount)
{
fprintf( stderr, "Invalid breakpoint number %d\n", num );
DEBUG_Printf( DBG_CHN_MESG, "Invalid breakpoint number %d\n", num );
return FALSE;
}

View File

@ -896,7 +896,7 @@ static unsigned int db_get_task_value( const DBG_ADDR *addr,
char buffer[4];
if (size != 1 && size != 2 && size != 4) {
fprintf(stderr, "Illegal size specified\n");
DEBUG_Printf(DBG_CHN_MESG, "Illegal size specified\n");
} else {
DEBUG_READ_MEM((void*)DEBUG_ToLinear( addr ), buffer, size);
@ -1020,22 +1020,21 @@ static void db_task_printsym(unsigned int addr, int size)
void db_print_address(char *seg, int size, struct i_addr *addrp, int byref)
{
if (addrp->is_reg) {
fprintf(stderr,"%s", db_reg[size][addrp->disp]);
DEBUG_Printf(DBG_CHN_MESG,"%s", db_reg[size][addrp->disp]);
return;
}
if (seg) {
fprintf(stderr,"%s:", seg);
DEBUG_Printf(DBG_CHN_MESG,"%s:", seg);
}
if (addrp->base != 0 || addrp->index != 0) {
fprintf(stderr,"0x%x", addrp->disp);
fprintf(stderr,"(");
DEBUG_Printf(DBG_CHN_MESG,"0x%x(", addrp->disp);
if (addrp->base)
fprintf(stderr,"%s", addrp->base);
DEBUG_Printf(DBG_CHN_MESG,"%s", addrp->base);
if (addrp->index)
fprintf(stderr,",%s,%d", addrp->index, 1<<addrp->ss);
fprintf(stderr,")");
DEBUG_Printf(DBG_CHN_MESG,",%s,%d", addrp->index, 1<<addrp->ss);
DEBUG_Printf(DBG_CHN_MESG,")");
}
else {
@ -1045,11 +1044,11 @@ void db_print_address(char *seg, int size, struct i_addr *addrp, int byref)
void* a1;
void* a2;
fprintf(stderr,"0x%x -> ", addrp->disp);
DEBUG_Printf(DBG_CHN_MESG,"0x%x -> ", addrp->disp);
if (!DEBUG_READ_MEM((void*)addrp->disp, &a1, sizeof(a1))) {
fprintf(stderr, "(invalid source)");
DEBUG_Printf(DBG_CHN_MESG, "(invalid source)");
} else if (!DEBUG_READ_MEM(a1, &a2, sizeof(a2))) {
fprintf(stderr, "(invalid destination)");
DEBUG_Printf(DBG_CHN_MESG, "(invalid destination)");
} else {
db_task_printsym((unsigned long)a1, 0);
}
@ -1085,30 +1084,30 @@ void db_disasm_esc( DBG_ADDR *addr, int inst, int short_addr,
* Normal address modes.
*/
db_read_address( addr, short_addr, regmodrm, &address);
fprintf(stderr,fp->f_name);
DEBUG_Printf(DBG_CHN_MESG,fp->f_name);
switch(fp->f_size) {
case SNGL:
fprintf(stderr,"s");
DEBUG_Printf(DBG_CHN_MESG,"s");
break;
case DBLR:
fprintf(stderr,"l");
DEBUG_Printf(DBG_CHN_MESG,"l");
break;
case EXTR:
fprintf(stderr,"t");
DEBUG_Printf(DBG_CHN_MESG,"t");
break;
case WORD:
fprintf(stderr,"s");
DEBUG_Printf(DBG_CHN_MESG,"s");
break;
case LONG:
fprintf(stderr,"l");
DEBUG_Printf(DBG_CHN_MESG,"l");
break;
case QUAD:
fprintf(stderr,"q");
DEBUG_Printf(DBG_CHN_MESG,"q");
break;
default:
break;
}
fprintf(stderr,"\t");
DEBUG_Printf(DBG_CHN_MESG,"\t");
db_print_address(seg, BYTE, &address, 0);
}
else {
@ -1118,25 +1117,25 @@ void db_disasm_esc( DBG_ADDR *addr, int inst, int short_addr,
switch (fp->f_rrmode) {
case op2(ST,STI):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
fprintf(stderr,"%s\t%%st,%%st(%d)",name,f_rm(regmodrm));
DEBUG_Printf(DBG_CHN_MESG,"%s\t%%st,%%st(%d)",name,f_rm(regmodrm));
break;
case op2(STI,ST):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
fprintf(stderr,"%s\t%%st(%d),%%st",name, f_rm(regmodrm));
DEBUG_Printf(DBG_CHN_MESG,"%s\t%%st(%d),%%st",name, f_rm(regmodrm));
break;
case op1(STI):
name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
fprintf(stderr,"%s\t%%st(%d)",name, f_rm(regmodrm));
DEBUG_Printf(DBG_CHN_MESG,"%s\t%%st(%d)",name, f_rm(regmodrm));
break;
case op1(X):
fprintf(stderr,"%s", ((char **)fp->f_rrname)[f_rm(regmodrm)]);
DEBUG_Printf(DBG_CHN_MESG,"%s", ((char **)fp->f_rrname)[f_rm(regmodrm)]);
break;
case op1(XA):
fprintf(stderr,"%s\t%%ax",
DEBUG_Printf(DBG_CHN_MESG,"%s\t%%ax",
((char **)fp->f_rrname)[f_rm(regmodrm)]);
break;
default:
fprintf(stderr,"<bad instruction>");
DEBUG_Printf(DBG_CHN_MESG,"<bad instruction>");
break;
}
}
@ -1174,7 +1173,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
switch (DEBUG_GetSelectorType(addr->seg)) {
case 16: db_disasm_16 = 1; break;
case 32: db_disasm_16 = 0; break;
default: fprintf(stderr, "Bad selector %ld\n", addr->seg); return;
default: DEBUG_Printf(DBG_CHN_MESG, "Bad selector %ld\n", addr->seg); return;
}
get_value_inc( inst, addr, 1, FALSE );
@ -1224,15 +1223,15 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
break;
case 0xf0:
if( db_display )
fprintf(stderr,"lock ");
DEBUG_Printf(DBG_CHN_MESG,"lock ");
break;
case 0xf2:
if( db_display )
fprintf(stderr,"repne ");
DEBUG_Printf(DBG_CHN_MESG,"repne ");
break;
case 0xf3:
if( db_display )
fprintf(stderr,"repe "); /* XXX repe VS rep */
DEBUG_Printf(DBG_CHN_MESG,"repe "); /* XXX repe VS rep */
break;
default:
prefix = FALSE;
@ -1297,28 +1296,28 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
if( db_display )
{
if (size == WORD)
fprintf(stderr,i_name);
DEBUG_Printf(DBG_CHN_MESG,i_name);
else
fprintf(stderr,ip->i_extra);
DEBUG_Printf(DBG_CHN_MESG,ip->i_extra);
}
}
else {
if( db_display )
{
fprintf(stderr,i_name);
DEBUG_Printf(DBG_CHN_MESG,i_name);
}
if (i_size != NONE) {
if (i_size == BYTE) {
if( db_display )
{
fprintf(stderr,"b");
DEBUG_Printf(DBG_CHN_MESG,"b");
}
size = BYTE;
}
else if (i_size == WORD) {
if( db_display )
{
fprintf(stderr,"w");
DEBUG_Printf(DBG_CHN_MESG,"w");
}
size = WORD;
}
@ -1326,28 +1325,28 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
{
if( db_display )
{
fprintf(stderr,"w");
DEBUG_Printf(DBG_CHN_MESG,"w");
}
}
else
{
if( db_display )
{
fprintf(stderr,"l");
DEBUG_Printf(DBG_CHN_MESG,"l");
}
}
}
}
if( db_display )
{
fprintf(stderr,"\t");
DEBUG_Printf(DBG_CHN_MESG,"\t");
}
for (first = TRUE;
i_mode != 0;
i_mode >>= 8, first = FALSE)
{
if (!first && db_display)
fprintf(stderr,",");
DEBUG_Printf(DBG_CHN_MESG,",");
switch (i_mode & 0xFF) {
@ -1361,7 +1360,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
case Eind:
if( db_display )
{
fprintf(stderr,"*");
DEBUG_Printf(DBG_CHN_MESG,"*");
db_print_address(seg, size, &address, 1);
}
break;
@ -1383,42 +1382,42 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
case R:
if( db_display )
{
fprintf(stderr,"%s", db_reg[size][f_reg(regmodrm)]);
DEBUG_Printf(DBG_CHN_MESG,"%s", db_reg[size][f_reg(regmodrm)]);
}
break;
case Rw:
if( db_display )
{
fprintf(stderr,"%s", db_reg[WORD][f_reg(regmodrm)]);
DEBUG_Printf(DBG_CHN_MESG,"%s", db_reg[WORD][f_reg(regmodrm)]);
}
break;
case Ri:
if( db_display )
{
fprintf(stderr,"%s", db_reg[size][f_rm(inst)]);
DEBUG_Printf(DBG_CHN_MESG,"%s", db_reg[size][f_rm(inst)]);
}
break;
case S:
if( db_display )
{
fprintf(stderr,"%s", db_seg_reg[f_reg(regmodrm)]);
DEBUG_Printf(DBG_CHN_MESG,"%s", db_seg_reg[f_reg(regmodrm)]);
}
break;
case Si:
if( db_display )
{
fprintf(stderr,"%s", db_seg_reg[f_reg(inst)]);
DEBUG_Printf(DBG_CHN_MESG,"%s", db_seg_reg[f_reg(inst)]);
}
break;
case A:
if( db_display )
{
fprintf(stderr,"%s", db_reg[size][0]); /* acc */
DEBUG_Printf(DBG_CHN_MESG,"%s", db_reg[size][0]); /* acc */
}
break;
@ -1426,22 +1425,22 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
if( db_display )
{
if (seg)
fprintf(stderr,"%s:", seg);
fprintf(stderr,"(%s)", short_addr ? "%bx" : "%ebx");
DEBUG_Printf(DBG_CHN_MESG,"%s:", seg);
DEBUG_Printf(DBG_CHN_MESG,"(%s)", short_addr ? "%bx" : "%ebx");
}
break;
case CL:
if( db_display )
{
fprintf(stderr,"%%cl");
DEBUG_Printf(DBG_CHN_MESG,"%%cl");
}
break;
case DX:
if( db_display )
{
fprintf(stderr,"%%dx");
DEBUG_Printf(DBG_CHN_MESG,"%%dx");
}
break;
@ -1449,36 +1448,36 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
if( db_display )
{
if (seg)
fprintf(stderr,"%s:", seg);
fprintf(stderr,"(%s)", short_addr ? "%si" : "%esi");
DEBUG_Printf(DBG_CHN_MESG,"%s:", seg);
DEBUG_Printf(DBG_CHN_MESG,"(%s)", short_addr ? "%si" : "%esi");
}
break;
case DI:
if( db_display )
{
fprintf(stderr,"%%es:(%s)", short_addr ? "%di" : "%edi");
DEBUG_Printf(DBG_CHN_MESG,"%%es:(%s)", short_addr ? "%di" : "%edi");
}
break;
case CR:
if( db_display )
{
fprintf(stderr,"%%cr%d", f_reg(regmodrm));
DEBUG_Printf(DBG_CHN_MESG,"%%cr%d", f_reg(regmodrm));
}
break;
case DR:
if( db_display )
{
fprintf(stderr,"%%dr%d", f_reg(regmodrm));
DEBUG_Printf(DBG_CHN_MESG,"%%dr%d", f_reg(regmodrm));
}
break;
case TR:
if( db_display )
{
fprintf(stderr,"%%tr%d", f_reg(regmodrm));
DEBUG_Printf(DBG_CHN_MESG,"%%tr%d", f_reg(regmodrm));
}
break;
@ -1487,7 +1486,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
get_value_inc(imm, addr, len, FALSE);/* unsigned */
if( db_display )
{
fprintf(stderr,"$0x%x", imm);
DEBUG_Printf(DBG_CHN_MESG,"$0x%x", imm);
}
break;
@ -1496,7 +1495,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
get_value_inc(imm, addr, len, TRUE); /* signed */
if( db_display )
{
fprintf(stderr,"$%d", imm);
DEBUG_Printf(DBG_CHN_MESG,"$%d", imm);
}
break;
@ -1504,7 +1503,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
get_value_inc(imm, addr, 1, FALSE); /* unsigned */
if( db_display )
{
fprintf(stderr,"$0x%x", imm);
DEBUG_Printf(DBG_CHN_MESG,"$0x%x", imm);
}
break;
@ -1512,7 +1511,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
get_value_inc(imm, addr, 1, TRUE); /* signed */
if( db_display )
{
fprintf(stderr,"$%d", imm);
DEBUG_Printf(DBG_CHN_MESG,"$%d", imm);
}
break;
@ -1520,7 +1519,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
get_value_inc(imm, addr, 2, FALSE); /* unsigned */
if( db_display )
{
fprintf(stderr,"$0x%x", imm);
DEBUG_Printf(DBG_CHN_MESG,"$0x%x", imm);
}
break;
@ -1528,7 +1527,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
get_value_inc(imm, addr, 4, FALSE);
if( db_display )
{
fprintf(stderr,"$0x%x", imm);
DEBUG_Printf(DBG_CHN_MESG,"$0x%x", imm);
}
break;
@ -1545,7 +1544,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
}
if (seg)
fprintf(stderr,"%s:0x%x",seg, displ);
DEBUG_Printf(DBG_CHN_MESG,"%s:0x%x",seg, displ);
else
db_task_printsym(displ, short_addr ? WORD : LONG);
break;
@ -1587,14 +1586,14 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display )
case o1:
if( db_display )
{
fprintf(stderr,"$1");
DEBUG_Printf(DBG_CHN_MESG,"$1");
}
break;
case o3:
if( db_display )
{
fprintf(stderr,"$3");
DEBUG_Printf(DBG_CHN_MESG,"$3");
}
break;

View File

@ -95,7 +95,8 @@ line: command
| error tEOL { yyerrok; }
command:
tQUIT tEOL { DEBUG_Exit(0); }
tQUIT tEOL { DEBUG_CurrThread->dbg_exec_count = 1;
DEBUG_CurrThread->dbg_exec_mode = EXEC_KILL; return 1; }
| tHELP tEOL { DEBUG_Help(); }
| tHELP tINFO tEOL { DEBUG_HelpInfo(); }
| tCONT tEOL { DEBUG_CurrThread->dbg_exec_count = 1;
@ -164,8 +165,8 @@ set_command:
DEBUG_FreeExprMem(); }
pathname:
tIDENTIFIER { $$ = $1; }
| tPATH { $$ = $1; }
tIDENTIFIER { $$ = $1; }
| tPATH { $$ = $1; }
disassemble_command:
tDISASSEMBLE tEOL { DEBUG_Disassemble( NULL, NULL, 10 ); }
@ -210,7 +211,7 @@ break_command:
}
else
{
fprintf(stderr,"Unable to add breakpoint\n");
DEBUG_Printf(DBG_CHN_MESG,"Unable to add breakpoint\n");
}
}
| tBREAK tIDENTIFIER ':' tNUM tEOL { DBG_VALUE value;
@ -220,9 +221,9 @@ break_command:
}
else
{
fprintf(stderr,"Unable to add breakpoint\n");
DEBUG_Printf(DBG_CHN_MESG,"Unable to add breakpoint\n");
}
}
}
| tBREAK tNUM tEOL { struct name_hash *nh;
DBG_VALUE value;
DEBUG_GetCurrentAddress( &value.addr );
@ -237,7 +238,7 @@ break_command:
}
else
{
fprintf(stderr,"Unable to add breakpoint\n");
DEBUG_Printf(DBG_CHN_MESG,"Unable to add breakpoint\n");
}
}
@ -255,7 +256,7 @@ watch_command:
if( DEBUG_GetSymbolValue($2, -1, &value, TRUE) )
DEBUG_AddWatchpoint( &value, 1 );
else
fprintf(stderr,"Unable to add breakpoint\n");
DEBUG_Printf(DBG_CHN_MESG,"Unable to add breakpoint\n");
}
info_command:
@ -388,49 +389,43 @@ lvalue:
static void issue_prompt(void)
{
#ifdef DONT_USE_READLINE
fprintf(stderr, "Wine-dbg>");
DEBUG_Printf(DBG_CHN_MESG, "Wine-dbg>");
#endif
}
static void mode_command(int newmode)
{
if ((newmode == 16) || (newmode == 32)) DEBUG_CurrThread->dbg_mode = newmode;
else fprintf(stderr,"Invalid mode (use 16 or 32)\n");
else DEBUG_Printf(DBG_CHN_MESG,"Invalid mode (use 16 or 32)\n");
}
void DEBUG_Exit(DWORD ec)
{
ExitProcess(ec);
}
static WINE_EXCEPTION_FILTER(wine_dbg_cmd)
{
fprintf(stderr, "\nwine_dbg_cmd: ");
DEBUG_Printf(DBG_CHN_MESG, "\nwine_dbg_cmd: ");
switch (GetExceptionCode()) {
case DEBUG_STATUS_INTERNAL_ERROR:
fprintf(stderr, "WineDbg internal error\n");
DEBUG_Printf(DBG_CHN_MESG, "WineDbg internal error\n");
break;
case DEBUG_STATUS_NO_SYMBOL:
fprintf(stderr, "Undefined symbol\n");
DEBUG_Printf(DBG_CHN_MESG, "Undefined symbol\n");
break;
case DEBUG_STATUS_DIV_BY_ZERO:
fprintf(stderr, "Division by zero\n");
DEBUG_Printf(DBG_CHN_MESG, "Division by zero\n");
break;
case DEBUG_STATUS_BAD_TYPE:
fprintf(stderr, "No type or type mismatch\n");
DEBUG_Printf(DBG_CHN_MESG, "No type or type mismatch\n");
break;
default:
fprintf(stderr, "Exception %lx\n", GetExceptionCode());
DEBUG_Printf(DBG_CHN_MESG, "Exception %lx\n", GetExceptionCode());
break;
}
return EXCEPTION_EXECUTE_HANDLER;
}
/***********************************************************************
* DEBUG_Exit
*
* Kill current process.
*
*/
void DEBUG_Exit( DWORD exit_code )
{
TASK_KillTask( 0 ); /* FIXME: should not be necessary */
TerminateProcess( DEBUG_CurrProcess->handle, exit_code );
return EXCEPTION_EXECUTE_HANDLER;
}
/***********************************************************************
@ -456,17 +451,16 @@ BOOL DEBUG_Main( BOOL is_debug, BOOL force, DWORD code )
{
#ifdef __i386__
if (DEBUG_IsSelectorSystem(DEBUG_context.SegCs))
fprintf( stderr, " in 32-bit code (0x%08lx).\n", DEBUG_context.Eip );
DEBUG_Printf( DBG_CHN_MESG, " in 32-bit code (0x%08lx).\n", DEBUG_context.Eip );
else
fprintf( stderr, " in 16-bit code (%04x:%04lx).\n",
(WORD)DEBUG_context.SegCs, DEBUG_context.Eip );
DEBUG_Printf( DBG_CHN_MESG, " in 16-bit code (%04x:%04lx).\n",
(WORD)DEBUG_context.SegCs, DEBUG_context.Eip );
#else
fprintf( stderr, " (%p).\n", GET_IP(&DEBUG_context) );
DEBUG_Printf( DBG_CHN_MESG, " (%p).\n", GET_IP(&DEBUG_context) );
#endif
}
if (DEBUG_LoadEntryPoints("Loading new modules symbols:\n"))
DEBUG_ProcessDeferredDebug();
DEBUG_LoadEntryPoints("Loading new modules symbols:\n");
if (force || !(is_debug && DEBUG_ShouldContinue( code,
DEBUG_CurrThread->dbg_exec_mode,
@ -478,13 +472,13 @@ BOOL DEBUG_Main( BOOL is_debug, BOOL force, DWORD code )
#ifdef __i386__
switch (newmode = DEBUG_GetSelectorType(addr.seg)) {
case 16: case 32: break;
default: fprintf(stderr, "Bad CS (%ld)\n", addr.seg); newmode = 32;
default: DEBUG_Printf(DBG_CHN_MESG, "Bad CS (%ld)\n", addr.seg); newmode = 32;
}
#else
newmode = 32;
#endif
if (newmode != DEBUG_CurrThread->dbg_mode)
fprintf(stderr,"In %d bit mode.\n", DEBUG_CurrThread->dbg_mode = newmode);
DEBUG_Printf(DBG_CHN_MESG,"In %d bit mode.\n", DEBUG_CurrThread->dbg_mode = newmode);
DEBUG_DoDisplay();
@ -520,9 +514,9 @@ BOOL DEBUG_Main( BOOL is_debug, BOOL force, DWORD code )
/* Show where we crashed */
curr_frame = 0;
DEBUG_PrintAddress( &addr, DEBUG_CurrThread->dbg_mode, TRUE );
fprintf(stderr,": ");
DEBUG_Printf(DBG_CHN_MESG,": ");
DEBUG_Disasm( &addr, TRUE );
fprintf( stderr, "\n" );
DEBUG_Printf( DBG_CHN_MESG, "\n" );
}
ret_ok = 0;
@ -531,16 +525,20 @@ BOOL DEBUG_Main( BOOL is_debug, BOOL force, DWORD code )
__TRY
{
issue_prompt();
yyparse();
flush_symbols();
if (yyparse()) {
DEBUG_CurrThread->dbg_exec_mode = EXEC_KILL;
ret_ok = TRUE;
} else {
flush_symbols();
DEBUG_GetCurrentAddress( &addr );
if ((ret_ok = DEBUG_ValidateRegisters()))
ret_ok = DEBUG_READ_MEM_VERBOSE((void*)DEBUG_ToLinear( &addr ), &ch, 1 );
DEBUG_GetCurrentAddress( &addr );
ret_ok = DEBUG_ValidateRegisters() &&
DEBUG_READ_MEM_VERBOSE((void*)DEBUG_ToLinear(&addr), &ch, 1);
}
}
__EXCEPT(wine_dbg_cmd)
{
ret_ok = 0;
ret_ok = FALSE;
}
__ENDTRY;
@ -553,14 +551,14 @@ BOOL DEBUG_Main( BOOL is_debug, BOOL force, DWORD code )
* if it was used. Otherwise it would have been ignored.
* In any case, we don't mess with it any more.
*/
if ((DEBUG_CurrThread->dbg_exec_mode == EXEC_CONT) || (DEBUG_CurrThread->dbg_exec_mode == EXEC_PASS))
if (DEBUG_CurrThread->dbg_exec_mode == EXEC_CONT || DEBUG_CurrThread->dbg_exec_mode == EXEC_PASS)
DEBUG_CurrThread->dbg_exec_count = 0;
return (DEBUG_CurrThread->dbg_exec_mode == EXEC_PASS) ? 0 : DBG_CONTINUE;
return (DEBUG_CurrThread->dbg_exec_mode == EXEC_PASS) ? DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE;
}
int yyerror(char* s)
{
fprintf(stderr,"%s\n", s);
DEBUG_Printf(DBG_CHN_MESG,"%s\n", s);
return 0;
}

View File

@ -190,7 +190,7 @@ enum { return tENUM; }
. { if (syntax_error == 0)
{
syntax_error ++; fprintf(stderr, "Syntax Error\n");
syntax_error ++; DEBUG_Printf(DBG_CHN_MESG, "Syntax Error\n");
}
}
@ -239,7 +239,7 @@ static int dbg_read(char * buf, int size)
line = readline ("Wine-dbg>");
if (!line)
{
fprintf( stderr, "\n" );
DEBUG_Printf( DBG_CHN_MESG, "\n" );
DEBUG_Exit(0);
}
@ -264,8 +264,8 @@ static int dbg_read(char * buf, int size)
{
if (size < len + 1)
{
fprintf(stderr,"Fatal readline goof.\n");
DEBUG_Exit(0);
DEBUG_Printf(DBG_CHN_MESG,"Fatal readline goof.\n");
DEBUG_Exit(0);
}
strcpy(buf, line);
buf[len] = '\n';

View File

@ -106,11 +106,12 @@ enum exec_mode
EXEC_STEPI_OVER, /* Stepping over a call */
EXEC_STEPI_INSTR, /* Single-stepping an instruction */
EXEC_FINISH, /* Step until we exit current frame */
EXEC_STEP_OVER_TRAMPOLINE /* Step over trampoline. Requires that
EXEC_STEP_OVER_TRAMPOLINE, /* Step over trampoline. Requires that
* we dig the real return value off the stack
* and set breakpoint there - not at the
* instr just after the call.
*/
EXEC_KILL /* terminate debugging session */
};
#define DBG_BREAK 0
@ -330,6 +331,7 @@ extern void DEBUG_WalkWindows(HWND hWnd, int indent);
extern int DEBUG_ReadMemory( const DBG_ADDR *address );
extern void DEBUG_WriteMemory( const DBG_ADDR *address, int value );
extern void DEBUG_ExamineMemory( const DBG_VALUE *addr, int count, char format);
extern void DEBUG_InvalAddr( const DBG_ADDR* addr );
extern void DEBUG_InvalLinAddr( void* addr );
#ifdef __i386__
extern void DEBUG_GetCurrentAddress( DBG_ADDR * );
@ -342,21 +344,19 @@ extern int DEBUG_IsSelectorSystem( WORD sel );
/* debugger/module.c */
extern int DEBUG_LoadEntryPoints( const char * prefix );
extern void DEBUG_LoadModule32( const char* name, DWORD base );
extern void DEBUG_LoadModule32( const char* name, HANDLE hFile, DWORD base );
extern DBG_MODULE* DEBUG_AddModule(const char* name, int type,
void* mod_addr, HMODULE hmod);
extern DBG_MODULE* DEBUG_FindModuleByName(const char* name, int type);
extern DBG_MODULE* DEBUG_FindModuleByHandle(HANDLE handle, int type);
extern DBG_MODULE* DEBUG_RegisterPEModule(HMODULE, u_long load_addr, const char* name);
extern DBG_MODULE* DEBUG_RegisterELFModule(u_long load_addr, const char* name);
extern int DEBUG_ProcessDeferredDebug(void);
extern void DEBUG_InfoShare(void);
/* debugger/msc.c */
extern int DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, void* nth, unsigned long nth_ofs);
extern int DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, void* nth, unsigned long nth_ofs);
extern int DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, HANDLE hFile, void* nth, unsigned long nth_ofs);
extern int DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, HANDLE hFile, void* nth, unsigned long nth_ofs);
extern void DEBUG_InitCVDataTypes(void);
extern int DEBUG_ProcessMSCDebugInfo(DBG_MODULE* module);
/* debugger/registers.c */
extern void DEBUG_SetRegister( enum debug_regs reg, int val );
@ -375,7 +375,8 @@ extern int DEBUG_GetCurrentFrame(struct name_hash ** name,
unsigned int * ebp);
/* debugger/stabs.c */
extern int DEBUG_ReadExecutableDbgInfo(void);
extern int DEBUG_ReadExecutableDbgInfo(const char* exe_name);
extern int DEBUG_ProcessElfObject(const char* filename, unsigned int load_offset);
extern int DEBUG_ParseStabs(char * addr, unsigned int load_offset, unsigned int staboff,
int stablen, unsigned int strtaboff, int strtablen);
@ -420,8 +421,16 @@ extern void DEBUG_Disassemble( const DBG_VALUE *, const DBG_VALUE*, int offset )
extern void DEBUG_ExternalDebugger(void);
/* debugger/dbg.y */
extern void DEBUG_Exit( DWORD exit_code );
extern BOOL DEBUG_Main( BOOL is_debug, BOOL force, DWORD code );
extern void DEBUG_Exit( DWORD );
/* debugger/winedbg.c */
#define DBG_CHN_MESG 1
#define DBG_CHN_ERR 2
#define DBG_CHN_WARN 4
#define DBG_CHN_FIXME 8
#define DBG_CHN_TRACE 16
extern int DEBUG_Printf(int chn, const char* format, ...);
/* Choose your allocator! */
#if 1
@ -455,4 +464,9 @@ extern HANDLE dbg_heap;
#define DEBUG_STATUS_DIV_BY_ZERO (DEBUG_STATUS_OFFSET+2)
#define DEBUG_STATUS_BAD_TYPE (DEBUG_STATUS_OFFSET+3)
#define DBG_IVAR(_var) DEBUG_IV_##_var
#define INTERNAL_VAR(_var,_val) extern int DBG_IVAR(_var);
#include "intvar.h"
#undef INTERNAL_VAR
#endif /* __WINE_DEBUGGER_H */

View File

@ -60,9 +60,9 @@ DEBUG_InfoDisplay(void)
{
if( displaypoints[i].exp != NULL )
{
fprintf(stderr, "%d : ", i+1);
DEBUG_Printf(DBG_CHN_MESG, "%d : ", i+1);
DEBUG_DisplayExpr(displaypoints[i].exp);
fprintf(stderr, "\n");
DEBUG_Printf(DBG_CHN_MESG, "\n");
}
}
@ -85,16 +85,16 @@ DEBUG_DoDisplay(void)
value = DEBUG_EvalExpr(displaypoints[i].exp);
if( value.type == NULL )
{
fprintf(stderr, "Unable to evaluate expression ");
DEBUG_Printf(DBG_CHN_MESG, "Unable to evaluate expression ");
DEBUG_DisplayExpr(displaypoints[i].exp);
fprintf(stderr, "\nDisabling...\n");
DEBUG_Printf(DBG_CHN_MESG, "\nDisabling...\n");
DEBUG_DelDisplay(i);
}
else
{
fprintf(stderr, "%d : ", i + 1);
DEBUG_Printf(DBG_CHN_MESG, "%d : ", i + 1);
DEBUG_DisplayExpr(displaypoints[i].exp);
fprintf(stderr, " = ");
DEBUG_Printf(DBG_CHN_MESG, " = ");
if( displaypoints[i].format == 'i' )
{
DEBUG_ExamineMemory( &value,
@ -121,7 +121,7 @@ DEBUG_DelDisplay(int displaynum)
if( displaynum >= MAX_DISPLAY || displaynum == 0 || displaynum < -1 )
{
fprintf(stderr, "Invalid display number\n");
DEBUG_Printf(DBG_CHN_MESG, "Invalid display number\n");
return TRUE;
}
if( displaynum == -1 )

View File

@ -418,7 +418,7 @@ DBG_VALUE DEBUG_EvalExpr(struct expr * exp)
break;
}
#else
fprintf(stderr, "Function call no longer implemented\n");
DEBUG_Printf(DBG_CHN_MESG, "Function call no longer implemented\n");
/* would need to set up a call to this function, and then restore the current
* context afterwards...
*/
@ -637,7 +637,7 @@ DBG_VALUE DEBUG_EvalExpr(struct expr * exp)
}
break;
default:
fprintf(stderr,"Unexpected expression (%d).\n", exp->type);
DEBUG_Printf(DBG_CHN_MESG,"Unexpected expression (%d).\n", exp->type);
RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
break;
}
@ -656,111 +656,111 @@ DEBUG_DisplayExpr(const struct expr * exp)
switch(exp->type)
{
case EXPR_TYPE_CAST:
fprintf(stderr, "((");
DEBUG_Printf(DBG_CHN_MESG, "((");
DEBUG_PrintTypeCast(exp->un.cast.cast);
fprintf(stderr, ")");
DEBUG_Printf(DBG_CHN_MESG, ")");
DEBUG_DisplayExpr(exp->un.cast.expr);
fprintf(stderr, ")");
DEBUG_Printf(DBG_CHN_MESG, ")");
break;
case EXPR_TYPE_REGISTER:
DEBUG_PrintRegister(exp->un.rgister.reg);
break;
case EXPR_TYPE_US_CONST:
fprintf(stderr, "%ud", exp->un.u_const.value);
DEBUG_Printf(DBG_CHN_MESG, "%ud", exp->un.u_const.value);
break;
case EXPR_TYPE_CONST:
fprintf(stderr, "%d", exp->un.u_const.value);
DEBUG_Printf(DBG_CHN_MESG, "%d", exp->un.u_const.value);
break;
case EXPR_TYPE_STRING:
fprintf(stderr, "\"%s\"", exp->un.string.str);
DEBUG_Printf(DBG_CHN_MESG, "\"%s\"", exp->un.string.str);
break;
case EXPR_TYPE_SYMBOL:
fprintf(stderr, "%s" , exp->un.symbol.name);
DEBUG_Printf(DBG_CHN_MESG, "%s" , exp->un.symbol.name);
break;
case EXPR_TYPE_PSTRUCT:
DEBUG_DisplayExpr(exp->un.structure.exp1);
fprintf(stderr, "->%s", exp->un.structure.element_name);
DEBUG_Printf(DBG_CHN_MESG, "->%s", exp->un.structure.element_name);
break;
case EXPR_TYPE_STRUCT:
DEBUG_DisplayExpr(exp->un.structure.exp1);
fprintf(stderr, ".%s", exp->un.structure.element_name);
DEBUG_Printf(DBG_CHN_MESG, ".%s", exp->un.structure.element_name);
break;
case EXPR_TYPE_CALL:
fprintf(stderr, "%s(",exp->un.call.funcname);
DEBUG_Printf(DBG_CHN_MESG, "%s(",exp->un.call.funcname);
for(i=0; i < exp->un.call.nargs; i++)
{
DEBUG_DisplayExpr(exp->un.call.arg[i]);
if( i != exp->un.call.nargs - 1 )
{
fprintf(stderr, ", ");
DEBUG_Printf(DBG_CHN_MESG, ", ");
}
}
fprintf(stderr, ")");
DEBUG_Printf(DBG_CHN_MESG, ")");
break;
case EXPR_TYPE_BINOP:
fprintf(stderr, "( ");
DEBUG_Printf(DBG_CHN_MESG, "( ");
DEBUG_DisplayExpr(exp->un.binop.exp1);
switch(exp->un.binop.binop_type)
{
case EXP_OP_ADD:
fprintf(stderr, " + ");
DEBUG_Printf(DBG_CHN_MESG, " + ");
break;
case EXP_OP_SUB:
fprintf(stderr, " - ");
DEBUG_Printf(DBG_CHN_MESG, " - ");
break;
case EXP_OP_SEG:
fprintf(stderr, ":");
DEBUG_Printf(DBG_CHN_MESG, ":");
break;
case EXP_OP_LOR:
fprintf(stderr, " || ");
DEBUG_Printf(DBG_CHN_MESG, " || ");
break;
case EXP_OP_LAND:
fprintf(stderr, " && ");
DEBUG_Printf(DBG_CHN_MESG, " && ");
break;
case EXP_OP_OR:
fprintf(stderr, " | ");
DEBUG_Printf(DBG_CHN_MESG, " | ");
break;
case EXP_OP_AND:
fprintf(stderr, " & ");
DEBUG_Printf(DBG_CHN_MESG, " & ");
break;
case EXP_OP_XOR:
fprintf(stderr, " ^ ");
DEBUG_Printf(DBG_CHN_MESG, " ^ ");
break;
case EXP_OP_EQ:
fprintf(stderr, " == ");
DEBUG_Printf(DBG_CHN_MESG, " == ");
break;
case EXP_OP_GT:
fprintf(stderr, " > ");
DEBUG_Printf(DBG_CHN_MESG, " > ");
break;
case EXP_OP_LT:
fprintf(stderr, " < ");
DEBUG_Printf(DBG_CHN_MESG, " < ");
break;
case EXP_OP_GE:
fprintf(stderr, " >= ");
DEBUG_Printf(DBG_CHN_MESG, " >= ");
break;
case EXP_OP_LE:
fprintf(stderr, " <= ");
DEBUG_Printf(DBG_CHN_MESG, " <= ");
break;
case EXP_OP_NE:
fprintf(stderr, " != ");
DEBUG_Printf(DBG_CHN_MESG, " != ");
break;
case EXP_OP_SHL:
fprintf(stderr, " << ");
DEBUG_Printf(DBG_CHN_MESG, " << ");
break;
case EXP_OP_SHR:
fprintf(stderr, " >> ");
DEBUG_Printf(DBG_CHN_MESG, " >> ");
break;
case EXP_OP_MUL:
fprintf(stderr, " * ");
DEBUG_Printf(DBG_CHN_MESG, " * ");
break;
case EXP_OP_DIV:
fprintf(stderr, " / ");
DEBUG_Printf(DBG_CHN_MESG, " / ");
break;
case EXP_OP_REM:
fprintf(stderr, " %% ");
DEBUG_Printf(DBG_CHN_MESG, " %% ");
break;
case EXP_OP_ARR:
fprintf(stderr, "[");
DEBUG_Printf(DBG_CHN_MESG, "[");
break;
default:
break;
@ -768,33 +768,33 @@ DEBUG_DisplayExpr(const struct expr * exp)
DEBUG_DisplayExpr(exp->un.binop.exp2);
if( exp->un.binop.binop_type == EXP_OP_ARR )
{
fprintf(stderr, "]");
DEBUG_Printf(DBG_CHN_MESG, "]");
}
fprintf(stderr, " )");
DEBUG_Printf(DBG_CHN_MESG, " )");
break;
case EXPR_TYPE_UNOP:
switch(exp->un.unop.unop_type)
{
case EXP_OP_NEG:
fprintf(stderr, "-");
DEBUG_Printf(DBG_CHN_MESG, "-");
break;
case EXP_OP_NOT:
fprintf(stderr, "!");
DEBUG_Printf(DBG_CHN_MESG, "!");
break;
case EXP_OP_LNOT:
fprintf(stderr, "~");
DEBUG_Printf(DBG_CHN_MESG, "~");
break;
case EXP_OP_DEREF:
fprintf(stderr, "*");
DEBUG_Printf(DBG_CHN_MESG, "*");
break;
case EXP_OP_ADDR:
fprintf(stderr, "&");
DEBUG_Printf(DBG_CHN_MESG, "&");
break;
}
DEBUG_DisplayExpr(exp->un.unop.exp1);
break;
default:
fprintf(stderr,"Unexpected expression.\n");
DEBUG_Printf(DBG_CHN_MESG,"Unexpected expression.\n");
RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
break;
}
@ -851,7 +851,7 @@ DEBUG_CloneExpr(const struct expr * exp)
rtn->un.unop.exp1 = DEBUG_CloneExpr(exp->un.unop.exp1);
break;
default:
fprintf(stderr,"Unexpected expression.\n");
DEBUG_Printf(DBG_CHN_MESG,"Unexpected expression.\n");
RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
break;
}
@ -904,7 +904,7 @@ DEBUG_FreeExpr(struct expr * exp)
DEBUG_FreeExpr(exp->un.unop.exp1);
break;
default:
fprintf(stderr,"Unexpected expression.\n");
DEBUG_Printf(DBG_CHN_MESG,"Unexpected expression.\n");
RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
break;
}

View File

@ -146,7 +146,7 @@ DEBUG_ResortSymbols(void)
if( (nh->flags & SYM_INVALID) == 0 )
nsym++;
else
fprintf( stderr, "Symbol %s is invalid\n", nh->name );
DEBUG_Printf( DBG_CHN_MESG, "Symbol %s is invalid\n", nh->name );
}
}
@ -198,6 +198,10 @@ DEBUG_AddSymbol( const char * name, const DBG_VALUE *value, const char * source,
{
if( ((nh->flags & SYM_INVALID) != 0) && strcmp(name, nh->name) == 0 )
{
#if 0
DEBUG_Printf(DBG_CHN_MESG, "Changing address for symbol %s (%08lx:%08lx => %08lx:%08lx)\n",
name, nh->value.addr.seg, nh->value.addr.off, value->addr.seg, value->addr.off);
#endif
nh->value.addr = value->addr;
if( nh->value.type == NULL && value->type != NULL )
@ -223,6 +227,11 @@ DEBUG_AddSymbol( const char * name, const DBG_VALUE *value, const char * source,
}
}
#if 0
DEBUG_Printf(DBG_CHN_TRACE, "adding symbol (%s) from file '%s' at 0x%04lx:%08lx\n",
name, source, value->addr.seg, value->addr.off);
#endif
/*
* First see if we already have an entry for this symbol. If so
* return it, so we don't end up with duplicates.
@ -564,12 +573,12 @@ const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
}
nearest = addr_sorttab[mid];
#if 0
fprintf(stderr, "Found %x:%x when looking for %x:%x %x %s\n",
addr_sorttab[mid ]->value.addr.seg,
addr_sorttab[mid ]->value.addr.off,
addr->seg, addr->off,
addr_sorttab[mid ]->linetab,
addr_sorttab[mid ]->name);
DEBUG_Printf(DBG_CHN_MESG, "Found %x:%x when looking for %x:%x %x %s\n",
addr_sorttab[mid ]->value.addr.seg,
addr_sorttab[mid ]->value.addr.off,
addr->seg, addr->off,
addr_sorttab[mid ]->linetab,
addr_sorttab[mid ]->name);
#endif
break;
}
@ -722,7 +731,6 @@ void DEBUG_ReadSymbolTable( const char * filename )
{
FILE * symbolfile;
DBG_VALUE value;
int nargs;
char type;
char * cpnt;
char buffer[256];
@ -730,11 +738,11 @@ void DEBUG_ReadSymbolTable( const char * filename )
if (!(symbolfile = fopen(filename, "r")))
{
fprintf( stderr, "Unable to open symbol table %s\n", filename );
DEBUG_Printf( DBG_CHN_WARN, "Unable to open symbol table %s\n", filename );
return;
}
fprintf( stderr, "Reading symbols from file %s\n", filename );
DEBUG_Printf( DBG_CHN_MESG, "Reading symbols from file %s\n", filename );
value.type = NULL;
value.addr.seg = 0;
@ -760,8 +768,8 @@ void DEBUG_ReadSymbolTable( const char * filename )
}
if (!(*cpnt) || *cpnt == '\n') continue;
nargs = sscanf(buffer, "%lx %c %s", &value.addr.off, &type, name);
DEBUG_AddSymbol( name, &value, NULL, SYM_WINE );
if (sscanf(buffer, "%lx %c %s", &value.addr.off, &type, name) == 3)
DEBUG_AddSymbol( name, &value, NULL, SYM_WINE );
}
fclose(symbolfile);
}
@ -837,7 +845,7 @@ DEBUG_DumpHashInfo(void)
{
depth++;
}
fprintf(stderr, "Bucket %d: %d\n", i, depth);
DEBUG_Printf(DBG_CHN_MESG, "Bucket %d: %d\n", i, depth);
}
}
@ -913,12 +921,12 @@ int DEBUG_CheckLinenoStatus( const DBG_ADDR *addr)
}
nearest = addr_sorttab[mid];
#if 0
fprintf(stderr, "Found %x:%x when looking for %x:%x %x %s\n",
addr_sorttab[mid ]->value.addr.seg,
addr_sorttab[mid ]->value.addr.off,
addr->seg, addr->off,
addr_sorttab[mid ]->linetab,
addr_sorttab[mid ]->name);
DEBUG_Printf(DBG_CHN_MESG, "Found %x:%x when looking for %x:%x %x %s\n",
addr_sorttab[mid ]->value.addr.seg,
addr_sorttab[mid ]->value.addr.off,
addr->seg, addr->off,
addr_sorttab[mid ]->linetab,
addr_sorttab[mid ]->name);
#endif
break;
}
@ -1055,11 +1063,11 @@ DEBUG_GetFuncInfo( struct list_id * ret, const char * filename,
{
if( filename != NULL )
{
fprintf(stderr, "No such function %s in %s\n", name, filename);
DEBUG_Printf(DBG_CHN_MESG, "No such function %s in %s\n", name, filename);
}
else
{
fprintf(stderr, "No such function %s\n", name);
DEBUG_Printf(DBG_CHN_MESG, "No such function %s\n", name);
}
ret->sourcefile = NULL;
ret->line = -1;
@ -1188,17 +1196,17 @@ DEBUG_InfoLocals(void)
{
ptr = (unsigned int *)(((DWORD)&DEBUG_context)
+ reg_ofs[curr_func->local_vars[i].regno - 1]);
fprintf(stderr, "%s:%s (optimized into register $%s) == 0x%8.8x\n",
curr_func->name, curr_func->local_vars[i].name,
reg_name[curr_func->local_vars[i].regno - 1],
*ptr);
DEBUG_Printf(DBG_CHN_MESG, "%s:%s (optimized into register $%s) == 0x%8.8x\n",
curr_func->name, curr_func->local_vars[i].name,
reg_name[curr_func->local_vars[i].regno - 1],
*ptr);
}
else
{
DEBUG_READ_MEM_VERBOSE((void*)(ebp + curr_func->local_vars[i].offset),
&val, sizeof(val));
fprintf(stderr, "%s:%s == 0x%8.8x\n",
curr_func->name, curr_func->local_vars[i].name, val);
DEBUG_Printf(DBG_CHN_MESG, "%s:%s == 0x%8.8x\n",
curr_func->name, curr_func->local_vars[i].name, val);
}
}

View File

@ -29,7 +29,7 @@ void DEBUG_PrintBasic( const DBG_VALUE* value, int count, char format )
assert(value->cookie == DV_TARGET || value->cookie == DV_HOST);
if( value->type == NULL )
{
fprintf(stderr, "Unable to evaluate expression\n");
DEBUG_Printf(DBG_CHN_MESG, "Unable to evaluate expression\n");
return;
}
@ -41,34 +41,34 @@ void DEBUG_PrintBasic( const DBG_VALUE* value, int count, char format )
case 'x':
if (value->addr.seg)
{
DEBUG_nchar += fprintf( stderr, "0x%04lx", (long unsigned int) res );
DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "0x%04lx", (long unsigned int) res );
}
else
{
DEBUG_nchar += fprintf( stderr, "0x%08lx", (long unsigned int) res );
DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "0x%08lx", (long unsigned int) res );
}
break;
case 'd':
DEBUG_nchar += fprintf( stderr, "%ld\n", (long int) res );
DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "%ld\n", (long int) res );
break;
case 'c':
DEBUG_nchar += fprintf( stderr, "%d = '%c'",
(char)(res & 0xff), (char)(res & 0xff) );
DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "%d = '%c'",
(char)(res & 0xff), (char)(res & 0xff) );
break;
case 'i':
case 's':
case 'w':
case 'b':
fprintf( stderr, "Format specifier '%c' is meaningless in 'print' command\n", format );
DEBUG_Printf( DBG_CHN_MESG, "Format specifier '%c' is meaningless in 'print' command\n", format );
case 0:
if( default_format != NULL )
{
if (strstr(default_format, "%S") == NULL)
{
DEBUG_nchar += fprintf( stderr, default_format, res );
DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, default_format, res );
}
else
{
@ -80,7 +80,7 @@ void DEBUG_PrintBasic( const DBG_VALUE* value, int count, char format )
*/
for (ptr = default_format; *ptr; ptr++)
{
fprintf(stderr, "[%c]", *ptr);
DEBUG_Printf(DBG_CHN_MESG, "[%c]", *ptr);
if (*ptr == '%') state++;
else if (state == 1)
@ -130,10 +130,10 @@ DEBUG_PrintAddress( const DBG_ADDR *addr, int addrlen, int flag )
const char *name = DEBUG_FindNearestSymbol( addr, flag, &rtn.sym, 0,
&rtn.list );
if (addr->seg) fprintf( stderr, "0x%04lx:", addr->seg&0xFFFF );
if (addrlen == 16) fprintf( stderr, "0x%04lx", addr->off );
else fprintf( stderr, "0x%08lx", addr->off );
if (name) fprintf( stderr, " (%s)", name );
if (addr->seg) DEBUG_Printf( DBG_CHN_MESG, "0x%04lx:", addr->seg&0xFFFF );
if (addrlen == 16) DEBUG_Printf( DBG_CHN_MESG, "0x%04lx", addr->off );
else DEBUG_Printf( DBG_CHN_MESG, "0x%08lx", addr->off );
if (name) DEBUG_Printf( DBG_CHN_MESG, " (%s)", name );
return rtn;
}
/***********************************************************************
@ -152,10 +152,10 @@ DEBUG_PrintAddressAndArgs( const DBG_ADDR *addr, int addrlen,
const char *name = DEBUG_FindNearestSymbol( addr, flag, &rtn.sym, ebp,
&rtn.list );
if (addr->seg) fprintf( stderr, "0x%04lx:", addr->seg );
if (addrlen == 16) fprintf( stderr, "0x%04lx", addr->off );
else fprintf( stderr, "0x%08lx", addr->off );
if (name) fprintf( stderr, " (%s)", name );
if (addr->seg) DEBUG_Printf( DBG_CHN_MESG, "0x%04lx:", addr->seg );
if (addrlen == 16) DEBUG_Printf( DBG_CHN_MESG, "0x%04lx", addr->off );
else DEBUG_Printf( DBG_CHN_MESG, "0x%08lx", addr->off );
if (name) DEBUG_Printf( DBG_CHN_MESG, " (%s)", name );
return rtn;
}
@ -205,7 +205,7 @@ void DEBUG_Help(void)
NULL
};
while(helptext[i]) fprintf(stderr,"%s\n", helptext[i++]);
while(helptext[i]) DEBUG_Printf(DBG_CHN_MESG,"%s\n", helptext[i++]);
}
@ -236,7 +236,7 @@ void DEBUG_HelpInfo(void)
NULL
};
while(infotext[i]) fprintf(stderr,"%s\n", infotext[i++]);
while(infotext[i]) DEBUG_Printf(DBG_CHN_MESG,"%s\n", infotext[i++]);
}
/* FIXME: merge InfoClass and InfoClass2 */
@ -244,19 +244,19 @@ void DEBUG_InfoClass(const char* name)
{
WNDCLASSEXA wca;
if (!GetClassInfoExA(0, name, &wca)) {
fprintf(stderr, "Cannot find class '%s'\n", name);
if (!GetClassInfoEx(0, name, &wca)) {
DEBUG_Printf(DBG_CHN_MESG, "Cannot find class '%s'\n", name);
return;
}
fprintf(stderr, "Class '%s':\n", name);
fprintf(stderr,
"style=%08x wndProc=%08lx\n"
"inst=%04x icon=%04x cursor=%04x bkgnd=%04x\n"
"clsExtra=%d winExtra=%d\n",
wca.style, (DWORD)wca.lpfnWndProc, wca.hInstance,
wca.hIcon, wca.hCursor, wca.hbrBackground,
wca.cbClsExtra, wca.cbWndExtra);
DEBUG_Printf(DBG_CHN_MESG, "Class '%s':\n", name);
DEBUG_Printf(DBG_CHN_MESG,
"style=%08x wndProc=%08lx\n"
"inst=%04x icon=%04x cursor=%04x bkgnd=%04x\n"
"clsExtra=%d winExtra=%d\n",
wca.style, (DWORD)wca.lpfnWndProc, wca.hInstance,
wca.hIcon, wca.hCursor, wca.hbrBackground,
wca.cbClsExtra, wca.cbWndExtra);
/* FIXME:
* + print #windows (or even list of windows...)
@ -268,34 +268,34 @@ static void DEBUG_InfoClass2(HWND hWnd, const char* name)
{
WNDCLASSEXA wca;
if (!GetClassInfoExA(GetWindowLongA(hWnd, GWL_HINSTANCE), name, &wca)) {
fprintf(stderr, "Cannot find class '%s'\n", name);
if (!GetClassInfoEx(GetWindowLong(hWnd, GWL_HINSTANCE), name, &wca)) {
DEBUG_Printf(DBG_CHN_MESG, "Cannot find class '%s'\n", name);
return;
}
fprintf(stderr, "Class '%s':\n", name);
fprintf(stderr,
"style=%08x wndProc=%08lx\n"
"inst=%04x icon=%04x cursor=%04x bkgnd=%04x\n"
"clsExtra=%d winExtra=%d\n",
wca.style, (DWORD)wca.lpfnWndProc, wca.hInstance,
wca.hIcon, wca.hCursor, wca.hbrBackground,
wca.cbClsExtra, wca.cbWndExtra);
DEBUG_Printf(DBG_CHN_MESG, "Class '%s':\n", name);
DEBUG_Printf(DBG_CHN_MESG,
"style=%08x wndProc=%08lx\n"
"inst=%04x icon=%04x cursor=%04x bkgnd=%04x\n"
"clsExtra=%d winExtra=%d\n",
wca.style, (DWORD)wca.lpfnWndProc, wca.hInstance,
wca.hIcon, wca.hCursor, wca.hbrBackground,
wca.cbClsExtra, wca.cbWndExtra);
if (wca.cbClsExtra) {
int i;
WORD w;
fprintf(stderr, "Extra bytes:" );
DEBUG_Printf(DBG_CHN_MESG, "Extra bytes:" );
for (i = 0; i < wca.cbClsExtra / 2; i++) {
w = GetClassWord(hWnd, i * 2);
/* FIXME: depends on i386 endian-ity */
fprintf(stderr, " %02x", HIBYTE(w));
fprintf(stderr, " %02x", LOBYTE(w));
DEBUG_Printf(DBG_CHN_MESG, " %02x", HIBYTE(w));
DEBUG_Printf(DBG_CHN_MESG, " %02x", LOBYTE(w));
}
fprintf(stderr, "\n" );
DEBUG_Printf(DBG_CHN_MESG, "\n" );
}
fprintf(stderr, "\n" );
DEBUG_Printf(DBG_CHN_MESG, "\n" );
}
struct class_walker {
@ -311,9 +311,9 @@ static void DEBUG_WalkClassesHelper(HWND hWnd, struct class_walker* cw)
ATOM atom;
HWND child;
if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
if (!GetClassName(hWnd, clsName, sizeof(clsName)))
return;
if ((atom = FindAtomA(clsName)) == 0)
if ((atom = FindAtom(clsName)) == 0)
return;
for (i = 0; i < cw->used; i++) {
@ -346,12 +346,12 @@ void DEBUG_WalkClasses(void)
void DEBUG_DumpQueue(DWORD q)
{
fprintf(stderr, "No longer doing info queue '0x%08lx'\n", q);
DEBUG_Printf(DBG_CHN_MESG, "No longer doing info queue '0x%08lx'\n", q);
}
void DEBUG_WalkQueues(void)
{
fprintf(stderr, "No longer walking queues list\n");
DEBUG_Printf(DBG_CHN_MESG, "No longer walking queues list\n");
}
void DEBUG_InfoWindow(HWND hWnd)
@ -363,9 +363,9 @@ void DEBUG_InfoWindow(HWND hWnd)
int i;
WORD w;
if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
if (!GetClassName(hWnd, clsName, sizeof(clsName)))
strcpy(clsName, "-- Unknown --");
if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
strcpy(wndName, "-- Empty --");
if (!GetClientRect(hWnd, &clientRect))
SetRectEmpty(&clientRect);
@ -373,38 +373,38 @@ void DEBUG_InfoWindow(HWND hWnd)
SetRectEmpty(&windowRect);
/* FIXME missing fields: hmemTaskQ, hrgnUpdate, dce, flags, pProp, scroll */
fprintf(stderr,
"next=0x%04x child=0x%04x parent=0x%04x owner=0x%04x class='%s'\n"
"inst=%08lx active=%04x idmenu=%08lx\n"
"style=%08lx exstyle=%08lx wndproc=%08lx text='%s'\n"
"client=%d,%d-%d,%d window=%d,%d-%d,%d sysmenu=%04x\n",
GetWindow(hWnd, GW_HWNDNEXT),
GetWindow(hWnd, GW_CHILD),
GetParent(hWnd),
GetWindow(hWnd, GW_OWNER),
clsName,
GetWindowLongA(hWnd, GWL_HINSTANCE),
GetLastActivePopup(hWnd),
GetWindowLongA(hWnd, GWL_ID),
GetWindowLongA(hWnd, GWL_STYLE),
GetWindowLongA(hWnd, GWL_EXSTYLE),
GetWindowLongA(hWnd, GWL_WNDPROC),
wndName,
clientRect.left, clientRect.top, clientRect.right, clientRect.bottom,
windowRect.left, windowRect.top, windowRect.right, windowRect.bottom,
GetSystemMenu(hWnd, FALSE));
DEBUG_Printf(DBG_CHN_MESG,
"next=0x%04x child=0x%04x parent=0x%04x owner=0x%04x class='%s'\n"
"inst=%08lx active=%04x idmenu=%08lx\n"
"style=%08lx exstyle=%08lx wndproc=%08lx text='%s'\n"
"client=%d,%d-%d,%d window=%d,%d-%d,%d sysmenu=%04x\n",
GetWindow(hWnd, GW_HWNDNEXT),
GetWindow(hWnd, GW_CHILD),
GetParent(hWnd),
GetWindow(hWnd, GW_OWNER),
clsName,
GetWindowLong(hWnd, GWL_HINSTANCE),
GetLastActivePopup(hWnd),
GetWindowLong(hWnd, GWL_ID),
GetWindowLong(hWnd, GWL_STYLE),
GetWindowLong(hWnd, GWL_EXSTYLE),
GetWindowLong(hWnd, GWL_WNDPROC),
wndName,
clientRect.left, clientRect.top, clientRect.right, clientRect.bottom,
windowRect.left, windowRect.top, windowRect.right, windowRect.bottom,
GetSystemMenu(hWnd, FALSE));
if (GetClassLongA(hWnd, GCL_CBWNDEXTRA)) {
fprintf(stderr, "Extra bytes:" );
for (i = 0; i < GetClassLongA(hWnd, GCL_CBWNDEXTRA) / 2; i++) {
if (GetClassLong(hWnd, GCL_CBWNDEXTRA)) {
DEBUG_Printf(DBG_CHN_MESG, "Extra bytes:" );
for (i = 0; i < GetClassLong(hWnd, GCL_CBWNDEXTRA) / 2; i++) {
w = GetWindowWord(hWnd, i * 2);
/* FIXME: depends on i386 endian-ity */
fprintf(stderr, " %02x", HIBYTE(w));
fprintf(stderr, " %02x", LOBYTE(w));
DEBUG_Printf(DBG_CHN_MESG, " %02x", HIBYTE(w));
DEBUG_Printf(DBG_CHN_MESG, " %02x", LOBYTE(w));
}
fprintf(stderr, "\n");
DEBUG_Printf(DBG_CHN_MESG, "\n");
}
fprintf(stderr, "\n");
DEBUG_Printf(DBG_CHN_MESG, "\n");
}
void DEBUG_WalkWindows(HWND hWnd, int indent)
@ -417,21 +417,21 @@ void DEBUG_WalkWindows(HWND hWnd, int indent)
hWnd = GetDesktopWindow();
if (!indent) /* first time around */
fprintf(stderr,
"%-16.16s %-17.17s %-8.8s %s\n",
"hwnd", "Class Name", " Style", " WndProc Text");
DEBUG_Printf(DBG_CHN_MESG,
"%-16.16s %-17.17s %-8.8s %s\n",
"hwnd", "Class Name", " Style", " WndProc Text");
do {
if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
if (!GetClassName(hWnd, clsName, sizeof(clsName)))
strcpy(clsName, "-- Unknown --");
if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
strcpy(wndName, "-- Empty --");
/* FIXME: missing hmemTaskQ */
fprintf(stderr, "%*s%04x%*s", indent, "", hWnd, 13-indent,"");
fprintf(stderr, "%-17.17s %08lx %08lx %.14s\n",
clsName, GetWindowLongA(hWnd, GWL_STYLE),
GetWindowLongA(hWnd, GWL_WNDPROC), wndName);
DEBUG_Printf(DBG_CHN_MESG, "%*s%04x%*s", indent, "", hWnd, 13-indent,"");
DEBUG_Printf(DBG_CHN_MESG, "%-17.17s %08lx %08lx %.14s\n",
clsName, GetWindowLong(hWnd, GWL_STYLE),
GetWindowLong(hWnd, GWL_WNDPROC), wndName);
if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
DEBUG_WalkWindows(child, indent + 1 );
@ -440,12 +440,12 @@ void DEBUG_WalkWindows(HWND hWnd, int indent)
void DEBUG_WalkProcess(void)
{
fprintf(stderr, "No longer walking processes list\n");
DEBUG_Printf(DBG_CHN_MESG, "No longer walking processes list\n");
}
void DEBUG_WalkModref(DWORD p)
{
fprintf(stderr, "No longer walking module references list\n");
DEBUG_Printf(DBG_CHN_MESG, "No longer walking module references list\n");
}
void DEBUG_InfoSegments(DWORD start, int length)
@ -473,19 +473,19 @@ void DEBUG_InfoSegments(DWORD start, int length)
flags[1] = (le.HighWord.Bits.Type & 0x2) ? 'w' : '-';
flags[2] = '-';
}
fprintf(stderr,
"%04lx: sel=%04lx base=%08x limit=%08x %d-bit %c%c%c\n",
i, (i<<3)|7,
(le.HighWord.Bits.BaseHi << 24) +
(le.HighWord.Bits.BaseMid << 16) + le.BaseLow,
((le.HighWord.Bits.LimitHi << 8) + le.LimitLow) <<
(le.HighWord.Bits.Granularity ? 12 : 0),
le.HighWord.Bits.Default_Big ? 32 : 16,
flags[0], flags[1], flags[2] );
DEBUG_Printf(DBG_CHN_MESG,
"%04lx: sel=%04lx base=%08x limit=%08x %d-bit %c%c%c\n",
i, (i<<3)|7,
(le.HighWord.Bits.BaseHi << 24) +
(le.HighWord.Bits.BaseMid << 16) + le.BaseLow,
((le.HighWord.Bits.LimitHi << 8) + le.LimitLow) <<
(le.HighWord.Bits.Granularity ? 12 : 0),
le.HighWord.Bits.Default_Big ? 32 : 16,
flags[0], flags[1], flags[2] );
}
}
void DEBUG_InfoVirtual(void)
{
fprintf(stderr, "No longer providing virtual mapping information\n");
DEBUG_Printf(DBG_CHN_MESG, "No longer providing virtual mapping information\n");
}

3
debugger/intvar.h Normal file
View File

@ -0,0 +1,3 @@
INTERNAL_VAR(BreakAllThreadsStartup, FALSE)
INTERNAL_VAR(ExtDbgOnInvalidAddress, FALSE)
INTERNAL_VAR(ChannelMask, DBG_CHN_MESG)

View File

@ -23,7 +23,7 @@
static void DEBUG_Die(const char* msg)
{
fprintf(stderr, msg);
DEBUG_Printf(DBG_CHN_MESG, msg);
exit(1);
}
@ -118,16 +118,21 @@ void DEBUG_GetCurrentAddress( DBG_ADDR *addr )
#endif
}
void DEBUG_InvalAddr( const DBG_ADDR* addr )
{
DEBUG_Printf(DBG_CHN_MESG,"*** Invalid address ");
DEBUG_PrintAddress(addr, DEBUG_CurrThread->dbg_mode, FALSE);
DEBUG_Printf(DBG_CHN_MESG,"\n");
if (DBG_IVAR(ExtDbgOnInvalidAddress)) DEBUG_ExternalDebugger();
}
void DEBUG_InvalLinAddr( void* addr )
{
DBG_ADDR address;
address.seg = 0;
address.off = (unsigned long)addr;
fprintf(stderr,"*** Invalid address ");
DEBUG_PrintAddress(&address, DEBUG_CurrThread->dbg_mode, FALSE);
fprintf(stderr,"\n");
DEBUG_InvalAddr( &address );
}
/***********************************************************************
@ -215,14 +220,14 @@ void DEBUG_ExamineMemory( const DBG_VALUE *_value, int count, char format )
}
else if (!value.addr.seg && !value.addr.off)
{
fprintf(stderr,"Invalid expression\n");
DEBUG_Printf(DBG_CHN_MESG,"Invalid expression\n");
return;
}
if (format != 'i' && count > 1)
{
DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, FALSE );
fprintf(stderr,": ");
DEBUG_Printf(DBG_CHN_MESG,": ");
}
pnt = (void*)DEBUG_ToLinear( &value.addr );
@ -239,7 +244,7 @@ void DEBUG_ExamineMemory( const DBG_VALUE *_value, int count, char format )
pnt += sizeof(wch);
fputc( (char)wch, stderr );
}
fprintf(stderr,"\n");
DEBUG_Printf(DBG_CHN_MESG,"\n");
return;
}
case 's': {
@ -253,31 +258,31 @@ void DEBUG_ExamineMemory( const DBG_VALUE *_value, int count, char format )
pnt++;
fputc( ch, stderr );
}
fprintf(stderr,"\n");
DEBUG_Printf(DBG_CHN_MESG,"\n");
return;
}
case 'i':
while (count--)
{
DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, TRUE );
fprintf(stderr,": ");
DEBUG_Printf(DBG_CHN_MESG,": ");
DEBUG_Disasm( &value.addr, TRUE );
fprintf(stderr,"\n");
DEBUG_Printf(DBG_CHN_MESG,"\n");
}
return;
#define DO_DUMP2(_t,_l,_f,_vv) { \
_t _v; \
for(i=0; i<count; i++) { \
if (!DEBUG_READ_MEM_VERBOSE(pnt, &_v, sizeof(_t))) break; \
fprintf(stderr,_f,(_vv)); \
DEBUG_Printf(DBG_CHN_MESG,_f,(_vv)); \
pnt += sizeof(_t); value.addr.off += sizeof(_t); \
if ((i % (_l)) == (_l)-1) { \
fprintf(stderr,"\n"); \
DEBUG_Printf(DBG_CHN_MESG,"\n"); \
DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, FALSE );\
fprintf(stderr,": ");\
DEBUG_Printf(DBG_CHN_MESG,": ");\
} \
} \
fprintf(stderr,"\n"); \
DEBUG_Printf(DBG_CHN_MESG,"\n"); \
} \
return
#define DO_DUMP(_t,_l,_f) DO_DUMP2(_t,_l,_f,_v)

View File

@ -12,6 +12,7 @@
#include "neexe.h"
#include "peexe.h"
#include "module.h"
#include "file.h"
#include "debugger.h"
#include "toolhelp.h"
@ -232,7 +233,7 @@ static void DEBUG_LoadModule16(HMODULE hModule, NE_MODULE* module, char* moduleA
/***********************************************************************
* DEBUG_LoadModule32
*/
void DEBUG_LoadModule32(const char* name, DWORD base)
void DEBUG_LoadModule32(const char* name, HANDLE hFile, DWORD base)
{
DBG_VALUE value;
char buffer[256];
@ -249,7 +250,7 @@ void DEBUG_LoadModule32(const char* name, DWORD base)
/* FIXME: we make the assumption that hModule == base */
wmod = DEBUG_RegisterPEModule((HMODULE)base, base, name);
fprintf(stderr, "Registring 32bit DLL '%s' at %08lx\n", name, base);
DEBUG_Printf(DBG_CHN_TRACE, "Registring 32bit DLL '%s' at %08lx\n", name, base);
value.type = NULL;
value.cookie = DV_TARGET;
@ -264,8 +265,8 @@ void DEBUG_LoadModule32(const char* name, DWORD base)
return;
if (wmod) {
DEBUG_RegisterMSCDebugInfo(wmod, &pe_header, pe_header_ofs);
DEBUG_RegisterStabsDebugInfo(wmod, &pe_header, pe_header_ofs);
DEBUG_RegisterStabsDebugInfo(wmod, hFile, &pe_header, pe_header_ofs);
DEBUG_RegisterMSCDebugInfo(wmod, hFile, &pe_header, pe_header_ofs);
}
/* Add start of DLL */
@ -282,11 +283,9 @@ void DEBUG_LoadModule32(const char* name, DWORD base)
pe_header.FileHeader.SizeOfOptionalHeader;
for (i = 0; i < pe_header.FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg)) {
if (!DEBUG_READ_MEM_VERBOSE((void*)(base + pe_seg_ofs), &pe_seg, sizeof(pe_seg)) ||
!DEBUG_READ_MEM_VERBOSE((void*)pe_seg.Name, bufstr, sizeof(bufstr)))
if (!DEBUG_READ_MEM_VERBOSE((void*)(base + pe_seg_ofs), &pe_seg, sizeof(pe_seg)))
continue;
bufstr[sizeof(bufstr) - 1] = 0;
sprintf(buffer, "%s.%s", name, bufstr);
sprintf(buffer, "%s.%s", name, pe_seg.Name);
value.addr.off = base + pe_seg.VirtualAddress;
DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
}
@ -359,6 +358,10 @@ int DEBUG_LoadEntryPoints(const char* pfx)
int len;
/* FIXME: we assume that a module is never removed from memory */
/* FIXME: this is (currently plain wrong when debugger is started by
* attaching to an existing program => the 16 bit modules will
* not be shared... not much to do on debugger side... sigh
*/
if (ModuleFirst16(&entry)) do {
if (DEBUG_FindModuleByName(entry.szModule, DM_TYPE_UNKNOWN) ||
!(moduleAddr = NE_GetPtr(entry.hModule)) ||
@ -366,68 +369,27 @@ int DEBUG_LoadEntryPoints(const char* pfx)
(module.flags & NE_FFLAGS_WIN32) /* NE module */)
continue;
if (!first) {
if (pfx) fprintf(stderr, pfx);
fprintf(stderr, " ");
if (pfx) DEBUG_Printf(DBG_CHN_MESG, pfx);
DEBUG_Printf(DBG_CHN_MESG, " ");
rowcount = 3 + (pfx ? strlen(pfx) : 0);
first = 1;
}
len = strlen(entry.szModule);
if ((rowcount + len) > 76) {
fprintf(stderr, "\n ");
DEBUG_Printf(DBG_CHN_MESG, "\n ");
rowcount = 3;
}
fprintf(stderr, " %s", entry.szModule);
DEBUG_Printf(DBG_CHN_MESG, " %s", entry.szModule);
rowcount += len + 1;
DEBUG_LoadModule16(entry.hModule, &module, moduleAddr, entry.szModule);
} while (ModuleNext16(&entry));
if (first) fprintf(stderr, "\n");
if (first) DEBUG_Printf(DBG_CHN_MESG, "\n");
return first;
}
/***********************************************************************
* DEBUG_ProcessDeferredDebug
*
*/
int DEBUG_ProcessDeferredDebug(void)
{
DBG_MODULE* wmod;
int sts;
int last_proc = -1;
int need_print = 0;
int rowcount = 0;
int len;
for (wmod = DEBUG_CurrProcess->modules; wmod; wmod = wmod->next) {
if (wmod->status != DM_STATUS_NEW) continue;
if (last_proc != wmod->dbg_index) {
if (!need_print) {
fprintf(stderr, "DeferredDebug for:");
rowcount = 18;
need_print = 1;
}
if (rowcount + (len = strlen(wmod->module_name)) > 76) {
rowcount = 0;
fprintf(stderr, "\n");
} else {
fprintf(stderr, " ");
rowcount++;
}
rowcount += len;
fprintf(stderr, wmod->module_name);
last_proc = wmod->dbg_index;
}
sts = (wmod->extra_info) ? DEBUG_ProcessMSCDebugInfo(wmod) : TRUE;
wmod->status = (sts) ? DM_STATUS_LOADED : DM_STATUS_ERROR;
}
if (need_print) fprintf(stderr, "\n");
return TRUE;
}
/***********************************************************************
* DEBUG_InfoShare
*
@ -438,7 +400,7 @@ void DEBUG_InfoShare(void)
DBG_MODULE* wmod;
const char* xtype;
fprintf(stderr, "Address\t\tModule\tName\n");
DEBUG_Printf(DBG_CHN_MESG, "Address\t\tModule\tName\n");
for (wmod = DEBUG_CurrProcess->modules; wmod; wmod = wmod->next) {
switch (wmod->type) {
@ -447,8 +409,8 @@ void DEBUG_InfoShare(void)
case DM_TYPE_ELF: xtype = "ELF"; break;
default: xtype = "???"; break;
}
fprintf(stderr, "0x%8.8x\t(%s)\t%s\n", (unsigned int)wmod->load_addr,
xtype, wmod->module_name);
DEBUG_Printf(DBG_CHN_MESG, "0x%8.8x\t(%s)\t%s\n", (unsigned int)wmod->load_addr,
xtype, wmod->module_name);
}
}
@ -482,13 +444,13 @@ void DEBUG_DumpModule(DWORD mod)
if (!(wmod = DEBUG_FindModuleByHandle(mod, DM_TYPE_UNKNOWN)) &&
!(wmod = DEBUG_FindModuleByAddr((void*)mod, DM_TYPE_UNKNOWN))) {
fprintf(stderr, "'0x%08lx' is not a valid module handle or address\n", mod);
DEBUG_Printf(DBG_CHN_MESG, "'0x%08lx' is not a valid module handle or address\n", mod);
return;
}
fprintf(stderr, "Module '%s' (handle=0x%08x) at 0x%8.8x (%s/%s)\n",
wmod->module_name, wmod->handle, (unsigned int)wmod->load_addr,
DEBUG_GetModuleType(wmod->type), DEBUG_GetModuleStatus(wmod->status));
DEBUG_Printf(DBG_CHN_MESG, "Module '%s' (handle=0x%08x) at 0x%8.8x (%s/%s)\n",
wmod->module_name, wmod->handle, (unsigned int)wmod->load_addr,
DEBUG_GetModuleType(wmod->type), DEBUG_GetModuleStatus(wmod->status));
}
/***********************************************************************
@ -501,7 +463,7 @@ void DEBUG_WalkModules(void)
DBG_MODULE* wmod;
const char* xtype;
fprintf(stderr, "Address\t\tModule\tName\n");
DEBUG_Printf(DBG_CHN_MESG, "Address\t\tModule\tName\n");
for (wmod = DEBUG_CurrProcess->modules; wmod; wmod = wmod->next) {
switch (wmod->type) {
@ -511,9 +473,9 @@ void DEBUG_WalkModules(void)
default: xtype = "???"; break;
}
fprintf(stderr, "0x%8.8x\t(%s)\t%s\n",
(unsigned int)wmod->load_addr, DEBUG_GetModuleType(wmod->type),
wmod->module_name);
DEBUG_Printf(DBG_CHN_MESG, "0x%8.8x\t(%s)\t%s\n",
(unsigned int)wmod->load_addr, DEBUG_GetModuleType(wmod->type),
wmod->module_name);
}
}

View File

@ -16,16 +16,8 @@
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#include <fcntl.h>
#include <sys/stat.h>
#include <limits.h>
#include <string.h>
#include <unistd.h>
#ifndef PATH_MAX
@ -46,44 +38,79 @@ typedef struct {
#define MSC_INFO(module) ((MSC_DBG_INFO*)((module)->extra_info))
static int DEBUG_ProcessMSCDebugInfo(DBG_MODULE* module);
/*
* dbg_filename must be at least MAX_PATHNAME_LEN bytes in size
*/
static void LocateDebugInfoFile(char *filename, char *dbg_filename)
static void DEBUG_LocateDebugInfoFile(const char *filename, char *dbg_filename)
{
char *str1 = DBG_alloc(MAX_PATHNAME_LEN*10);
char *str2 = DBG_alloc(MAX_PATHNAME_LEN);
char *file;
char *str1 = DBG_alloc(MAX_PATHNAME_LEN);
char *str2 = DBG_alloc(MAX_PATHNAME_LEN*10);
const char *file;
char *name_part;
DOS_FULL_NAME fullname;
file = strrchr(filename, '\\');
if( file == NULL ) file = filename; else file++;
if (GetEnvironmentVariableA("_NT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN))
if (SearchPathA(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))
goto ok;
if (GetEnvironmentVariableA("_NT_ALT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN))
if (SearchPathA(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))
goto ok;
if (SearchPathA(NULL, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))
goto ok;
if ((GetEnvironmentVariable("_NT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN) &&
(SearchPath(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))) ||
(GetEnvironmentVariable("_NT_ALT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN) &&
(SearchPath(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))) ||
(SearchPath(NULL, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part)))
lstrcpyn(dbg_filename, str2, MAX_PATHNAME_LEN);
else
{
quit:
memcpy(dbg_filename, filename, MAX_PATHNAME_LEN);
DBG_free(str1);
DBG_free(str2);
return;
}
ok:
if (DOSFS_GetFullName(str2, TRUE, &fullname))
memcpy(dbg_filename, fullname.long_name, MAX_PATHNAME_LEN);
else
goto quit;
lstrcpyn(dbg_filename, filename, MAX_PATHNAME_LEN);
DBG_free(str1);
DBG_free(str2);
return;
}
/***********************************************************************
* DEBUG_MapDebugInfoFile
*/
static void* DEBUG_MapDebugInfoFile(const char* name, DWORD offset, DWORD size,
HANDLE* hFile, HANDLE* hMap)
{
OFSTRUCT ofs;
DWORD g_offset; /* offset aligned on map granuality */
DWORD g_size; /* size to map, with offset aligned */
char* ret;
*hMap = 0;
if (name != NULL) {
char filename[MAX_PATHNAME_LEN];
DEBUG_LocateDebugInfoFile(name, filename);
if ((*hFile = OpenFile(filename, &ofs, OF_READ)) == HFILE_ERROR)
return NULL;
}
if (!size) {
DWORD file_size = GetFileSize(*hFile, NULL);
if (file_size == (DWORD)-1) return NULL;
size = file_size - offset;
}
g_offset = offset & ~0xFFFF; /* FIXME: is granularity portable ? */
g_size = offset + size - g_offset;
if ((*hMap = CreateFileMapping(*hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == 0)
return NULL;
if ((ret = MapViewOfFile(*hMap, FILE_MAP_READ, 0, g_offset, g_size)) != NULL)
ret += offset - g_offset;
return ret;
}
/***********************************************************************
* DEBUG_UnmapDebugInfoFile
*/
static void DEBUG_UnmapDebugInfoFile(HANDLE hFile, HANDLE hMap, void* addr)
{
if (addr) UnmapViewOfFile(addr);
if (hMap) CloseHandle(hMap);
if (hFile) CloseHandle(hFile);
}
union any_size
@ -790,7 +817,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
break;
}
if( type->array.namelen != 0 )
@ -825,7 +852,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
break;
}
if( type->array32.namelen != 0 )
@ -900,7 +927,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
}
else
{
@ -920,7 +947,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
}
else
{
@ -935,7 +962,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* object in the fieldlist, or some other problem which I wouldn't
* really know how to handle until it came up.
*/
fprintf(stderr, "Unexpected entry in fieldlist\n");
DEBUG_Printf(DBG_CHN_MESG, "Unexpected entry in fieldlist\n");
break;
}
@ -990,7 +1017,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
}
else
{
@ -1010,7 +1037,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
}
else
{
@ -1025,7 +1052,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* object in the fieldlist, or some other problem which I wouldn't
* really know how to handle until it came up.
*/
fprintf(stderr, "Unexpected entry in fieldlist\n");
DEBUG_Printf(DBG_CHN_MESG, "Unexpected entry in fieldlist\n");
break;
}
@ -1041,7 +1068,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
break;
}
memset(symname, 0, sizeof(symname));
@ -1075,7 +1102,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
break;
}
memset(symname, 0, sizeof(symname));
@ -1108,7 +1135,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
break;
}
memset(symname, 0, sizeof(symname));
@ -1143,7 +1170,7 @@ DEBUG_ParseTypeTable(char * table, int len)
* This is a numeric leaf, I am too lazy to handle this right
* now.
*/
fprintf(stderr, "Ignoring large numberic leaf.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ignoring large numberic leaf.\n");
break;
}
memset(symname, 0, sizeof(symname));
@ -1274,7 +1301,7 @@ DEBUG_InitCVDataTypes(void)
* We don't fully process it here for performance reasons.
*/
int
DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, void* _nth, unsigned long nth_ofs)
DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, HANDLE hFile, void* _nth, unsigned long nth_ofs)
{
int has_codeview = FALSE;
int rtn = FALSE;
@ -1309,7 +1336,7 @@ DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, void* _nth, unsigned long nth_ofs
case IMAGE_DEBUG_TYPE_COFF:
/*
* If we have both codeview and COFF debug info, ignore the
* coff debug info as it would just confuse us, and it is
* coff debug info as it would just confuse us, and it is
* less complete.
*
* FIXME - this is broken - if we cannot find the PDB file, then
@ -1335,11 +1362,6 @@ DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, void* _nth, unsigned long nth_ofs
if( (dbg.Type != IMAGE_DEBUG_TYPE_MISC) ||
(nth->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) != 0 )
{
char fn[PATH_MAX];
int fd = -1;
DOS_FULL_NAME full_name;
char* dbg_info;
/*
* Read the important bits. What we do after this depends
* upon the type, but this is always enough so we are able
@ -1349,31 +1371,27 @@ DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, void* _nth, unsigned long nth_ofs
* the DataDirectory array's content. One its entry contains the *beloved*
* debug information. (Note the DataDirectory is mapped, not its content)
*/
/* FIXME: the module->handle value is not usable in the debugger's process */
if (GetModuleFileNameA(module->handle, fn, sizeof(fn)) > 0 &&
DOSFS_GetFullName(fn, TRUE, &full_name) &&
(fd = open(full_name.long_name, O_RDONLY)) > 0)
{
dbg_info = mmap(NULL, dbg.SizeOfData,
PROT_READ, MAP_PRIVATE, fd, dbg.PointerToRawData);
close(fd);
if( dbg_info == (char *) 0xffffffff ) break;
}
else
{
fprintf(stderr, " (not mapped: fn='%s', lfn='%s', fd=%d)\n", fn, full_name.long_name, fd);
break;
}
if (!(module->extra_info = DBG_alloc(sizeof(MSC_DBG_INFO))))
break;
HANDLE hMap;
char* dbg_info;
MSC_INFO(module)->dbg_info = dbg_info;
MSC_INFO(module)->dbg_size = dbg.SizeOfData;
MSC_INFO(module)->dbgdir = dbg;
MSC_INFO(module)->sect_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
nth->FileHeader.SizeOfOptionalHeader;
MSC_INFO(module)->nsect = nth->FileHeader.NumberOfSections;
}
DEBUG_Printf(DBG_CHN_TRACE, "PE debugging info at %ld<%ld>\n", dbg.PointerToRawData, dbg.SizeOfData);
dbg_info = DEBUG_MapDebugInfoFile(NULL, dbg.PointerToRawData, dbg.SizeOfData,
&hFile, &hMap);
if (dbg_info != NULL &&
(module->extra_info = DBG_alloc(sizeof(MSC_DBG_INFO))) != NULL) {
MSC_INFO(module)->dbg_info = dbg_info;
MSC_INFO(module)->dbg_size = dbg.SizeOfData;
MSC_INFO(module)->dbgdir = dbg;
MSC_INFO(module)->sect_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
nth->FileHeader.SizeOfOptionalHeader;
MSC_INFO(module)->nsect = nth->FileHeader.NumberOfSections;
DEBUG_ProcessMSCDebugInfo(module);
DBG_free(MSC_INFO(module));
MSC_INFO(module) = NULL;
}
DEBUG_UnmapDebugInfoFile(0, hMap, dbg_info);
}
break;
#if 0
default:
@ -1388,44 +1406,65 @@ DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, void* _nth, unsigned long nth_ofs
}
/* look for stabs information in PE header (it's how mingw compiler provides its
* debugging information
* debugging information), and also wine PE <-> ELF linking thru .wsolnk sections
*/
int DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, void* _nth, unsigned long nth_ofs)
int DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, HANDLE hFile, void* _nth,
unsigned long nth_ofs)
{
IMAGE_SECTION_HEADER pe_seg;
unsigned long pe_seg_ofs;
int i, stabsize = 0, stabstrsize = 0;
unsigned int stabs = 0, stabstr = 0;
char bufstr[256];
PIMAGE_NT_HEADERS nth = (PIMAGE_NT_HEADERS)_nth;
int i, stabsize = 0, stabstrsize = 0, xcnlnksize = 0;
unsigned int stabs = 0, stabstr = 0, xcnlnk = 0;
PIMAGE_NT_HEADERS nth = (PIMAGE_NT_HEADERS)_nth;
pe_seg_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
nth->FileHeader.SizeOfOptionalHeader;
for (i = 0; i < nth->FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg)) {
if (!DEBUG_READ_MEM_VERBOSE((void*)((char *)module->load_addr + pe_seg_ofs),
&pe_seg, sizeof(pe_seg)) ||
!DEBUG_READ_MEM_VERBOSE((void*)pe_seg.Name, bufstr, sizeof(bufstr)))
{fprintf(stderr, "err3\n");continue;}
bufstr[sizeof(bufstr) - 1] = 0;
&pe_seg, sizeof(pe_seg)))
continue;
if (!strcasecmp(bufstr, ".stab")) {
if (!strcasecmp(pe_seg.Name, ".stab")) {
stabs = pe_seg.VirtualAddress;
stabsize = pe_seg.SizeOfRawData;
} else if (!strncasecmp(bufstr, ".stabstr", 8)) {
} else if (!strncasecmp(pe_seg.Name, ".stabstr", 8)) {
stabstr = pe_seg.VirtualAddress;
stabstrsize = pe_seg.SizeOfRawData;
} else if (!strncasecmp(pe_seg.Name, ".xcnlnk", 7)) {
xcnlnk = pe_seg.VirtualAddress;
xcnlnksize = pe_seg.SizeOfRawData;
}
}
if (stabstrsize && stabsize) {
#ifdef _WE_SUPPORT_THE_STAB_TYPES_USED_BY_MINGW_TOO
/* Won't work currently, since MINGW32 uses some special typedefs
* which we do not handle yet. Support for them is a bit difficult.
*/
/* FIXME: load_addr is in a different address space... */
DEBUG_ParseStabs(module->load_addr, 0, stabs, stabsize, stabstr, stabstrsize);
#endif
fprintf(stderr,"(stabs not loaded)");
char* s1 = DBG_alloc(stabsize+stabstrsize);
if (s1) {
if (DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabs, s1, stabsize) &&
DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabstr,
s1 + stabsize, stabstrsize)) {
DEBUG_ParseStabs(s1, 0, 0, stabsize, stabsize, stabstrsize);
} else {
DEBUG_Printf(DBG_CHN_MESG, "couldn't read data block\n");
}
DBG_free(s1);
} else {
DEBUG_Printf(DBG_CHN_MESG, "couldn't alloc %d bytes\n",
stabsize + stabstrsize);
}
}
if (xcnlnksize) {
DWORD addr;
char bufstr[256];
if (DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + xcnlnk, &addr,
sizeof(addr)) &&
DEBUG_READ_MEM_VERBOSE((char*)addr, bufstr, sizeof(bufstr))) {
bufstr[sizeof(bufstr) - 1] = 0;
DEBUG_Printf(DBG_CHN_TRACE, "Got xcnlnk: argv0 '%s'\n", bufstr);
DEBUG_ReadExecutableDbgInfo(bufstr);
}
}
return TRUE;
}
@ -1504,9 +1543,7 @@ DEBUG_ProcessCoff(DBG_MODULE* module)
curr_file->linecnt = 0;
curr_file->entries = NULL;
curr_file->neps = curr_file->neps_alloc = 0;
#if 0
fprintf(stderr,"New file %s\n", curr_file->filename);
#endif
DEBUG_Printf(DBG_CHN_TRACE,"New file %s\n", curr_file->filename);
i += naux;
continue;
}
@ -1527,19 +1564,19 @@ DEBUG_ProcessCoff(DBG_MODULE* module)
if( curr_file->linetab_offset != -1 )
{
#if 0
fprintf(stderr, "Duplicating sect from %s: %x %x %x %d %d\n",
curr_file->filename,
aux->Length,
aux->NumberOfRelocations,
aux->NumberOfLinenumbers,
aux->Number,
aux->Selection);
fprintf(stderr, "More sect %d %x %d %d %d\n",
coff_sym->SectionNumber,
coff_sym->Value,
coff_sym->Type,
coff_sym->StorageClass,
coff_sym->NumberOfAuxSymbols);
DEBUG_Printf(DBG_CHN_TRACE, "Duplicating sect from %s: %x %x %x %d %d\n",
curr_file->filename,
aux->Length,
aux->NumberOfRelocations,
aux->NumberOfLinenumbers,
aux->Number,
aux->Selection);
DEBUG_Printf(DBG_CHN_TRACE, "More sect %d %x %d %d %d\n",
coff_sym->SectionNumber,
coff_sym->Value,
coff_sym->Type,
coff_sym->StorageClass,
coff_sym->NumberOfAuxSymbols);
#endif
/*
@ -1555,7 +1592,7 @@ DEBUG_ProcessCoff(DBG_MODULE* module)
{
nfiles_alloc += 10;
coff_files = (struct CoffFiles *) DBG_realloc(coff_files,
nfiles_alloc * sizeof(struct CoffFiles));
nfiles_alloc * sizeof(struct CoffFiles));
}
curr_file = coff_files + nfiles;
nfiles++;
@ -1570,13 +1607,13 @@ DEBUG_ProcessCoff(DBG_MODULE* module)
#if 0
else
{
fprintf(stderr, "New text sect from %s: %x %x %x %d %d\n",
curr_file->filename,
aux->Length,
aux->NumberOfRelocations,
aux->NumberOfLinenumbers,
aux->Number,
aux->Selection);
DEBUG_Printf(DBG_CHN_TRACE, "New text sect from %s: %x %x %x %d %d\n",
curr_file->filename,
aux->Length,
aux->NumberOfRelocations,
aux->NumberOfLinenumbers,
aux->Number,
aux->Selection);
}
#endif
@ -1638,7 +1675,7 @@ DEBUG_ProcessCoff(DBG_MODULE* module)
curr_file->neps_alloc * sizeof(struct name_hash *));
}
#if 0
fprintf(stderr,"\tAdding static symbol %s\n", nampnt);
DEBUG_Printf(DBG_CHN_TRACE,"\tAdding static symbol %s\n", nampnt);
#endif
curr_file->entries[curr_file->neps++] =
DEBUG_AddSymbol( nampnt, &new_value, this_file, SYM_WIN32 );
@ -1671,9 +1708,9 @@ DEBUG_ProcessCoff(DBG_MODULE* module)
new_value.addr.off = (int) ((char *)module->load_addr + coff_sym->Value);
#if 0
fprintf(stderr, "%d: %x %s\n", i, new_value.addr.off, nampnt);
DEBUG_Printf(DBG_CHN_TRACE, "%d: %x %s\n", i, new_value.addr.off, nampnt);
fprintf(stderr,"\tAdding global symbol %s\n", nampnt);
DEBUG_Printf(DBG_CHN_TRACE,"\tAdding global symbol %s\n", nampnt);
#endif
/*
@ -1730,9 +1767,9 @@ DEBUG_ProcessCoff(DBG_MODULE* module)
new_value.addr.off = (int) ((char *)module->load_addr + coff_sym->Value);
#if 0
fprintf(stderr, "%d: %x %s\n", i, new_value.addr.off, nampnt);
DEBUG_Printf(DBG_CHN_TRACE, "%d: %x %s\n", i, new_value.addr.off, nampnt);
fprintf(stderr,"\tAdding global data symbol %s\n", nampnt);
DEBUG_Printf(DBG_CHN_TRACE,"\tAdding global data symbol %s\n", nampnt);
#endif
/*
@ -1755,8 +1792,8 @@ DEBUG_ProcessCoff(DBG_MODULE* module)
}
#if 0
fprintf(stderr,"Skipping unknown entry %d %d %d\n", coff_sym->StorageClass,
coff_sym->SectionNumber, naux);
DEBUG_Printf(DBG_CHN_TRACE,"Skipping unknown entry %d %d %d\n", coff_sym->StorageClass,
coff_sym->SectionNumber, naux);
#endif
/*
@ -2547,12 +2584,10 @@ static void pdb_convert_symbols_header( PDB_SYMBOLS *symbols,
}
}
static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
static int DEBUG_ProcessPDBFile( DBG_MODULE* module, const char *full_filename )
{
char filename[MAX_PATHNAME_LEN];
struct stat statbuf;
int fd = -1;
char *image = (char *) 0xffffffff;
HANDLE hFile, hMap;
char *image = NULL;
PDB_HEADER *pdb = NULL;
PDB_TOC *toc = NULL;
PDB_ROOT *root = NULL;
@ -2565,29 +2600,11 @@ static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
/*
* Open and mmap() .PDB file
* Open and map() .PDB file
*/
LocateDebugInfoFile( full_filename, filename );
if ( stat( filename, &statbuf ) == -1 )
{
fprintf( stderr, "-Unable to open .PDB file %s\n", filename );
goto leave;
}
fd = open(filename, O_RDONLY);
if ( fd == -1 )
{
fprintf( stderr, "-Unable to open .PDB file %s\n", filename );
goto leave;
}
image = mmap( 0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );
if ( image == (char *) 0xffffffff )
{
fprintf(stderr, "-Unable to mmap .PDB file %s\n", filename);
goto leave;
if ((image = DEBUG_MapDebugInfoFile(full_filename, 0, 0, &hFile, &hMap)) == NULL) {
DEBUG_Printf( DBG_CHN_ERR, "-Unable to peruse .PDB file %s\n", full_filename );
goto leave;
}
/*
@ -2615,7 +2632,7 @@ static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
case 19970604: /* VC 6.0 */
break;
default:
fprintf( stderr, "-Unknown root block version %ld\n", root->version );
DEBUG_Printf( DBG_CHN_ERR, "-Unknown root block version %ld\n", root->version );
}
switch ( types.version )
@ -2625,7 +2642,7 @@ static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
case 19961031: /* VC 5.0 / 6.0 */
break;
default:
fprintf( stderr, "-Unknown type info version %ld\n", types.version );
DEBUG_Printf( DBG_CHN_ERR, "-Unknown type info version %ld\n", types.version );
}
switch ( symbols.version )
@ -2635,7 +2652,7 @@ static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
case 19970606: /* VC 6.0 */
break;
default:
fprintf( stderr, "-Unknown symbol info version %ld\n", symbols.version );
DEBUG_Printf( DBG_CHN_ERR, "-Unknown symbol info version %ld\n", symbols.version );
}
@ -2646,7 +2663,7 @@ static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
if ( root->TimeDateStamp
!= ((struct CodeViewDebug *)MSC_INFO(module)->dbg_info)->cv_timestamp )
{
fprintf(stderr, "-Wrong time stamp of .PDB file %s\n", filename);
DEBUG_Printf(DBG_CHN_ERR, "-Wrong time stamp of .PDB file %s\n", full_filename);
goto leave;
}
@ -2663,7 +2680,7 @@ static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
if ( symbols.pdbimport_size )
{
/* FIXME */
fprintf(stderr, "-Type server .PDB imports ignored!\n" );
DEBUG_Printf(DBG_CHN_ERR, "-Type server .PDB imports ignored!\n" );
}
/*
@ -2738,8 +2755,7 @@ static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
if ( root ) pdb_free( root );
if ( toc ) pdb_free( toc );
if ( image != (char *) 0xffffffff ) munmap( image, statbuf.st_size );
if ( fd != -1 ) close( fd );
DEBUG_UnmapDebugInfoFile(hFile, hMap, image);
return TRUE;
}
@ -2750,61 +2766,33 @@ static int DEBUG_ProcessPDBFile( DBG_MODULE* module, char *full_filename )
*/
static
int
DEBUG_ProcessDBGFile(DBG_MODULE* module, char * filename)
DEBUG_ProcessDBGFile(DBG_MODULE* module, const char* filename)
{
char * addr = (char *) 0xffffffff;
HANDLE hFile, hMap;
char * addr;
char * codeview;
struct CV4_DirHead * codeview_dir;
struct CV4_DirEnt * codeview_dent;
PIMAGE_DEBUG_DIRECTORY dbghdr;
DBG_MODULE module2;
int fd = -1;
int i;
int j;
struct codeview_linetab_hdr * linetab;
int nsect;
PIMAGE_SEPARATE_DEBUG_HEADER pdbg = NULL;
IMAGE_SECTION_HEADER * sectp;
struct stat statbuf;
int status;
char dbg_file[MAX_PATHNAME_LEN];
LocateDebugInfoFile(filename, dbg_file);
status = stat(dbg_file, &statbuf);
if( status == -1 )
{
fprintf(stderr, "-Unable to open .DBG file %s\n", dbg_file);
goto leave;
}
/*
* Now open the file, so that we can mmap() it.
*/
fd = open(dbg_file, O_RDONLY);
if( fd == -1 )
{
fprintf(stderr, "Unable to open .DBG file %s\n", dbg_file);
goto leave;
}
/*
* Now mmap() the file.
*/
addr = mmap(0, statbuf.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
if( addr == (char *) 0xffffffff )
{
fprintf(stderr, "Unable to mmap .DBG file %s\n", dbg_file);
goto leave;
}
if ((addr = DEBUG_MapDebugInfoFile(filename, 0, 0, &hFile, &hMap)) == NULL) {
DEBUG_Printf(DBG_CHN_ERR, "-Unable to peruse .DBG file %s\n", filename);
goto leave;
}
pdbg = (PIMAGE_SEPARATE_DEBUG_HEADER) addr;
if( pdbg->TimeDateStamp != MSC_INFO(module)->dbgdir.TimeDateStamp )
{
fprintf(stderr, "Warning - %s has incorrect internal timestamp\n",
dbg_file);
DEBUG_Printf(DBG_CHN_ERR, "Warning - %s has incorrect internal timestamp\n",
filename);
/* goto leave; */
/*
Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
@ -2813,7 +2801,7 @@ DEBUG_ProcessDBGFile(DBG_MODULE* module, char * filename)
*/
}
fprintf(stderr, "Processing symbols from %s...\n", dbg_file);
DEBUG_Printf(DBG_CHN_MESG, "Processing symbols from %s...\n", filename);
dbghdr = (PIMAGE_DEBUG_DIRECTORY) ( addr + sizeof(*pdbg)
+ pdbg->NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
@ -2918,20 +2906,12 @@ DEBUG_ProcessDBGFile(DBG_MODULE* module, char * filename)
}
leave:
if( addr != (char *) 0xffffffff )
{
munmap(addr, statbuf.st_size);
}
if( fd != -1 )
{
close(fd);
}
DEBUG_UnmapDebugInfoFile(hFile, hMap, addr);
return TRUE;
}
int
static int
DEBUG_ProcessMSCDebugInfo(DBG_MODULE* module)
{
struct CodeViewDebug * cvd;
@ -2946,9 +2926,7 @@ DEBUG_ProcessMSCDebugInfo(DBG_MODULE* module)
* Standard COFF debug information that VC++ adds when you
* use /debugtype:both with the linker.
*/
#if 0
fprintf(stderr, "Processing COFF symbols...\n");
#endif
DEBUG_Printf(DBG_CHN_TRACE, "Processing COFF symbols...\n");
sts = DEBUG_ProcessCoff(module);
break;
case IMAGE_DEBUG_TYPE_CODEVIEW:
@ -2967,9 +2945,7 @@ DEBUG_ProcessMSCDebugInfo(DBG_MODULE* module)
break;
}
sts = DEBUG_ProcessPDBFile(module, cvd->cv_name);
#if 0
fprintf(stderr, "Processing PDB file %s\n", cvd->cv_name);
#endif
DEBUG_Printf(DBG_CHN_TRACE, "Processing PDB file %s\n", cvd->cv_name);
break;
case IMAGE_DEBUG_TYPE_MISC:
/*
@ -3007,6 +2983,7 @@ DEBUG_ProcessMSCDebugInfo(DBG_MODULE* module)
sts = FALSE;
break;
}
module->status = (sts) ? DM_STATUS_LOADED : DM_STATUS_ERROR;
return sts;
}

View File

@ -85,7 +85,7 @@ int DEBUG_PrintRegister(enum debug_regs reg)
case REG_FS: val = "%%fs"; break;
case REG_GS: val = "%%gs"; break;
}
if (val) fprintf(stderr, val);
if (val) DEBUG_Printf(DBG_CHN_MESG, val);
return TRUE;
#else
return FALSE;
@ -195,40 +195,40 @@ char *DEBUG_Flags( DWORD flag, char *buf )
*/
void DEBUG_InfoRegisters(void)
{
fprintf(stderr,"Register dump:\n");
DEBUG_Printf(DBG_CHN_MESG,"Register dump:\n");
#ifdef __i386__
/* First get the segment registers out of the way */
fprintf( stderr," CS:%04x SS:%04x DS:%04x ES:%04x FS:%04x GS:%04x",
(WORD)DEBUG_context.SegCs, (WORD)DEBUG_context.SegSs,
(WORD)DEBUG_context.SegDs, (WORD)DEBUG_context.SegEs,
(WORD)DEBUG_context.SegFs, (WORD)DEBUG_context.SegGs );
DEBUG_Printf( DBG_CHN_MESG," CS:%04x SS:%04x DS:%04x ES:%04x FS:%04x GS:%04x",
(WORD)DEBUG_context.SegCs, (WORD)DEBUG_context.SegSs,
(WORD)DEBUG_context.SegDs, (WORD)DEBUG_context.SegEs,
(WORD)DEBUG_context.SegFs, (WORD)DEBUG_context.SegGs );
if (DEBUG_CurrThread->dbg_mode == 16)
{
char flag[33];
fprintf( stderr,"\n IP:%04x SP:%04x BP:%04x FLAGS:%04x(%s)\n",
LOWORD(DEBUG_context.Eip), LOWORD(DEBUG_context.Esp),
LOWORD(DEBUG_context.Ebp), LOWORD(DEBUG_context.EFlags),
DEBUG_Flags(LOWORD(DEBUG_context.EFlags), flag));
fprintf( stderr," AX:%04x BX:%04x CX:%04x DX:%04x SI:%04x DI:%04x\n",
LOWORD(DEBUG_context.Eax), LOWORD(DEBUG_context.Ebx),
LOWORD(DEBUG_context.Ecx), LOWORD(DEBUG_context.Edx),
LOWORD(DEBUG_context.Esi), LOWORD(DEBUG_context.Edi) );
DEBUG_Printf( DBG_CHN_MESG,"\n IP:%04x SP:%04x BP:%04x FLAGS:%04x(%s)\n",
LOWORD(DEBUG_context.Eip), LOWORD(DEBUG_context.Esp),
LOWORD(DEBUG_context.Ebp), LOWORD(DEBUG_context.EFlags),
DEBUG_Flags(LOWORD(DEBUG_context.EFlags), flag));
DEBUG_Printf( DBG_CHN_MESG," AX:%04x BX:%04x CX:%04x DX:%04x SI:%04x DI:%04x\n",
LOWORD(DEBUG_context.Eax), LOWORD(DEBUG_context.Ebx),
LOWORD(DEBUG_context.Ecx), LOWORD(DEBUG_context.Edx),
LOWORD(DEBUG_context.Esi), LOWORD(DEBUG_context.Edi) );
}
else /* 32-bit mode */
{
char flag[33];
fprintf( stderr, "\n EIP:%08lx ESP:%08lx EBP:%08lx EFLAGS:%08lx(%s)\n",
DEBUG_context.Eip, DEBUG_context.Esp,
DEBUG_context.Ebp, DEBUG_context.EFlags,
DEBUG_Flags(DEBUG_context.EFlags, flag));
fprintf( stderr, " EAX:%08lx EBX:%08lx ECX:%08lx EDX:%08lx\n",
DEBUG_context.Eax, DEBUG_context.Ebx,
DEBUG_context.Ecx, DEBUG_context.Edx );
fprintf( stderr, " ESI:%08lx EDI:%08lx\n",
DEBUG_context.Esi, DEBUG_context.Edi );
DEBUG_Printf( DBG_CHN_MESG, "\n EIP:%08lx ESP:%08lx EBP:%08lx EFLAGS:%08lx(%s)\n",
DEBUG_context.Eip, DEBUG_context.Esp,
DEBUG_context.Ebp, DEBUG_context.EFlags,
DEBUG_Flags(DEBUG_context.EFlags, flag));
DEBUG_Printf( DBG_CHN_MESG, " EAX:%08lx EBX:%08lx ECX:%08lx EDX:%08lx\n",
DEBUG_context.Eax, DEBUG_context.Ebx,
DEBUG_context.Ecx, DEBUG_context.Edx );
DEBUG_Printf( DBG_CHN_MESG, " ESI:%08lx EDI:%08lx\n",
DEBUG_context.Esi, DEBUG_context.Edi );
}
#endif
}
@ -249,8 +249,8 @@ BOOL DEBUG_ValidateRegisters(void)
/* Check that a selector is a valid ring-3 LDT selector, or a NULL selector */
#define CHECK_SEG(seg,name) \
if (((seg) & ~3) && ((((seg) & 7) != 7) || !DEBUG_IsSelector(seg))) { \
fprintf( stderr, "*** Invalid value for %s register: %04x\n", \
(name), (WORD)(seg) ); \
DEBUG_Printf( DBG_CHN_MESG, "*** Invalid value for %s register: %04x\n", \
(name), (WORD)(seg) ); \
return FALSE; \
}
@ -268,14 +268,14 @@ BOOL DEBUG_ValidateRegisters(void)
if (!(DEBUG_context.SegCs & ~3))
{
fprintf( stderr, "*** Invalid value for CS register: %04x\n",
(WORD)DEBUG_context.SegCs );
DEBUG_Printf( DBG_CHN_MESG, "*** Invalid value for CS register: %04x\n",
(WORD)DEBUG_context.SegCs );
return FALSE;
}
if (!(DEBUG_context.SegSs & ~3))
{
fprintf( stderr, "*** Invalid value for SS register: %04x\n",
(WORD)DEBUG_context.SegSs );
DEBUG_Printf( DBG_CHN_MESG, "*** Invalid value for SS register: %04x\n",
(WORD)DEBUG_context.SegSs );
return FALSE;
}
return TRUE;

View File

@ -53,12 +53,12 @@ DEBUG_ShowDir(void)
{
struct searchlist * sl;
fprintf(stderr,"Search list :\n");
DEBUG_Printf(DBG_CHN_MESG,"Search list :\n");
for(sl = listhead; sl; sl = sl->next)
{
fprintf(stderr, "\t%s\n", sl->path);
DEBUG_Printf(DBG_CHN_MESG, "\t%s\n", sl->path);
}
fprintf(stderr, "\n");
DEBUG_Printf(DBG_CHN_MESG, "\n");
}
void
@ -186,7 +186,7 @@ DEBUG_DisplaySource(char * sourcefile, int start, int end)
/*
* Still couldn't find it. Ask user for path to add.
*/
fprintf(stderr,"Enter path to file %s: ", sourcefile);
DEBUG_Printf(DBG_CHN_MESG,"Enter path to file %s: ", sourcefile);
fgets(tmppath, sizeof(tmppath), stdin);
if( tmppath[strlen(tmppath)-1] == '\n' )
@ -217,7 +217,7 @@ DEBUG_DisplaySource(char * sourcefile, int start, int end)
ol->nlines = 0;
ol->linelist = NULL;
ofiles = ol;
fprintf(stderr,"Unable to open file %s\n", tmppath);
DEBUG_Printf(DBG_CHN_MESG,"Unable to open file %s\n", tmppath);
return FALSE;
}
}
@ -314,7 +314,7 @@ DEBUG_DisplaySource(char * sourcefile, int start, int end)
memcpy(&buffer, addr + ol->linelist[i],
(ol->linelist[i+1] - ol->linelist[i]) - 1);
}
fprintf(stderr,"%d\t%s\n", i + 1, buffer);
DEBUG_Printf(DBG_CHN_MESG,"%d\t%s\n", i + 1, buffer);
}
munmap(addr, ol->size);
@ -343,7 +343,7 @@ DEBUG_List(struct list_id * source1, struct list_id * source2,
&& source2->sourcefile != NULL
&& strcmp(source1->sourcefile, source2->sourcefile) != 0 )
{
fprintf(stderr, "Ambiguous source file specification.\n");
DEBUG_Printf(DBG_CHN_MESG, "Ambiguous source file specification.\n");
return;
}
@ -367,7 +367,7 @@ DEBUG_List(struct list_id * source1, struct list_id * source2,
if( sourcefile == NULL )
{
fprintf(stderr, "No source file specified.\n");
DEBUG_Printf(DBG_CHN_MESG, "No source file specified.\n");
return;
}
@ -430,10 +430,10 @@ _disassemble(DBG_ADDR *addr)
char ch;
DEBUG_PrintAddress( addr, DEBUG_CurrThread->dbg_mode, TRUE );
fprintf(stderr,": ");
DEBUG_Printf(DBG_CHN_MESG,": ");
if (!DEBUG_READ_MEM_VERBOSE((void*)DEBUG_ToLinear(addr), &ch, sizeof(ch))) return 0;
DEBUG_Disasm( addr, TRUE );
fprintf(stderr,"\n");
DEBUG_Printf(DBG_CHN_MESG,"\n");
return 1;
}
@ -469,7 +469,7 @@ _disassemble_fixaddr(DBG_VALUE *value) {
}
else if (!value->addr.seg && !value->addr.off)
{
fprintf(stderr,"Invalid expression\n");
DEBUG_Printf(DBG_CHN_MESG,"Invalid expression\n");
return;
}
}

View File

@ -4,6 +4,7 @@
* File stabs.c - read stabs information from the wine executable itself.
*
* Copyright (C) 1996, Eric Youngdale.
* 1999, 2000 Eric Pouech
*/
#include "config.h"
@ -23,7 +24,6 @@
#define PATH_MAX _MAX_PATH
#endif
#include "options.h"
#include "debugger.h"
#if defined(__svr4__) || defined(__sun)
@ -240,7 +240,7 @@ DEBUG_FileSubNr2StabEnum(int filenr, int subnr)
{
struct datatype** ret;
/* fprintf(stderr, "creating type id for (%d,%d)\n", filenr, subnr); */
/* DEBUG_Printf(DBG_CHN_MESG, "creating type id for (%d,%d)\n", filenr, subnr); */
/* FIXME: I could perhaps create a dummy include_def for each compilation
* unit which would allow not to handle those two cases separately
@ -271,7 +271,7 @@ DEBUG_FileSubNr2StabEnum(int filenr, int subnr)
}
ret = &idef->vector[subnr];
}
/* fprintf(stderr,"(%d,%d) is %d\n",filenr,subnr,ret); */
/* DEBUG_Printf(DBG_CHN_MESG,"(%d,%d) is %d\n",filenr,subnr,ret); */
return ret;
}
@ -403,7 +403,7 @@ DEBUG_HandlePreviousTypedef(const char * name, const char * stab)
expect = DT_FUNC;
break;
default:
fprintf(stderr, "Unknown type (%c).\n",ptr[1]);
DEBUG_Printf(DBG_CHN_MESG, "Unknown type (%c).\n",ptr[1]);
return FALSE;
}
if( expect != -1 && expect != DEBUG_GetType(ktd->types[count]) )
@ -491,7 +491,7 @@ DEBUG_ParseTypedefStab(char * ptr, const char * typename)
/*
* If this ever happens, just bump the counter.
*/
fprintf(stderr, "Typedef nesting overflow\n");
DEBUG_Printf(DBG_CHN_MESG, "Typedef nesting overflow\n");
return FALSE;
}
@ -535,7 +535,7 @@ DEBUG_ParseTypedefStab(char * ptr, const char * typename)
curr_types[ntypes++] = *dt;
break;
default:
fprintf(stderr, "Unknown type (%c).\n",c[1]);
DEBUG_Printf(DBG_CHN_MESG, "Unknown type (%c).\n",c[1]);
}
typename = NULL;
@ -594,7 +594,7 @@ DEBUG_ParseTypedefStab(char * ptr, const char * typename)
}
else
{
fprintf(stderr, "Unknown condition %p %p (%s)\n", *dt, *dt2, ptr);
DEBUG_Printf(DBG_CHN_MESG, "Unknown condition %p %p (%s)\n", *dt, *dt2, ptr);
}
if( *tc == '\0' )
*c = '\0';
@ -679,7 +679,7 @@ DEBUG_ParseTypedefStab(char * ptr, const char * typename)
{
failure = 1;
/* ... but proceed parsing to the end of the stab */
fprintf(stderr, "failure on %s %s\n", ptr, ti);
DEBUG_Printf(DBG_CHN_MESG, "failure on %s %s\n", ptr, ti);
}
}
@ -723,7 +723,7 @@ DEBUG_ParseTypedefStab(char * ptr, const char * typename)
strcpy(c, tc + 1);
break;
default:
fprintf(stderr, "Unknown type (%c).\n",c[1]);
DEBUG_Printf(DBG_CHN_MESG, "Unknown type (%c).\n",c[1]);
break;
}
}
@ -852,7 +852,7 @@ DEBUG_ParseStabs(char * addr, unsigned int load_offset,
* ignore them, and when we process the normal symbol table
* we should do the right thing.
*
* With a.out, they actually do make some amount of sense.
* With a.out or mingw, they actually do make some amount of sense.
*/
new_value.addr.seg = 0;
new_value.type = DEBUG_ParseStabType(ptr);
@ -862,7 +862,7 @@ DEBUG_ParseStabs(char * addr, unsigned int load_offset,
stab_strcpy(symname, ptr);
#ifdef __ELF__
curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath,
SYM_WINE | SYM_DATA | SYM_INVALID);
SYM_WINE | SYM_DATA | SYM_INVALID );
#else
curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath,
SYM_WINE | SYM_DATA );
@ -956,22 +956,30 @@ DEBUG_ParseStabs(char * addr, unsigned int load_offset,
* on, we will add the line number information and the
* local symbols.
*/
if( !in_external_file )
if( !in_external_file)
{
new_value.addr.seg = 0;
new_value.type = DEBUG_ParseStabType(ptr);
new_value.addr.off = load_offset + stab_ptr->n_value;
new_value.cookie = DV_TARGET;
/*
* Copy the string to a temp buffer so we
* can kill everything after the ':'. We do
* it this way because otherwise we end up dirtying
* all of the pages related to the stabs, and that
* sucks up swap space like crazy.
*/
stab_strcpy(symname, ptr);
curr_func = DEBUG_AddSymbol( symname, &new_value, currpath,
SYM_WINE | SYM_FUNC);
if (*symname)
{
new_value.addr.seg = 0;
new_value.type = DEBUG_ParseStabType(ptr);
new_value.addr.off = load_offset + stab_ptr->n_value;
new_value.cookie = DV_TARGET;
/*
* Copy the string to a temp buffer so we
* can kill everything after the ':'. We do
* it this way because otherwise we end up dirtying
* all of the pages related to the stabs, and that
* sucks up swap space like crazy.
*/
curr_func = DEBUG_AddSymbol( symname, &new_value, currpath,
SYM_WINE | SYM_FUNC);
}
else
{
/* some GCC seem to use a N_FUN "" to mark the end of a function */
curr_func = NULL;
}
}
else
{
@ -1054,16 +1062,16 @@ DEBUG_ParseStabs(char * addr, unsigned int load_offset,
*/
break;
default:
fprintf(stderr, "Unkown stab type 0x%02x\n", stab_ptr->n_type);
DEBUG_Printf(DBG_CHN_MESG, "Unkown stab type 0x%02x\n", stab_ptr->n_type);
break;
}
stabbuff[0] = '\0';
#if 0
fprintf(stderr, "%d %x %s\n", stab_ptr->n_type,
(unsigned int) stab_ptr->n_value,
strs + (unsigned int) stab_ptr->n_un.n_name);
DEBUG_Printf(DBG_CHN_MESG, "%d %x %s\n", stab_ptr->n_type,
(unsigned int) stab_ptr->n_value,
strs + (unsigned int) stab_ptr->n_un.n_name);
#endif
}
@ -1110,7 +1118,8 @@ DEBUG_ProcessElfSymtab(char * addr, unsigned int load_offset,
* Ignore certain types of entries which really aren't of that much
* interest.
*/
if( ELF32_ST_TYPE(symp->st_info) == STT_SECTION )
if( ELF32_ST_TYPE(symp->st_info) == STT_SECTION ||
symp->st_shndx == STN_UNDEF )
{
continue;
}
@ -1160,15 +1169,13 @@ DEBUG_ProcessElfSymtab(char * addr, unsigned int load_offset,
return TRUE;
}
static
int
DEBUG_ProcessElfObject(const char * filename, unsigned int load_offset)
{
int rtn = FALSE;
struct stat statbuf;
char * addr = (char*)0xffffffff;
int fd = -1;
int status;
char * addr = (char *) 0xffffffff;
struct stat statbuf;
Elf32_Ehdr * ehptr;
Elf32_Shdr * spnt;
char * shstrtab;
@ -1177,15 +1184,13 @@ DEBUG_ProcessElfObject(const char * filename, unsigned int load_offset)
int stabsect;
int stabstrsect;
/*
* Make sure we can stat and open this file.
*/
if( filename == NULL )
goto leave;
status = stat(filename, &statbuf);
if( status == -1 )
if (stat(filename, &statbuf) == -1)
{
char *s,*t,*fn,*paths;
if (strchr(filename,'/'))
@ -1207,25 +1212,28 @@ DEBUG_ProcessElfObject(const char * filename, unsigned int load_offset)
DBG_free(fn);
if (t) s = t+1; else break;
}
if (!s || !*s) fprintf(stderr," not found");
if (!s || !*s) DEBUG_Printf(DBG_CHN_MESG," not found");
DBG_free(paths);
goto leave;
}
if (DEBUG_FindModuleByName(filename, DM_TYPE_ELF))
goto leave;
DEBUG_Printf(DBG_CHN_MESG, "Loading stabs debug symbols from %s (0x%08lx)\n",
filename, load_offset);
/*
* Now open the file, so that we can mmap() it.
*/
fd = open(filename, O_RDONLY);
if( fd == -1 )
if ((fd = open(filename, O_RDONLY)) == -1)
goto leave;
/*
* Now mmap() the file.
*/
addr = mmap(0, statbuf.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
if( addr == (char *) 0xffffffff )
addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (addr == (char*)0xffffffff)
goto leave;
/*
@ -1255,20 +1263,22 @@ DEBUG_ProcessElfObject(const char * filename, unsigned int load_offset)
stabstrsect = i;
}
if( stabsect == -1 || stabstrsect == -1 )
goto leave;
if( stabsect == -1 || stabstrsect == -1 ) {
DEBUG_Printf(DBG_CHN_WARN, "no .stab section\n");
goto leave;
}
/*
* OK, now just parse all of the stabs.
*/
rtn = DEBUG_ParseStabs(addr, load_offset,
spnt[stabsect].sh_offset,
spnt[stabsect].sh_size,
spnt[stabstrsect].sh_offset,
spnt[stabstrsect].sh_size);
if( rtn != TRUE )
goto leave;
if (!(rtn = DEBUG_ParseStabs(addr, load_offset,
spnt[stabsect].sh_offset,
spnt[stabsect].sh_size,
spnt[stabstrsect].sh_offset,
spnt[stabstrsect].sh_size))) {
DEBUG_Printf(DBG_CHN_WARN, "bad stabs\n");
goto leave;
}
for(i=0; i < nsect; i++)
{
@ -1285,22 +1295,17 @@ DEBUG_ProcessElfObject(const char * filename, unsigned int load_offset)
leave:
if( addr != (char *) 0xffffffff )
munmap(addr, statbuf.st_size);
if (addr != (char*)0xffffffff)
munmap(addr, statbuf.st_size);
if( fd != -1 )
close(fd);
return (rtn);
if (fd != -1) close(fd);
return rtn;
}
int
DEBUG_ReadExecutableDbgInfo(void)
DEBUG_ReadExecutableDbgInfo(const char* exe_name)
{
const char * exe_name;
DBG_VALUE val;
u_long dyn_addr;
Elf32_Dyn dyn;
struct r_debug dbg_hdr;
u_long lm_addr;
@ -1308,9 +1313,7 @@ DEBUG_ReadExecutableDbgInfo(void)
Elf32_Ehdr ehdr;
char bufstr[256];
int rtn = FALSE;
int rowcount;
exe_name = argv0;
DBG_VALUE val;
/*
* Make sure we can stat and open this file.
@ -1319,19 +1322,20 @@ DEBUG_ReadExecutableDbgInfo(void)
goto leave;
fprintf( stderr, "Loading symbols: %s", exe_name );
rowcount = 17 + strlen(exe_name);
DEBUG_ProcessElfObject(exe_name, 0);
/* previous step should have loaded symbol _DYNAMIC if it exists inside
* the main executable
*/
if (!DEBUG_GetSymbolValue("_DYNAMIC", -1, &val, FALSE)) {
fprintf(stderr, "Can't find symbol _DYNAMIC\n");
goto leave;
}
dyn_addr = val.addr.off;
do {
if (!DEBUG_READ_MEM_VERBOSE((void*)dyn_addr, &dyn, sizeof(dyn)))
if (!DEBUG_READ_MEM_VERBOSE((void*)val.addr.off, &dyn, sizeof(dyn)))
goto leave;
dyn_addr += sizeof(dyn);
val.addr.off += sizeof(dyn);
} while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
if (dyn.d_tag == DT_NULL) goto leave;
@ -1351,124 +1355,34 @@ DEBUG_ReadExecutableDbgInfo(void)
{
if (!DEBUG_READ_MEM_VERBOSE((void*)lm_addr, &lm, sizeof(lm)))
goto leave;
if (!DEBUG_READ_MEM_VERBOSE((void*)lm.l_addr, &ehdr, sizeof(ehdr)))
continue;
/*
* We already got the stuff for the executable using the
* argv[0] entry above. Here we only need to concentrate on any
* shared libraries which may be loaded.
*/
if( (lm.l_addr == 0) || (ehdr.e_type != ET_DYN) )
continue;
if( lm.l_name != NULL )
{
if (!DEBUG_READ_MEM_VERBOSE(lm.l_name, bufstr, sizeof(bufstr)))
continue;
bufstr[sizeof(bufstr) - 1] = '\0';
if (rowcount + strlen(bufstr) > 76)
{
fprintf( stderr, "\n " );
rowcount = 3;
}
fprintf( stderr, " %s", bufstr );
rowcount += strlen(bufstr) + 1;
DEBUG_ProcessElfObject(bufstr, lm.l_addr);
if (lm.l_addr != 0 &&
DEBUG_READ_MEM_VERBOSE((void*)lm.l_addr, &ehdr, sizeof(ehdr)) &&
ehdr.e_type == ET_DYN && /* only look at dynamic modules */
lm.l_name != NULL &&
DEBUG_READ_MEM_VERBOSE(lm.l_name, bufstr, sizeof(bufstr))) {
bufstr[sizeof(bufstr) - 1] = '\0';
DEBUG_ProcessElfObject(bufstr, lm.l_addr);
}
}
rtn = TRUE;
leave:
fprintf( stderr, "\n" );
return (rtn);
return rtn;
}
#else /* !__ELF__ */
#ifdef linux
/*
* a.out linux.
*/
int
DEBUG_ProcessElfObject(const char * filename, unsigned int load_offset)
{
return FALSE;
}
int
DEBUG_ReadExecutableDbgInfo(void)
{
char * addr = (char *) 0xffffffff;
char * exe_name;
struct exec * ahdr;
int fd = -1;
int rtn = FALSE;
unsigned int staboff;
struct stat statbuf;
int status;
unsigned int stroff;
exe_name = argv0;
/*
* Make sure we can stat and open this file.
*/
if( exe_name == NULL )
goto leave;
status = stat(exe_name, &statbuf);
if( status == -1 )
goto leave;
/*
* Now open the file, so that we can mmap() it.
*/
fd = open(exe_name, O_RDONLY);
if( fd == -1 )
goto leave;
/*
* Now mmap() the file.
*/
addr = mmap(0, statbuf.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
if( addr == (char *) 0xffffffff )
goto leave;
ahdr = (struct exec *) addr;
staboff = N_SYMOFF(*ahdr);
stroff = N_STROFF(*ahdr);
rtn = DEBUG_ParseStabs(addr, 0,
staboff,
ahdr->a_syms,
stroff,
statbuf.st_size - stroff);
/*
* Give a nice status message here...
*/
fprintf( stderr, "Loading symbols: %s", exe_name );
rtn = TRUE;
leave:
if( addr != (char *) 0xffffffff )
munmap(addr, statbuf.st_size);
if( fd != -1 )
close(fd);
return (rtn);
return FALSE;
}
#else
/*
* Non-linux, non-ELF platforms.
*/
int
DEBUG_ReadExecutableDbgInfo(void)
{
return FALSE;
}
#endif
#endif /* __ELF__ */

View File

@ -64,7 +64,7 @@ void DEBUG_InfoStack(void)
value.addr.seg = DEBUG_context.SegSs;
value.addr.off = DEBUG_context.Esp;
fprintf(stderr,"Stack dump:\n");
DEBUG_Printf(DBG_CHN_MESG,"Stack dump:\n");
switch (DEBUG_GetSelectorType(value.addr.seg)) {
case 32: /* 32-bit mode */
DEBUG_ExamineMemory( &value, 24, 'x' );
@ -74,9 +74,9 @@ void DEBUG_InfoStack(void)
DEBUG_ExamineMemory( &value, 24, 'w' );
break;
default:
fprintf(stderr, "Bad segment (%ld)\n", value.addr.seg);
DEBUG_Printf(DBG_CHN_MESG, "Bad segment (%ld)\n", value.addr.seg);
}
fprintf(stderr,"\n");
DEBUG_Printf(DBG_CHN_MESG,"\n");
#endif
}
@ -87,7 +87,7 @@ static void DEBUG_ForceFrame(DBG_ADDR *stack, DBG_ADDR *code, int frameno, int b
frames = (struct bt_info *)DBG_realloc(frames,
nframe*sizeof(struct bt_info));
if (noisy)
fprintf(stderr,"%s%d ", (theframe == curr_frame ? "=>" : " "),
DEBUG_Printf(DBG_CHN_MESG,"%s%d ", (theframe == curr_frame ? "=>" : " "),
frameno);
frames[theframe].cs = code->seg;
frames[theframe].eip = code->off;
@ -101,7 +101,7 @@ static void DEBUG_ForceFrame(DBG_ADDR *stack, DBG_ADDR *code, int frameno, int b
frames[theframe].ss = stack->seg;
frames[theframe].ebp = stack->off;
if (noisy) {
fprintf( stderr, (bits == 16) ? " (bp=%04lx)\n" : " (ebp=%08lx)\n", stack->off );
DEBUG_Printf( DBG_CHN_MESG, (bits == 16) ? " (bp=%04lx)\n" : " (ebp=%08lx)\n", stack->off );
}
}
@ -115,11 +115,7 @@ static BOOL DEBUG_Frame16(DBG_ADDR *addr, unsigned int *cs, int frameno, int noi
if (!p) return FALSE;
if (!DEBUG_READ_MEM(p, &frame, sizeof(frame))) {
if (noisy) {
fprintf(stderr,"*** Invalid address ");
DEBUG_PrintAddress(addr, DEBUG_CurrThread->dbg_mode, FALSE);
fprintf(stderr,"\n");
}
if (noisy) DEBUG_InvalAddr(addr);
return FALSE;
}
if (!frame.bp) return FALSE;
@ -127,8 +123,8 @@ static BOOL DEBUG_Frame16(DBG_ADDR *addr, unsigned int *cs, int frameno, int noi
frames = (struct bt_info *)DBG_realloc(frames,
nframe*sizeof(struct bt_info));
if (noisy)
fprintf(stderr,"%s%d ", (theframe == curr_frame ? "=>" : " "),
frameno);
DEBUG_Printf(DBG_CHN_MESG,"%s%d ", (theframe == curr_frame ? "=>" : " "),
frameno);
if (frame.bp & 1) *cs = frame.cs;
else {
/* not explicitly marked as far call,
@ -156,11 +152,11 @@ static BOOL DEBUG_Frame16(DBG_ADDR *addr, unsigned int *cs, int frameno, int noi
frames[theframe].ss = addr->seg = ss;
frames[theframe].ebp = addr->off = frame.bp & ~1;
if (noisy) {
fprintf( stderr, " (bp=%04lx", addr->off );
DEBUG_Printf( DBG_CHN_MESG, " (bp=%04lx", addr->off );
if (possible_cs) {
fprintf( stderr, ", far call assumed" );
DEBUG_Printf( DBG_CHN_MESG, ", far call assumed" );
}
fprintf( stderr, ")\n" );
DEBUG_Printf( DBG_CHN_MESG, ")\n" );
}
return TRUE;
}
@ -175,11 +171,7 @@ static BOOL DEBUG_Frame32(DBG_ADDR *addr, unsigned int *cs, int frameno, int noi
if (!p) return FALSE;
if (!DEBUG_READ_MEM(p, &frame, sizeof(frame))) {
if (noisy) {
fprintf(stderr,"*** Invalid address ");
DEBUG_PrintAddress(addr, DEBUG_CurrThread->dbg_mode, FALSE);
fprintf(stderr,"\n");
}
if (noisy) DEBUG_InvalAddr(addr);
return FALSE;
}
if (!frame.ip) return FALSE;
@ -188,8 +180,8 @@ static BOOL DEBUG_Frame32(DBG_ADDR *addr, unsigned int *cs, int frameno, int noi
frames = (struct bt_info *)DBG_realloc(frames,
nframe*sizeof(struct bt_info));
if (noisy)
fprintf(stderr,"%s%d ", (theframe == curr_frame ? "=>" : " "),
frameno);
DEBUG_Printf(DBG_CHN_MESG,"%s%d ", (theframe == curr_frame ? "=>" : " "),
frameno);
frames[theframe].cs = addr->seg = *cs;
frames[theframe].eip = addr->off = frame.ip;
if (noisy)
@ -199,7 +191,7 @@ static BOOL DEBUG_Frame32(DBG_ADDR *addr, unsigned int *cs, int frameno, int noi
DEBUG_FindNearestSymbol( addr, TRUE,
&frames[theframe].frame.sym, frame.bp,
&frames[theframe].frame.list);
if (noisy) fprintf( stderr, " (ebp=%08lx)\n", frame.bp );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, " (ebp=%08lx)\n", frame.bp );
frames[theframe].ss = addr->seg = ss;
frames[theframe].ebp = frame.bp;
if (addr->off == frame.bp) return FALSE;
@ -226,13 +218,13 @@ void DEBUG_BackTrace(BOOL noisy)
STACK32FRAME frame32;
char ch;
if (noisy) fprintf( stderr, "Backtrace:\n" );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Backtrace:\n" );
nframe = 1;
if (frames) DBG_free( frames );
frames = (struct bt_info *) DBG_alloc( sizeof(struct bt_info) );
if (noisy)
fprintf(stderr,"%s%d ",(curr_frame == 0 ? "=>" : " "), frameno);
DEBUG_Printf(DBG_CHN_MESG,"%s%d ",(curr_frame == 0 ? "=>" : " "), frameno);
if (DEBUG_IsSelectorSystem(ss)) ss = 0;
if (DEBUG_IsSelectorSystem(cs)) cs = 0;
@ -250,7 +242,7 @@ void DEBUG_BackTrace(BOOL noisy)
&frames[0].frame.list);
frames[0].ss = addr.seg = ss;
frames[0].ebp = addr.off = DEBUG_context.Ebp;
if (noisy) fprintf( stderr, " (ebp=%08x)\n", frames[0].ebp );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, " (ebp=%08x)\n", frames[0].ebp );
is16 = FALSE;
break;
case 16:
@ -263,11 +255,11 @@ void DEBUG_BackTrace(BOOL noisy)
&frames[0].frame.list);
frames[0].ss = addr.seg = ss;
frames[0].ebp = addr.off = LOWORD(DEBUG_context.Ebp);
if (noisy) fprintf( stderr, " (bp=%04x)\n", frames[0].ebp );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, " (bp=%04x)\n", frames[0].ebp );
is16 = TRUE;
break;
default:
if (noisy) fprintf( stderr, "Bad segment '%u'\n", ss);
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Bad segment '%u'\n", ss);
return;
}
@ -276,14 +268,14 @@ void DEBUG_BackTrace(BOOL noisy)
*/
cur_switch = (DWORD)DEBUG_CurrThread->teb + OFFSET_OF(TEB, cur_stack);
if (!DEBUG_READ_MEM((void*)cur_switch, &next_switch, sizeof(next_switch))) {
if (noisy) fprintf( stderr, "Can't read TEB:cur_stack\n");
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Can't read TEB:cur_stack\n");
return;
}
if (is16) {
if (!DEBUG_READ_MEM((void*)next_switch, &frame32, sizeof(STACK32FRAME))) {
if (noisy) fprintf( stderr, "Bad stack frame %p\n",
(STACK32FRAME*)next_switch );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Bad stack frame %p\n",
(STACK32FRAME*)next_switch );
return;
}
cur_switch = (DWORD)frame32.frame16;
@ -295,7 +287,7 @@ void DEBUG_BackTrace(BOOL noisy)
p = DEBUG_ToLinear(&tmp);
if (!DEBUG_READ_MEM((void*)p, &frame16, sizeof(STACK16FRAME))) {
if (noisy) fprintf( stderr, "Bad stack frame %p\n", (STACK16FRAME*)p );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Bad stack frame %p\n", (STACK16FRAME*)p );
return;
}
cur_switch = (DWORD)frame16.frame32;
@ -315,7 +307,7 @@ void DEBUG_BackTrace(BOOL noisy)
if (is16) {
if (!DEBUG_READ_MEM((void*)next_switch, &frame32, sizeof(STACK32FRAME))) {
if (noisy) fprintf( stderr, "Bad stack frame %p\n", (STACK32FRAME*)next_switch );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Bad stack frame %p\n", (STACK32FRAME*)next_switch );
return;
}
@ -333,8 +325,8 @@ void DEBUG_BackTrace(BOOL noisy)
p = DEBUG_ToLinear(&tmp);
if (!DEBUG_READ_MEM((void*)p, &frame16, sizeof(STACK16FRAME))) {
if (noisy) fprintf( stderr, "Bad stack frame %p\n",
(STACK16FRAME*)p );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Bad stack frame %p\n",
(STACK16FRAME*)p );
return;
}
cur_switch = (DWORD)frame16.frame32;
@ -348,8 +340,8 @@ void DEBUG_BackTrace(BOOL noisy)
p = DEBUG_ToLinear(&tmp);
if (!DEBUG_READ_MEM((void*)p, &frame16, sizeof(STACK16FRAME))) {
if (noisy) fprintf( stderr, "Bad stack frame %p\n",
(STACK16FRAME*)p );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Bad stack frame %p\n",
(STACK16FRAME*)p );
return;
}
@ -363,8 +355,8 @@ void DEBUG_BackTrace(BOOL noisy)
next_switch = cur_switch;
if (!DEBUG_READ_MEM((void*)next_switch, &frame32, sizeof(STACK32FRAME))) {
if (noisy) fprintf( stderr, "Bad stack frame %p\n",
(STACK32FRAME*)next_switch );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "Bad stack frame %p\n",
(STACK32FRAME*)next_switch );
return;
}
cur_switch = (DWORD)frame32.frame16;
@ -383,7 +375,7 @@ void DEBUG_BackTrace(BOOL noisy)
: DEBUG_Frame32( &addr, &cs, ++frameno, noisy);
}
}
if (noisy) fprintf( stderr, "\n" );
if (noisy) DEBUG_Printf( DBG_CHN_MESG, "\n" );
#endif
}

View File

@ -794,7 +794,7 @@ DEBUG_Print( const DBG_VALUE *value, int count, char format, int level )
if (count != 1)
{
fprintf( stderr, "Count other than 1 is meaningless in 'print' command\n" );
DEBUG_Printf( DBG_CHN_MESG, "Count other than 1 is meaningless in 'print' command\n" );
return;
}
@ -802,8 +802,8 @@ DEBUG_Print( const DBG_VALUE *value, int count, char format, int level )
{
/* No type, just print the addr value */
if (value->addr.seg && (value->addr.seg != 0xffffffff))
DEBUG_nchar += fprintf( stderr, "0x%04lx: ", value->addr.seg );
DEBUG_nchar += fprintf( stderr, "0x%08lx", value->addr.off );
DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "0x%04lx: ", value->addr.seg );
DEBUG_nchar += DEBUG_Printf( DBG_CHN_MESG, "0x%08lx", value->addr.off );
goto leave;
}
@ -814,13 +814,13 @@ DEBUG_Print( const DBG_VALUE *value, int count, char format, int level )
if( DEBUG_nchar > DEBUG_maxchar )
{
fprintf(stderr, "...");
DEBUG_Printf(DBG_CHN_MESG, "...");
goto leave;
}
if( format == 'i' || format == 's' || format == 'w' || format == 'b' )
{
fprintf( stderr, "Format specifier '%c' is meaningless in 'print' command\n", format );
DEBUG_Printf( DBG_CHN_MESG, "Format specifier '%c' is meaningless in 'print' command\n", format );
format = '\0';
}
@ -833,24 +833,24 @@ DEBUG_Print( const DBG_VALUE *value, int count, char format, int level )
DEBUG_PrintBasic(value, 1, format);
break;
case DT_STRUCT:
DEBUG_nchar += fprintf(stderr, "{");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, "{");
for(m = value->type->un.structure.members; m; m = m->next)
{
val1 = *value;
DEBUG_FindStructElement(&val1, m->name, &xval);
DEBUG_nchar += fprintf(stderr, "%s=", m->name);
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, "%s=", m->name);
DEBUG_Print(&val1, 1, format, level + 1);
if( m->next != NULL )
{
DEBUG_nchar += fprintf(stderr, ", ");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, ", ");
}
if( DEBUG_nchar > DEBUG_maxchar )
{
fprintf(stderr, "...}");
DEBUG_Printf(DBG_CHN_MESG, "...}");
goto leave;
}
}
DEBUG_nchar += fprintf(stderr, "}");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, "}");
break;
case DT_ARRAY:
/*
@ -863,38 +863,38 @@ DEBUG_Print( const DBG_VALUE *value, int count, char format, int level )
* Special handling for character arrays.
*/
pnt = (char *) value->addr.off;
DEBUG_nchar += fprintf(stderr, "\"");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, "\"");
for( i=value->type->un.array.start; i < value->type->un.array.end; i++ )
{
fputc(*pnt++, stderr);
DEBUG_nchar++;
if( DEBUG_nchar > DEBUG_maxchar )
{
fprintf(stderr, "...\"");
DEBUG_Printf(DBG_CHN_MESG, "...\"");
goto leave;
}
}
DEBUG_nchar += fprintf(stderr, "\"");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, "\"");
break;
}
val1 = *value;
val1.type = value->type->un.array.basictype;
DEBUG_nchar += fprintf(stderr, "{");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, "{");
for( i=value->type->un.array.start; i <= value->type->un.array.end; i++ )
{
DEBUG_Print(&val1, 1, format, level + 1);
val1.addr.off += size;
if( i == value->type->un.array.end )
{
DEBUG_nchar += fprintf(stderr, "}");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, "}");
}
else
{
DEBUG_nchar += fprintf(stderr, ", ");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, ", ");
}
if( DEBUG_nchar > DEBUG_maxchar )
{
fprintf(stderr, "...}");
DEBUG_Printf(DBG_CHN_MESG, "...}");
goto leave;
}
}
@ -908,7 +908,7 @@ leave:
if( level == 0 )
{
DEBUG_nchar += fprintf(stderr, "\n");
DEBUG_nchar += DEBUG_Printf(DBG_CHN_MESG, "\n");
}
return;
}
@ -935,11 +935,11 @@ DEBUG_DumpTypes(void)
switch(dt->type)
{
case DT_BASIC:
fprintf(stderr, "0x%p - BASIC(%s)\n",
DEBUG_Printf(DBG_CHN_MESG, "0x%p - BASIC(%s)\n",
dt, name);
break;
case DT_POINTER:
fprintf(stderr, "0x%p - POINTER(%s)(%p)\n",
DEBUG_Printf(DBG_CHN_MESG, "0x%p - POINTER(%s)(%p)\n",
dt, name, dt->un.pointer.pointsto);
break;
case DT_STRUCT:
@ -954,27 +954,26 @@ DEBUG_DumpTypes(void)
nm++;
}
}
fprintf(stderr, "0x%p - STRUCT(%s) %d %d %s\n", dt, name,
dt->un.structure.size, nm, member_name);
DEBUG_Printf(DBG_CHN_MESG, "0x%p - STRUCT(%s) %d %d %s\n", dt, name,
dt->un.structure.size, nm, member_name);
break;
case DT_ARRAY:
fprintf(stderr, "0x%p - ARRAY(%s)(%p)\n",
dt, name, dt->un.array.basictype);
DEBUG_Printf(DBG_CHN_MESG, "0x%p - ARRAY(%s)(%p)\n",
dt, name, dt->un.array.basictype);
break;
case DT_ENUM:
fprintf(stderr, "0x%p - ENUM(%s)\n",
dt, name);
DEBUG_Printf(DBG_CHN_MESG, "0x%p - ENUM(%s)\n", dt, name);
break;
case DT_BITFIELD:
fprintf(stderr, "0x%p - BITFIELD(%s)\n", dt, name);
DEBUG_Printf(DBG_CHN_MESG, "0x%p - BITFIELD(%s)\n", dt, name);
break;
case DT_FUNC:
fprintf(stderr, "0x%p - FUNC(%s)(%p)\n",
dt, name, dt->un.funct.rettype);
DEBUG_Printf(DBG_CHN_MESG, "0x%p - FUNC(%s)(%p)\n",
dt, name, dt->un.funct.rettype);
break;
case DT_CONST:
case DT_TYPEDEF:
fprintf(stderr, "What???\n");
DEBUG_Printf(DBG_CHN_MESG, "What???\n");
break;
}
}
@ -1025,31 +1024,31 @@ DEBUG_PrintTypeCast(const struct datatype * dt)
switch(dt->type)
{
case DT_BASIC:
fprintf(stderr, "%s", name);
DEBUG_Printf(DBG_CHN_MESG, "%s", name);
break;
case DT_POINTER:
DEBUG_PrintTypeCast(dt->un.pointer.pointsto);
fprintf(stderr, "*");
DEBUG_Printf(DBG_CHN_MESG, "*");
break;
case DT_STRUCT:
fprintf(stderr, "struct %s", name);
DEBUG_Printf(DBG_CHN_MESG, "struct %s", name);
break;
case DT_ARRAY:
fprintf(stderr, "%s[]", name);
DEBUG_Printf(DBG_CHN_MESG, "%s[]", name);
break;
case DT_ENUM:
fprintf(stderr, "enum %s", name);
DEBUG_Printf(DBG_CHN_MESG, "enum %s", name);
break;
case DT_BITFIELD:
fprintf(stderr, "unsigned %s", name);
DEBUG_Printf(DBG_CHN_MESG, "unsigned %s", name);
break;
case DT_FUNC:
DEBUG_PrintTypeCast(dt->un.funct.rettype);
fprintf(stderr, "(*%s)()", name);
DEBUG_Printf(DBG_CHN_MESG, "(*%s)()", name);
break;
case DT_CONST:
case DT_TYPEDEF:
fprintf(stderr, "What???\n");
DEBUG_Printf(DBG_CHN_MESG, "What???\n");
break;
}
@ -1062,12 +1061,12 @@ int DEBUG_PrintType( const DBG_VALUE *value )
if (!value->type)
{
fprintf(stderr, "Unknown type\n");
DEBUG_Printf(DBG_CHN_MESG, "Unknown type\n");
return FALSE;
}
if (!DEBUG_PrintTypeCast(value->type))
return FALSE;
fprintf(stderr, "\n");
DEBUG_Printf(DBG_CHN_MESG, "\n");
return TRUE;
}

View File

@ -7,7 +7,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include <string.h>
#include "debugger.h"
#include "thread.h"
@ -16,21 +16,39 @@
#include "winuser.h"
#include "winreg.h"
#include "debugtools.h"
#include "options.h"
#ifdef DBG_need_heap
HANDLE dbg_heap = 0;
#endif
DEFAULT_DEBUG_CHANNEL(winedbg);
DBG_PROCESS* DEBUG_CurrProcess = NULL;
DBG_THREAD* DEBUG_CurrThread = NULL;
CONTEXT DEBUG_context;
static DBG_PROCESS* proc = NULL;
static BOOL bBreakAllThreads = FALSE;
/* build internal vars table */
#define INTERNAL_VAR(_var,_val) int DBG_IVAR(_var) = _val;
#include "intvar.h"
#undef INTERNAL_VAR
int DEBUG_Printf(int chn, const char* format, ...)
{
char buf[1024];
va_list valist;
va_start(valist, format);
vsprintf(buf, format, valist);
va_end(valist);
#if 0
if (DBG_IVAR(ChannelMask) & chn)
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), NULL, NULL);
if (chn == DBG_CHN_MESG) fwrite(buf, strlen(buf), 1, stderr);
#else
if (DBG_IVAR(ChannelMask) & chn) fwrite(buf, strlen(buf), 1, stderr);
#endif
return strlen(buf);
}
static BOOL DEBUG_Init(void)
{
@ -39,10 +57,12 @@ static BOOL DEBUG_Init(void)
DWORD val;
DWORD count = sizeof(val);
if (!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey)) {
if (!RegQueryValueExA(hkey, "BreakAllThreadsStartup", 0, &type, (LPSTR)&val, &count)) {
bBreakAllThreads = val;
}
if (!RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey)) {
#define INTERNAL_VAR(_var,_val) \
if (!RegQueryValueEx(hkey, #_var, 0, &type, (LPSTR)&val, &count)) \
DBG_IVAR(_var) = val;
#include "intvar.h"
#undef INTERNAL_VAR
RegCloseKey(hkey);
}
return TRUE;
@ -51,7 +71,7 @@ static BOOL DEBUG_Init(void)
static WINE_EXCEPTION_FILTER(wine_dbg)
{
DEBUG_ExternalDebugger();
fprintf(stderr, "\nwine_dbg: Exception %lx\n", GetExceptionCode());
DEBUG_Printf(DBG_CHN_MESG, "\nwine_dbg: Exception %lx\n", GetExceptionCode());
return EXCEPTION_EXECUTE_HANDLER;
}
@ -88,7 +108,7 @@ static void DEBUG_DelThread(DBG_THREAD* p);
static void DEBUG_DelProcess(DBG_PROCESS* p)
{
if (p->threads != NULL) {
ERR("Shouldn't happen\n");
DEBUG_Printf(DBG_CHN_ERR, "Shouldn't happen\n");
while (p->threads) DEBUG_DelThread(p->threads);
}
if (p->prev) p->prev->next = p->next;
@ -111,41 +131,6 @@ static void DEBUG_InitCurrProcess(void)
*/
DEBUG_InitTypes();
DEBUG_InitCVDataTypes();
/*
* In some cases we can read the stabs information directly
* from the executable. If this is the case, we don't need
* to bother with trying to read a symbol file, as the stabs
* also have line number and local variable information.
* As long as gcc is used for the compiler, stabs will
* be the default. On SVr4, DWARF could be used, but we
* don't grok that yet, and in this case we fall back to using
* the wine.sym file.
*/
if( DEBUG_ReadExecutableDbgInfo() == FALSE )
{
char* symfilename = "wine.sym";
struct stat statbuf;
HKEY hWineConf, hkey;
DWORD count;
char symbolTableFile[256];
if (-1 == stat(symfilename, &statbuf) )
symfilename = LIBDIR "wine.sym";
strcpy(symbolTableFile, symfilename);
if (!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config", &hWineConf)) {
if (!RegOpenKeyA(hWineConf, "wine", &hkey)) {
count = sizeof(symbolTableFile);
RegQueryValueA(hkey, "SymbolTableFile", symbolTableFile, &count);
RegCloseKey(hkey);
}
RegCloseKey(hWineConf);
}
DEBUG_ReadSymbolTable(symbolTableFile);
}
DEBUG_LoadEntryPoints(NULL);
DEBUG_ProcessDeferredDebug();
}
static BOOL DEBUG_ProcessGetString(char* buffer, int size, HANDLE hp, LPSTR addr)
@ -206,10 +191,9 @@ static DBG_THREAD* DEBUG_AddThread(DBG_PROCESS* p, DWORD tid,
static void DEBUG_InitCurrThread(void)
{
if (!Options.debug) return;
if (DEBUG_CurrThread->start) {
if (DEBUG_CurrThread->process->num_threads == 1 || bBreakAllThreads) {
if (DEBUG_CurrThread->process->num_threads == 1 ||
DBG_IVAR(BreakAllThreadsStartup)) {
DBG_VALUE value;
DEBUG_SetBreakpoints(FALSE);
@ -239,7 +223,9 @@ static BOOL DEBUG_HandleException( EXCEPTION_RECORD *rec, BOOL first_chance, BOO
BOOL is_debug = FALSE;
BOOL ret;
if (first_chance && !Options.debug && !force ) return 0; /* pass to app first */
/* FIXME: need for a configuration var ? */
/* pass to app first ??? */
/* if (first_chance && !force) return 0; */
switch (rec->ExceptionCode)
{
@ -247,83 +233,80 @@ static BOOL DEBUG_HandleException( EXCEPTION_RECORD *rec, BOOL first_chance, BOO
case EXCEPTION_SINGLE_STEP:
is_debug = TRUE;
break;
case CONTROL_C_EXIT:
if (!Options.debug) DEBUG_Exit(0);
break;
}
if (!is_debug)
{
/* print some infos */
fprintf( stderr, "%s: ",
first_chance ? "First chance exception" : "Unhandled exception" );
DEBUG_Printf( DBG_CHN_MESG, "%s: ",
first_chance ? "First chance exception" : "Unhandled exception" );
switch(rec->ExceptionCode)
{
case EXCEPTION_INT_DIVIDE_BY_ZERO:
fprintf( stderr, "divide by zero" );
DEBUG_Printf( DBG_CHN_MESG, "divide by zero" );
break;
case EXCEPTION_INT_OVERFLOW:
fprintf( stderr, "overflow" );
DEBUG_Printf( DBG_CHN_MESG, "overflow" );
break;
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
fprintf( stderr, "array bounds " );
DEBUG_Printf( DBG_CHN_MESG, "array bounds " );
break;
case EXCEPTION_ILLEGAL_INSTRUCTION:
fprintf( stderr, "illegal instruction" );
DEBUG_Printf( DBG_CHN_MESG, "illegal instruction" );
break;
case EXCEPTION_STACK_OVERFLOW:
fprintf( stderr, "stack overflow" );
DEBUG_Printf( DBG_CHN_MESG, "stack overflow" );
break;
case EXCEPTION_PRIV_INSTRUCTION:
fprintf( stderr, "priviledged instruction" );
DEBUG_Printf( DBG_CHN_MESG, "priviledged instruction" );
break;
case EXCEPTION_ACCESS_VIOLATION:
if (rec->NumberParameters == 2)
fprintf( stderr, "page fault on %s access to 0x%08lx",
rec->ExceptionInformation[0] ? "write" : "read",
rec->ExceptionInformation[1] );
DEBUG_Printf( DBG_CHN_MESG, "page fault on %s access to 0x%08lx",
rec->ExceptionInformation[0] ? "write" : "read",
rec->ExceptionInformation[1] );
else
fprintf( stderr, "page fault" );
DEBUG_Printf( DBG_CHN_MESG, "page fault" );
break;
case EXCEPTION_DATATYPE_MISALIGNMENT:
fprintf( stderr, "Alignment" );
DEBUG_Printf( DBG_CHN_MESG, "Alignment" );
break;
case CONTROL_C_EXIT:
fprintf( stderr, "^C" );
DEBUG_Printf( DBG_CHN_MESG, "^C" );
break;
case EXCEPTION_CRITICAL_SECTION_WAIT:
fprintf( stderr, "critical section %08lx wait failed",
rec->ExceptionInformation[0] );
DEBUG_Printf( DBG_CHN_MESG, "critical section %08lx wait failed",
rec->ExceptionInformation[0] );
break;
default:
fprintf( stderr, "%08lx", rec->ExceptionCode );
DEBUG_Printf( DBG_CHN_MESG, "%08lx", rec->ExceptionCode );
break;
}
}
#if 1
fprintf(stderr, "Entering debugger PC=%lx EFL=%08lx mode=%d count=%d\n",
DEBUG_context.Eip, DEBUG_context.EFlags,
DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
#endif
DEBUG_Printf(DBG_CHN_TRACE,
"Entering debugger PC=%lx EFL=%08lx mode=%d count=%d\n",
DEBUG_context.Eip, DEBUG_context.EFlags,
DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
ret = DEBUG_Main( is_debug, force, rec->ExceptionCode );
#if 1
fprintf(stderr, "Exiting debugger PC=%lx EFL=%08lx mode=%d count=%d\n",
DEBUG_context.Eip, DEBUG_context.EFlags,
DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
#endif
DEBUG_Printf(DBG_CHN_TRACE,
"Exiting debugger PC=%lx EFL=%08lx mode=%d count=%d\n",
DEBUG_context.Eip, DEBUG_context.EFlags,
DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
return ret;
}
static DWORD DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
static BOOL DEBUG_HandleDebugEvent(DEBUG_EVENT* de, LPDWORD cont)
{
char buffer[256];
DWORD cont;
BOOL ret;
__TRY {
cont = 0L;
ret = TRUE;
*cont = 0L;
if ((DEBUG_CurrProcess = DEBUG_GetProcess(de->dwProcessId)) != NULL)
DEBUG_CurrThread = DEBUG_GetThread(DEBUG_CurrProcess, de->dwThreadId);
@ -332,45 +315,47 @@ static DWORD DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
switch (de->dwDebugEventCode) {
case EXCEPTION_DEBUG_EVENT:
if (!DEBUG_CurrThread) break;
if (!DEBUG_CurrThread) {
DEBUG_Printf(DBG_CHN_ERR, "%08lx:%08lx: not a registered process or thread (perhaps a 16 bit one ?)\n",
de->dwProcessId, de->dwThreadId);
break;
}
TRACE("%08lx:%08lx: exception code=%08lx %d\n",
de->dwProcessId, de->dwThreadId,
de->u.Exception.ExceptionRecord.ExceptionCode,
DEBUG_CurrThread->wait_for_first_exception);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exception code=%08lx %d\n",
de->dwProcessId, de->dwThreadId,
de->u.Exception.ExceptionRecord.ExceptionCode,
DEBUG_CurrThread->wait_for_first_exception);
DEBUG_context.ContextFlags = CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS|CONTEXT_DEBUG_REGISTERS;
if (!GetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context)) {
WARN("Can't get thread's context\n");
DEBUG_Printf(DBG_CHN_WARN, "Can't get thread's context\n");
break;
}
TRACE("%p:%p\n", de->u.Exception.ExceptionRecord.ExceptionAddress,
(void*)DEBUG_context.Eip);
DEBUG_Printf(DBG_CHN_TRACE, "%p:%p\n", de->u.Exception.ExceptionRecord.ExceptionAddress,
(void*)DEBUG_context.Eip);
cont = DEBUG_HandleException(&de->u.Exception.ExceptionRecord,
de->u.Exception.dwFirstChance,
DEBUG_CurrThread->wait_for_first_exception);
if (DEBUG_CurrThread->wait_for_first_exception) {
*cont = DEBUG_HandleException(&de->u.Exception.ExceptionRecord,
de->u.Exception.dwFirstChance,
DEBUG_CurrThread->wait_for_first_exception);
if (DEBUG_CurrThread->dbg_exec_mode == EXEC_KILL) {
ret = FALSE;
} else {
DEBUG_CurrThread->wait_for_first_exception = 0;
#ifdef __i386__
DEBUG_context.Eip--;
#endif
SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
}
SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
break;
case CREATE_THREAD_DEBUG_EVENT:
TRACE("%08lx:%08lx: create thread D @%p\n", de->dwProcessId, de->dwThreadId,
de->u.CreateThread.lpStartAddress);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create thread D @%p\n", de->dwProcessId, de->dwThreadId,
de->u.CreateThread.lpStartAddress);
if (DEBUG_CurrProcess == NULL) {
ERR("Unknown process\n");
DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
break;
}
if (DEBUG_GetThread(DEBUG_CurrProcess, de->dwThreadId) != NULL) {
TRACE("Thread already listed, skipping\n");
DEBUG_Printf(DBG_CHN_TRACE, "Thread already listed, skipping\n");
break;
}
@ -380,7 +365,7 @@ static DWORD DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
de->u.CreateThread.lpStartAddress,
de->u.CreateThread.lpThreadLocalBase);
if (!DEBUG_CurrThread) {
ERR("Couldn't create thread\n");
DEBUG_Printf(DBG_CHN_ERR, "Couldn't create thread\n");
break;
}
DEBUG_InitCurrThread();
@ -389,27 +374,30 @@ static DWORD DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
case CREATE_PROCESS_DEBUG_EVENT:
DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
de->u.CreateProcessInfo.hProcess,
de->u.LoadDll.lpImageName);
de->u.CreateProcessInfo.lpImageName);
/* FIXME unicode ? de->u.CreateProcessInfo.fUnicode */
TRACE("%08lx:%08lx: create process %s @%p\n",
de->dwProcessId, de->dwThreadId,
buffer,
de->u.CreateProcessInfo.lpStartAddress);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create process %s @%p (%ld<%ld>)\n",
de->dwProcessId, de->dwThreadId,
buffer,
de->u.CreateProcessInfo.lpStartAddress,
de->u.CreateProcessInfo.dwDebugInfoFileOffset,
de->u.CreateProcessInfo.nDebugInfoSize);
if (DEBUG_GetProcess(de->dwProcessId) != NULL) {
TRACE("Skipping already defined process\n");
DEBUG_Printf(DBG_CHN_TRACE, "Skipping already defined process\n");
break;
}
DEBUG_CurrProcess = DEBUG_AddProcess(de->dwProcessId,
de->u.CreateProcessInfo.hProcess);
if (DEBUG_CurrProcess == NULL) {
ERR("Unknown process\n");
DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
break;
}
TRACE("%08lx:%08lx: create thread I @%p\n", de->dwProcessId, de->dwThreadId,
de->u.CreateProcessInfo.lpStartAddress);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create thread I @%p\n",
de->dwProcessId, de->dwThreadId,
de->u.CreateProcessInfo.lpStartAddress);
DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess,
de->dwThreadId,
@ -417,25 +405,23 @@ static DWORD DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
de->u.CreateProcessInfo.lpStartAddress,
de->u.CreateProcessInfo.lpThreadLocalBase);
if (!DEBUG_CurrThread) {
ERR("Couldn't create thread\n");
DEBUG_Printf(DBG_CHN_ERR, "Couldn't create thread\n");
break;
}
DEBUG_InitCurrProcess();
DEBUG_InitCurrThread();
#ifdef _WE_SUPPORT_THE_STAB_TYPES_USED_BY_MINGW_TOO
/* so far, process name is not set */
DEBUG_RegisterDebugInfo((DWORD)de->u.CreateProcessInfo.lpBaseOfImage,
"wine-exec");
#endif
DEBUG_LoadModule32("<Debugged process>", de->u.CreateProcessInfo.hFile,
(DWORD)de->u.CreateProcessInfo.lpBaseOfImage);
break;
case EXIT_THREAD_DEBUG_EVENT:
TRACE("%08lx:%08lx: exit thread (%ld)\n",
de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exit thread (%ld)\n",
de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
if (DEBUG_CurrThread == NULL) {
ERR("Unknown thread\n");
DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
break;
}
/* FIXME: remove break point set on thread startup */
@ -443,22 +429,24 @@ static DWORD DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
break;
case EXIT_PROCESS_DEBUG_EVENT:
TRACE("%08lx:%08lx: exit process (%ld)\n",
de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exit process (%ld)\n",
de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
if (DEBUG_CurrProcess == NULL) {
ERR("Unknown process\n");
DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
break;
}
/* just in case */
DEBUG_SetBreakpoints(FALSE);
/* kill last thread */
DEBUG_DelThread(DEBUG_CurrProcess->threads);
/* FIXME: remove break point set on thread startup */
DEBUG_DelProcess(DEBUG_CurrProcess);
ret = FALSE;
break;
case LOAD_DLL_DEBUG_EVENT:
if (DEBUG_CurrThread == NULL) {
ERR("Unknown thread\n");
DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
break;
}
DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
@ -466,20 +454,23 @@ static DWORD DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
de->u.LoadDll.lpImageName);
/* FIXME unicode: de->u.LoadDll.fUnicode */
TRACE("%08lx:%08lx: loads DLL %s @%p\n", de->dwProcessId, de->dwThreadId,
buffer, de->u.LoadDll.lpBaseOfDll);
CharUpperA(buffer);
DEBUG_LoadModule32( buffer, (DWORD)de->u.LoadDll.lpBaseOfDll);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: loads DLL %s @%p (%ld<%ld>)\n",
de->dwProcessId, de->dwThreadId,
buffer, de->u.LoadDll.lpBaseOfDll,
de->u.LoadDll.dwDebugInfoFileOffset,
de->u.LoadDll.nDebugInfoSize);
CharUpper(buffer);
DEBUG_LoadModule32(buffer, de->u.LoadDll.hFile, (DWORD)de->u.LoadDll.lpBaseOfDll);
break;
case UNLOAD_DLL_DEBUG_EVENT:
TRACE("%08lx:%08lx: unload DLL @%p\n", de->dwProcessId, de->dwThreadId,
de->u.UnloadDll.lpBaseOfDll);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: unload DLL @%p\n", de->dwProcessId, de->dwThreadId,
de->u.UnloadDll.lpBaseOfDll);
break;
case OUTPUT_DEBUG_STRING_EVENT:
if (DEBUG_CurrThread == NULL) {
ERR("Unknown thread\n");
DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
break;
}
@ -488,111 +479,119 @@ static DWORD DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
de->u.DebugString.lpDebugStringData);
/* fixme unicode de->u.DebugString.fUnicode ? */
TRACE("%08lx:%08lx: output debug string (%s)\n",
de->dwProcessId, de->dwThreadId,
buffer);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: output debug string (%s)\n",
de->dwProcessId, de->dwThreadId, buffer);
break;
case RIP_EVENT:
TRACE("%08lx:%08lx: rip error=%ld type=%ld\n",
de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
de->u.RipInfo.dwType);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: rip error=%ld type=%ld\n",
de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
de->u.RipInfo.dwType);
break;
default:
TRACE("%08lx:%08lx: unknown event (%ld)\n",
de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: unknown event (%ld)\n",
de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
}
} __EXCEPT(wine_dbg) {
cont = 0;
*cont = 0;
ret = TRUE;
}
__ENDTRY;
return cont;
return ret;
}
static DWORD CALLBACK DEBUG_MainLoop(DWORD pid)
{
DEBUG_EVENT de;
DWORD cont;
BOOL ret = TRUE;
DEBUG_Printf(DBG_CHN_MESG, " on pid %ld\n", pid);
DEBUG_Init();
while (WaitForDebugEvent(&de, INFINITE)) {
cont = DEBUG_HandleDebugEvent(&de);
while (ret && WaitForDebugEvent(&de, INFINITE)) {
ret = DEBUG_HandleDebugEvent(&de, &cont);
ContinueDebugEvent(de.dwProcessId, de.dwThreadId, cont);
}
TRACE("WineDbg terminated on pid %ld\n", pid);
DEBUG_Printf(DBG_CHN_MESG, "WineDbg terminated on pid %ld\n", pid);
return 0L;
ExitProcess(0);
}
static DWORD CALLBACK DEBUG_StarterFromPID(LPVOID pid)
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE prev, LPSTR _cmdline, int show)
{
TRACE("WineDbg started on pid %ld\n", (DWORD)pid);
char* argv[5];
char* cmdline = strdup(_cmdline);
char* ptr = cmdline;
int instr = FALSE;
int argc = 0;
if (!DebugActiveProcess((DWORD)pid)) {
TRACE("Can't debug process %ld: %ld\n", (DWORD)pid, GetLastError());
return 0;
while ((*ptr == ' ' || *ptr == '\t') && *ptr != 0) ptr++;
argv[argc++] = ptr;
for (; *ptr; ptr++) {
if ((*ptr == ' ' || *ptr == '\t') && !instr) {
*ptr++ = 0;
while (*ptr == ' ' || *ptr == '\t') ptr++;
if (*ptr) argv[argc++] = ptr;
if (argc >= sizeof(argv) / sizeof(argv[0])) return 0;
} else if (*ptr == '"') {
instr = !instr;
}
}
return DEBUG_MainLoop((DWORD)pid);
}
void DEBUG_Attach(DWORD pid)
{
CreateThread(NULL, 0, DEBUG_StarterFromPID, (LPVOID)pid, 0, NULL);
}
#if 0
/* would require to change .spec with a cuiexe type */
/* keep it as a guiexe for now, so that Wine won't touch the Unix stdin,
* stdout and stderr streams
*/
if (1 /*DBG_IVAR(UseXterm)*/) {
COORD pos;
struct dsfcl {
HANDLE hEvent;
LPSTR lpCmdLine;
int showWindow;
DWORD error;
};
static DWORD CALLBACK DEBUG_StarterFromCmdLine(LPVOID p)
{
PROCESS_INFORMATION info;
STARTUPINFOA startup;
BOOL ok = TRUE;
memset(&startup, 0, sizeof(startup));
startup.cb = sizeof(startup);
startup.dwFlags = STARTF_USESHOWWINDOW;
startup.wShowWindow = ((struct dsfcl*)p)->showWindow;
/* any value >= 32 will do, simulate a correct handle value */
((struct dsfcl*)p)->error = 0xFFFFFFFF;
if (!CreateProcessA(NULL, ((struct dsfcl*)p)->lpCmdLine, NULL, NULL,
FALSE, DEBUG_PROCESS, NULL, NULL, &startup, &info)) {
((struct dsfcl*)p)->error = GetLastError();
ok = FALSE;
/* This is a hack: it forces creation of an xterm, not done by default */
pos.x = 0; pos.y = 1;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}
SetEvent(((struct dsfcl*)p)->hEvent);
if (ok) DEBUG_MainLoop(info.dwProcessId);
#endif
DEBUG_Printf(DBG_CHN_MESG, "Starting WineDbg... ");
if (argc == 2) {
DWORD pid = atoi(argv[0]);
HANDLE hEvent = atoi(argv[1]);
if (pid != 0 && hEvent != 0) {
free(cmdline);
if (!DebugActiveProcess(pid)) {
DEBUG_Printf(DBG_CHN_ERR, "Can't attach process %ld: %ld\n",
pid, GetLastError());
return 0;
}
SetEvent(hEvent);
return DEBUG_MainLoop(pid);
}
}
do {
PROCESS_INFORMATION info;
STARTUPINFOA startup;
free(cmdline);
memset(&startup, 0, sizeof(startup));
startup.cb = sizeof(startup);
startup.dwFlags = STARTF_USESHOWWINDOW;
startup.wShowWindow = SW_SHOWNORMAL;
if (CreateProcess(NULL, _cmdline, NULL, NULL,
FALSE, DEBUG_PROCESS, NULL, NULL, &startup, &info)) {
return DEBUG_MainLoop(info.dwProcessId);
}
DEBUG_Printf(DBG_CHN_MESG, "Couldn't start process '%s'\n", _cmdline);
} while (0);
return 0;
}
DWORD DEBUG_WinExec(LPSTR lpCmdLine, int sw)
{
struct dsfcl s;
BOOL ret;
if ((s.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL))) {
s.lpCmdLine = lpCmdLine;
s.showWindow = sw;
if (CreateThread(NULL, 0, DEBUG_StarterFromCmdLine, (LPVOID)&s, 0, NULL)) {
WaitForSingleObject(s.hEvent, INFINITE);
ret = s.error;
} else {
ret = 3; /* (dummy) error value for non created thread */
}
CloseHandle(s.hEvent);
} else {
ret = 1; /* (dummy) error value for non created event */
}
return ret;
}

5
debugger/winedbg.spec Normal file
View File

@ -0,0 +1,5 @@
name winedbg
mode guiexe
type win32
init WinMain

View File

@ -96,15 +96,15 @@ static inline void WINE_UNUSED stack16_pop( int size )
/* Push a DWORD on the 32-bit stack */
static inline void WINE_UNUSED stack32_push( CONTEXT86 *context, DWORD val )
{
ESP_reg(context) -= sizeof(DWORD);
*(DWORD *)ESP_reg(context) = val;
context->Esp -= sizeof(DWORD);
*(DWORD *)context->Esp = val;
}
/* Pop a DWORD from the 32-bit stack */
static inline DWORD WINE_UNUSED stack32_pop( CONTEXT86 *context )
{
DWORD ret = *(DWORD *)ESP_reg(context);
ESP_reg(context) += sizeof(DWORD);
DWORD ret = *(DWORD *)context->Esp;
context->Esp += sizeof(DWORD);
return ret;
}