diff --git a/Makefile.in b/Makefile.in index 998bf5c7737..ef9332f8607 100644 --- a/Makefile.in +++ b/Makefile.in @@ -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 diff --git a/debugger/.cvsignore b/debugger/.cvsignore index 8e7a16238bc..7f47d23c1dd 100644 --- a/debugger/.cvsignore +++ b/debugger/.cvsignore @@ -1,4 +1,6 @@ Makefile lex.yy.c +winedbg +winedbg.spec.c y.tab.c y.tab.h diff --git a/debugger/Makefile.in b/debugger/Makefile.in index df5677b9288..a6d15b98475 100644 --- a/debugger/Makefile.in +++ b/debugger/Makefile.in @@ -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: diff --git a/debugger/break.c b/debugger/break.c index f38cb2f33df..616dbc85f42 100644 --- a/debugger/break.c +++ b/debugger/break.c @@ -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; } diff --git a/debugger/db_disasm.c b/debugger/db_disasm.c index 9f1a0be3239..1a2e9e89269 100644 --- a/debugger/db_disasm.c +++ b/debugger/db_disasm.c @@ -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<ss); - fprintf(stderr,")"); + DEBUG_Printf(DBG_CHN_MESG,",%s,%d", addrp->index, 1<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,""); + DEBUG_Printf(DBG_CHN_MESG,""); 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; diff --git a/debugger/dbg.y b/debugger/dbg.y index 1ed882bee30..913e1d4f797 100644 --- a/debugger/dbg.y +++ b/debugger/dbg.y @@ -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; } diff --git a/debugger/debug.l b/debugger/debug.l index c0020d00e43..2884216b31e 100644 --- a/debugger/debug.l +++ b/debugger/debug.l @@ -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'; diff --git a/debugger/debugger.h b/debugger/debugger.h index d95ce57c662..2ff273cc0fe 100644 --- a/debugger/debugger.h +++ b/debugger/debugger.h @@ -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 */ diff --git a/debugger/display.c b/debugger/display.c index 80926f99946..56a03b44a78 100644 --- a/debugger/display.c +++ b/debugger/display.c @@ -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 ) diff --git a/debugger/expr.c b/debugger/expr.c index 298b62c4bc9..76f4f7996aa 100644 --- a/debugger/expr.c +++ b/debugger/expr.c @@ -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; } diff --git a/debugger/hash.c b/debugger/hash.c index 1eaf5ce971a..0544d65dad9 100644 --- a/debugger/hash.c +++ b/debugger/hash.c @@ -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); } } diff --git a/debugger/info.c b/debugger/info.c index 19ca90c356c..606e50c2ad3 100644 --- a/debugger/info.c +++ b/debugger/info.c @@ -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"); } diff --git a/debugger/intvar.h b/debugger/intvar.h new file mode 100644 index 00000000000..1e3207e943b --- /dev/null +++ b/debugger/intvar.h @@ -0,0 +1,3 @@ +INTERNAL_VAR(BreakAllThreadsStartup, FALSE) +INTERNAL_VAR(ExtDbgOnInvalidAddress, FALSE) +INTERNAL_VAR(ChannelMask, DBG_CHN_MESG) diff --git a/debugger/memory.c b/debugger/memory.c index 19466e5df7a..4889ce7b264 100644 --- a/debugger/memory.c +++ b/debugger/memory.c @@ -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; idbg_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) diff --git a/debugger/module.c b/debugger/module.c index f73dfb294a1..783b5337780 100644 --- a/debugger/module.c +++ b/debugger/module.c @@ -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; @@ -257,15 +258,15 @@ void DEBUG_LoadModule32(const char* name, DWORD base) value.addr.off = 0; /* grab PE Header */ - if (!DEBUG_READ_MEM_VERBOSE((void*)(base + OFFSET_OF(IMAGE_DOS_HEADER, e_lfanew)), + if (!DEBUG_READ_MEM_VERBOSE((void*)(base + OFFSET_OF(IMAGE_DOS_HEADER, e_lfanew)), &pe_header_ofs, sizeof(pe_header_ofs)) || !DEBUG_READ_MEM_VERBOSE((void*)(base + pe_header_ofs), &pe_header, sizeof(pe_header))) 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); } } diff --git a/debugger/msc.c b/debugger/msc.c index 998d3420e75..bae9edd7e03 100644 --- a/debugger/msc.c +++ b/debugger/msc.c @@ -16,16 +16,8 @@ */ #include "config.h" -#include #include -#include -#ifdef HAVE_SYS_MMAN_H -#include -#endif -#include -#include -#include #include #include #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; } diff --git a/debugger/registers.c b/debugger/registers.c index 9f6610f6173..3e49ca63447 100644 --- a/debugger/registers.c +++ b/debugger/registers.c @@ -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; diff --git a/debugger/source.c b/debugger/source.c index 1f212c3d0ab..e4f23652c81 100644 --- a/debugger/source.c +++ b/debugger/source.c @@ -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; } } diff --git a/debugger/stabs.c b/debugger/stabs.c index 30a7c46587f..807b36b8531 100644 --- a/debugger/stabs.c +++ b/debugger/stabs.c @@ -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,9 +862,9 @@ 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, + curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath, SYM_WINE | SYM_DATA ); #endif break; @@ -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__ */ diff --git a/debugger/stack.c b/debugger/stack.c index 07f2a958488..1b0935dddfb 100644 --- a/debugger/stack.c +++ b/debugger/stack.c @@ -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 } diff --git a/debugger/types.c b/debugger/types.c index 64f12905fbf..f200c9916ab 100644 --- a/debugger/types.c +++ b/debugger/types.c @@ -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; } diff --git a/debugger/winedbg.c b/debugger/winedbg.c index be37c110c32..0bdc6d5ac26 100644 --- a/debugger/winedbg.c +++ b/debugger/winedbg.c @@ -7,7 +7,7 @@ #include #include -#include +#include #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; @@ -110,42 +130,7 @@ static void DEBUG_InitCurrProcess(void) * Initialize the type handling stuff. */ 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(); + DEBUG_InitCVDataTypes(); } 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("", 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); - - if (!DebugActiveProcess((DWORD)pid)) { - TRACE("Can't debug process %ld: %ld\n", (DWORD)pid, GetLastError()); - return 0; + char* argv[5]; + char* cmdline = strdup(_cmdline); + char* ptr = cmdline; + int instr = FALSE; + int argc = 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); -} - -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; +#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; + + /* 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; -} diff --git a/debugger/winedbg.spec b/debugger/winedbg.spec new file mode 100644 index 00000000000..6d2c64905f3 --- /dev/null +++ b/debugger/winedbg.spec @@ -0,0 +1,5 @@ +name winedbg +mode guiexe +type win32 +init WinMain + diff --git a/include/stackframe.h b/include/stackframe.h index 80b307322a2..9cc0389b8f8 100644 --- a/include/stackframe.h +++ b/include/stackframe.h @@ -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; }