| %{ |
| /* |
| * Parser for command lines in the Wine debugger |
| * |
| * Copyright 1993 Eric Youngdale |
| * Copyright 1995 Morten Welinder |
| */ |
| |
| #include "config.h" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <signal.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| #ifdef HAVE_ALLOCA_H |
| #include <alloca.h> |
| #endif |
| |
| #include "winbase.h" |
| #include "module.h" |
| #include "task.h" |
| #include "options.h" |
| #include "queue.h" |
| #include "wine/winbase16.h" |
| #include "winnt.h" |
| #include "x11drv.h" |
| #include "win.h" |
| #include "debugger.h" |
| #include "neexe.h" |
| #include "process.h" |
| #include "server.h" |
| #include "main.h" |
| #include "expr.h" |
| #include "user.h" |
| |
| extern FILE * yyin; |
| unsigned int dbg_mode = 0; |
| HANDLE dbg_heap = 0; |
| int curr_frame = 0; |
| |
| static enum exec_mode dbg_exec_mode = EXEC_CONT; |
| static int dbg_exec_count = 0; |
| |
| void issue_prompt(void); |
| void mode_command(int); |
| void flush_symbols(void); |
| int yylex(void); |
| int yyerror(char *); |
| |
| #ifdef DBG_need_heap |
| #define malloc(x) DBG_alloc(x) |
| #define realloc(x,y) DBG_realloc(x,y) |
| #define free(x) DBG_free(x) |
| #endif |
| |
| extern void VIRTUAL_Dump(void); /* memory/virtual.c */ |
| |
| %} |
| |
| %union |
| { |
| DBG_ADDR address; |
| enum debug_regs reg; |
| char * string; |
| int integer; |
| struct list_id listing; |
| struct expr * expression; |
| struct datatype * type; |
| } |
| |
| %token tCONT tPASS tSTEP tLIST tNEXT tQUIT tHELP tBACKTRACE tINFO tWALK tUP tDOWN |
| %token tENABLE tDISABLE tBREAK tDELETE tSET tMODE tPRINT tEXAM tABORT tDEBUGMSG |
| %token tCLASS tMAPS tMODULE tSTACK tSEGMENTS tREGS tWND tQUEUE tLOCAL |
| %token tPROCESS tMODREF |
| %token tEOL tSTRING tDEBUGSTR |
| %token tFRAME tSHARE tCOND tDISPLAY tUNDISPLAY tDISASSEMBLE |
| %token tSTEPI tNEXTI tFINISH tSHOW tDIR |
| %token <string> tPATH |
| %token <string> tIDENTIFIER tSTRING tDEBUGSTR |
| %token <integer> tNUM tFORMAT |
| %token <reg> tREG |
| %token tSYMBOLFILE |
| |
| %token tCHAR tSHORT tINT tLONG tFLOAT tDOUBLE tUNSIGNED tSIGNED |
| %token tSTRUCT tUNION tENUM |
| |
| /* %left ',' */ |
| /* %left '=' OP_OR_EQUAL OP_XOR_EQUAL OP_AND_EQUAL OP_SHL_EQUAL \ |
| OP_SHR_EQUAL OP_PLUS_EQUAL OP_MINUS_EQUAL \ |
| OP_TIMES_EQUAL OP_DIVIDE_EQUAL OP_MODULO_EQUAL */ |
| /* %left OP_COND */ /* ... ? ... : ... */ |
| %left OP_LOR |
| %left OP_LAND |
| %left '|' |
| %left '^' |
| %left '&' |
| %left OP_EQ OP_NE |
| %left '<' '>' OP_LE OP_GE |
| %left OP_SHL OP_SHR |
| %left '+' '-' |
| %left '*' '/' '%' |
| %left OP_SIGN '!' '~' OP_DEREF /* OP_INC OP_DEC OP_ADDR */ |
| %left '.' '[' OP_DRF |
| %nonassoc ':' |
| |
| %type <expression> expr lval lvalue |
| %type <type> type_cast type_expr |
| %type <address> expr_addr lval_addr |
| %type <integer> expr_value |
| %type <string> pathname |
| |
| %type <listing> list_arg |
| |
| %% |
| |
| input: line { issue_prompt(); } |
| | input line { issue_prompt(); } |
| |
| line: command |
| | tEOL |
| | error tEOL { yyerrok; } |
| |
| command: |
| tQUIT tEOL { DEBUG_Exit(0); } |
| | tHELP tEOL { DEBUG_Help(); } |
| | tHELP tINFO tEOL { DEBUG_HelpInfo(); } |
| | tCONT tEOL { dbg_exec_count = 1; |
| dbg_exec_mode = EXEC_CONT; return 0; } |
| | tPASS tEOL { dbg_exec_count = 1; |
| dbg_exec_mode = EXEC_PASS; return 0; } |
| | tCONT tNUM tEOL { dbg_exec_count = $2; |
| dbg_exec_mode = EXEC_CONT; return 0; } |
| | tSTEP tEOL { dbg_exec_count = 1; |
| dbg_exec_mode = EXEC_STEP_INSTR; return 0; } |
| | tNEXT tEOL { dbg_exec_count = 1; |
| dbg_exec_mode = EXEC_STEP_OVER; return 0; } |
| | tSTEP tNUM tEOL { dbg_exec_count = $2; |
| dbg_exec_mode = EXEC_STEP_INSTR; return 0; } |
| | tNEXT tNUM tEOL { dbg_exec_count = $2; |
| dbg_exec_mode = EXEC_STEP_OVER; return 0; } |
| | tSTEPI tEOL { dbg_exec_count = 1; |
| dbg_exec_mode = EXEC_STEPI_INSTR; return 0; } |
| | tNEXTI tEOL { dbg_exec_count = 1; |
| dbg_exec_mode = EXEC_STEPI_OVER; return 0; } |
| | tSTEPI tNUM tEOL { dbg_exec_count = $2; |
| dbg_exec_mode = EXEC_STEPI_INSTR; return 0; } |
| | tNEXTI tNUM tEOL { dbg_exec_count = $2; |
| dbg_exec_mode = EXEC_STEPI_OVER; return 0; } |
| | tABORT tEOL { kill(getpid(), SIGABRT); } |
| | tMODE tNUM tEOL { mode_command($2); } |
| | tENABLE tNUM tEOL { DEBUG_EnableBreakpoint( $2, TRUE ); } |
| | tDISABLE tNUM tEOL { DEBUG_EnableBreakpoint( $2, FALSE ); } |
| | tDELETE tBREAK tNUM tEOL { DEBUG_DelBreakpoint( $3 ); } |
| | tBACKTRACE tEOL { DEBUG_BackTrace(); } |
| | tUP tEOL { DEBUG_SetFrame( curr_frame + 1 ); } |
| | tUP tNUM tEOL { DEBUG_SetFrame( curr_frame + $2 ); } |
| | tDOWN tEOL { DEBUG_SetFrame( curr_frame - 1 ); } |
| | tDOWN tNUM tEOL { DEBUG_SetFrame( curr_frame - $2 ); } |
| | tFRAME tNUM tEOL { DEBUG_SetFrame( $2 ); } |
| | tFINISH tEOL { dbg_exec_count = 0; |
| dbg_exec_mode = EXEC_FINISH; return 0; } |
| | tSHOW tDIR tEOL { DEBUG_ShowDir(); } |
| | tDIR pathname tEOL { DEBUG_AddPath( $2 ); } |
| | tDIR tEOL { DEBUG_NukePath(); } |
| | tDISPLAY tEOL { DEBUG_InfoDisplay(); } |
| | tDISPLAY expr tEOL { DEBUG_AddDisplay($2, 1, 0); } |
| | tDISPLAY tFORMAT expr tEOL { DEBUG_AddDisplay($3, $2 >> 8, $2 & 0xff); } |
| | tDELETE tDISPLAY tNUM tEOL { DEBUG_DelDisplay( $3 ); } |
| | tDELETE tDISPLAY tEOL { DEBUG_DelDisplay( -1 ); } |
| | tUNDISPLAY tNUM tEOL { DEBUG_DelDisplay( $2 ); } |
| | tUNDISPLAY tEOL { DEBUG_DelDisplay( -1 ); } |
| | tCOND tNUM tEOL { DEBUG_AddBPCondition($2, NULL); } |
| | tCOND tNUM expr tEOL { DEBUG_AddBPCondition($2, $3); } |
| | tDEBUGMSG tDEBUGSTR tEOL { MAIN_ParseDebugOptions($2); } |
| | tSYMBOLFILE pathname tEOL{ DEBUG_ReadSymbolTable($2); } |
| | list_command |
| | disassemble_command |
| | set_command |
| | x_command |
| | print_command |
| | break_command |
| | info_command |
| | walk_command |
| |
| set_command: |
| tSET tREG '=' expr_value tEOL { DEBUG_SetRegister( $2, $4 ); |
| DEBUG_FreeExprMem(); } |
| | tSET lval_addr '=' expr_value tEOL { DEBUG_WriteMemory( &$2, $4 ); |
| DEBUG_FreeExprMem(); } |
| |
| pathname: |
| tIDENTIFIER { $$ = $1; } |
| | tPATH { $$ = $1; } |
| |
| disassemble_command: |
| tDISASSEMBLE tEOL { DEBUG_Disassemble( NULL, NULL, 10 ); } |
| | tDISASSEMBLE expr_addr tEOL { DEBUG_Disassemble( & $2, NULL, 10 ); } |
| | tDISASSEMBLE expr_addr ',' expr_addr tEOL { DEBUG_Disassemble( & $2, & $4, 0 ); } |
| |
| list_command: |
| tLIST tEOL { DEBUG_List( NULL, NULL, 10 ); } |
| | tLIST '-' tEOL { DEBUG_List( NULL, NULL, -10 ); } |
| | tLIST list_arg tEOL { DEBUG_List( & $2, NULL, 10 ); } |
| | tLIST ',' list_arg tEOL { DEBUG_List( NULL, & $3, -10 ); } |
| | tLIST list_arg ',' list_arg tEOL { DEBUG_List( & $2, & $4, 0 ); } |
| |
| list_arg: |
| tNUM { $$.sourcefile = NULL; $$.line = $1; } |
| | pathname ':' tNUM { $$.sourcefile = $1; $$.line = $3; } |
| | tIDENTIFIER { DEBUG_GetFuncInfo( & $$, NULL, $1); } |
| | pathname ':' tIDENTIFIER { DEBUG_GetFuncInfo( & $$, $1, $3); } |
| | '*' expr_addr { DEBUG_FindNearestSymbol( & $2, FALSE, NULL, |
| 0, & $$ ); |
| DEBUG_FreeExprMem(); } |
| |
| x_command: |
| tEXAM expr_addr tEOL { DEBUG_ExamineMemory( &$2, 1, 'x'); |
| DEBUG_FreeExprMem(); } |
| | tEXAM tFORMAT expr_addr tEOL { DEBUG_ExamineMemory( &$3, $2>>8, $2&0xff ); |
| DEBUG_FreeExprMem(); } |
| |
| print_command: |
| tPRINT expr_addr tEOL { DEBUG_Print( &$2, 1, 0, 0 ); |
| DEBUG_FreeExprMem(); } |
| | tPRINT tFORMAT expr_addr tEOL { DEBUG_Print( &$3, $2 >> 8, $2 & 0xff, 0 ); |
| DEBUG_FreeExprMem(); } |
| |
| break_command: |
| tBREAK '*' expr_addr tEOL { DEBUG_AddBreakpoint( &$3 ); |
| DEBUG_FreeExprMem(); } |
| | tBREAK tIDENTIFIER tEOL { DBG_ADDR addr; |
| if( DEBUG_GetSymbolValue($2, -1, &addr, TRUE) ) |
| { |
| DEBUG_AddBreakpoint( &addr ); |
| } |
| else |
| { |
| fprintf(stderr,"Unable to add breakpoint\n"); |
| } |
| } |
| | tBREAK tIDENTIFIER ':' tNUM tEOL { DBG_ADDR addr; |
| if( DEBUG_GetSymbolValue($2, $4, &addr, TRUE) ) |
| { |
| DEBUG_AddBreakpoint( &addr ); |
| } |
| else |
| { |
| fprintf(stderr,"Unable to add breakpoint\n"); |
| } |
| } |
| | tBREAK tNUM tEOL { struct name_hash *nh; |
| DBG_ADDR addr; |
| DEBUG_GetCurrentAddress( &addr ); |
| DEBUG_FindNearestSymbol(&addr, TRUE, |
| &nh, 0, NULL); |
| if( nh != NULL ) |
| { |
| DEBUG_GetLineNumberAddr(nh, |
| $2, &addr, TRUE); |
| DEBUG_AddBreakpoint( &addr ); |
| } |
| else |
| { |
| fprintf(stderr,"Unable to add breakpoint\n"); |
| } |
| } |
| |
| | tBREAK tEOL { DBG_ADDR addr; |
| DEBUG_GetCurrentAddress( &addr ); |
| DEBUG_AddBreakpoint( &addr ); |
| } |
| |
| info_command: |
| tINFO tBREAK tEOL { DEBUG_InfoBreakpoints(); } |
| | tINFO tCLASS expr_value tEOL { CLASS_DumpClass( (struct tagCLASS *)$3 ); |
| DEBUG_FreeExprMem(); } |
| | tINFO tSHARE tEOL { DEBUG_InfoShare(); } |
| | tINFO tMODULE expr_value tEOL { NE_DumpModule( $3 ); |
| DEBUG_FreeExprMem(); } |
| | tINFO tQUEUE expr_value tEOL { QUEUE_DumpQueue( $3 ); |
| DEBUG_FreeExprMem(); } |
| | tINFO tREGS tEOL { DEBUG_InfoRegisters(); } |
| | tINFO tSEGMENTS expr_value tEOL { LDT_Print( SELECTOR_TO_ENTRY($3), 1 ); |
| DEBUG_FreeExprMem(); } |
| | tINFO tSEGMENTS tEOL { LDT_Print( 0, -1 ); } |
| | tINFO tSTACK tEOL { DEBUG_InfoStack(); } |
| | tINFO tMAPS tEOL { VIRTUAL_Dump(); } |
| | tINFO tWND expr_value tEOL { WIN_DumpWindow( $3 ); |
| DEBUG_FreeExprMem(); } |
| | tINFO tLOCAL tEOL { DEBUG_InfoLocals(); } |
| | tINFO tDISPLAY tEOL { DEBUG_InfoDisplay(); } |
| |
| walk_command: |
| tWALK tCLASS tEOL { CLASS_WalkClasses(); } |
| | tWALK tMODULE tEOL { NE_WalkModules(); } |
| | tWALK tQUEUE tEOL { QUEUE_WalkQueues(); } |
| | tWALK tWND tEOL { WIN_WalkWindows( 0, 0 ); } |
| | tWALK tWND tNUM tEOL { WIN_WalkWindows( $3, 0 ); } |
| | tWALK tPROCESS tEOL { PROCESS_WalkProcess(); } |
| | tWALK tMODREF expr_value tEOL { MODULE_WalkModref( $3 ); } |
| |
| |
| type_cast: |
| '(' type_expr ')' { $$ = $2; } |
| |
| type_expr: |
| type_expr '*' { $$ = DEBUG_FindOrMakePointerType($1); } |
| | tINT { $$ = DEBUG_TypeCast(DT_BASIC, "int"); } |
| | tCHAR { $$ = DEBUG_TypeCast(DT_BASIC, "char"); } |
| | tLONG tINT { $$ = DEBUG_TypeCast(DT_BASIC, "long int"); } |
| | tUNSIGNED tINT { $$ = DEBUG_TypeCast(DT_BASIC, "unsigned int"); } |
| | tLONG tUNSIGNED tINT { $$ = DEBUG_TypeCast(DT_BASIC, "long unsigned int"); } |
| | tLONG tLONG tINT { $$ = DEBUG_TypeCast(DT_BASIC, "long long int"); } |
| | tLONG tLONG tUNSIGNED tINT { $$ = DEBUG_TypeCast(DT_BASIC, "long long unsigned int"); } |
| | tSHORT tINT { $$ = DEBUG_TypeCast(DT_BASIC, "short int"); } |
| | tSHORT tUNSIGNED tINT { $$ = DEBUG_TypeCast(DT_BASIC, "short unsigned int"); } |
| | tSIGNED tCHAR { $$ = DEBUG_TypeCast(DT_BASIC, "signed char"); } |
| | tUNSIGNED tCHAR { $$ = DEBUG_TypeCast(DT_BASIC, "unsigned char"); } |
| | tFLOAT { $$ = DEBUG_TypeCast(DT_BASIC, "float"); } |
| | tDOUBLE { $$ = DEBUG_TypeCast(DT_BASIC, "double"); } |
| | tLONG tDOUBLE { $$ = DEBUG_TypeCast(DT_BASIC, "long double"); } |
| | tSTRUCT tIDENTIFIER { $$ = DEBUG_TypeCast(DT_STRUCT, $2); } |
| | tUNION tIDENTIFIER { $$ = DEBUG_TypeCast(DT_STRUCT, $2); } |
| | tENUM tIDENTIFIER { $$ = DEBUG_TypeCast(DT_ENUM, $2); } |
| |
| expr_addr: |
| expr { $$ = DEBUG_EvalExpr($1); } |
| |
| expr_value: |
| expr { DBG_ADDR addr = DEBUG_EvalExpr($1); |
| $$ = addr.off ? *(unsigned int *) addr.off : 0; } |
| /* |
| * The expr rule builds an expression tree. When we are done, we call |
| * EvalExpr to evaluate the value of the expression. The advantage of |
| * the two-step approach is that it is possible to save expressions for |
| * use in 'display' commands, and in conditional watchpoints. |
| */ |
| expr: |
| tNUM { $$ = DEBUG_ConstExpr($1); } |
| | tSTRING { $$ = DEBUG_StringExpr($1); } |
| | tREG { $$ = DEBUG_RegisterExpr($1); } |
| | tIDENTIFIER { $$ = DEBUG_SymbolExpr($1); } |
| | expr OP_DRF tIDENTIFIER { $$ = DEBUG_StructPExpr($1, $3); } |
| | expr '.' tIDENTIFIER { $$ = DEBUG_StructExpr($1, $3); } |
| | tIDENTIFIER '(' ')' { $$ = DEBUG_CallExpr($1, 0); } |
| | tIDENTIFIER '(' expr ')' { $$ = DEBUG_CallExpr($1, 1, $3); } |
| | tIDENTIFIER '(' expr ',' expr ')' { $$ = DEBUG_CallExpr($1, 2, $3, |
| $5); } |
| | tIDENTIFIER '(' expr ',' expr ',' expr ')' { $$ = DEBUG_CallExpr($1, 3, $3, $5, $7); } |
| | tIDENTIFIER '(' expr ',' expr ',' expr ',' expr ')' { $$ = DEBUG_CallExpr($1, 3, $3, $5, $7, $9); } |
| | tIDENTIFIER '(' expr ',' expr ',' expr ',' expr ',' expr ')' { $$ = DEBUG_CallExpr($1, 3, $3, $5, $7, $9, $11); } |
| | expr '[' expr ']' { $$ = DEBUG_BinopExpr(EXP_OP_ARR, $1, $3); } |
| | expr ':' expr { $$ = DEBUG_BinopExpr(EXP_OP_SEG, $1, $3); } |
| | expr OP_LOR expr { $$ = DEBUG_BinopExpr(EXP_OP_LOR, $1, $3); } |
| | expr OP_LAND expr { $$ = DEBUG_BinopExpr(EXP_OP_LAND, $1, $3); } |
| | expr '|' expr { $$ = DEBUG_BinopExpr(EXP_OP_OR, $1, $3); } |
| | expr '&' expr { $$ = DEBUG_BinopExpr(EXP_OP_AND, $1, $3); } |
| | expr '^' expr { $$ = DEBUG_BinopExpr(EXP_OP_XOR, $1, $3); } |
| | expr OP_EQ expr { $$ = DEBUG_BinopExpr(EXP_OP_EQ, $1, $3); } |
| | expr '>' expr { $$ = DEBUG_BinopExpr(EXP_OP_GT, $1, $3); } |
| | expr '<' expr { $$ = DEBUG_BinopExpr(EXP_OP_LT, $1, $3); } |
| | expr OP_GE expr { $$ = DEBUG_BinopExpr(EXP_OP_GE, $1, $3); } |
| | expr OP_LE expr { $$ = DEBUG_BinopExpr(EXP_OP_LE, $1, $3); } |
| | expr OP_NE expr { $$ = DEBUG_BinopExpr(EXP_OP_NE, $1, $3); } |
| | expr OP_SHL expr { $$ = DEBUG_BinopExpr(EXP_OP_SHL, $1, $3); } |
| | expr OP_SHR expr { $$ = DEBUG_BinopExpr(EXP_OP_SHR, $1, $3); } |
| | expr '+' expr { $$ = DEBUG_BinopExpr(EXP_OP_ADD, $1, $3); } |
| | expr '-' expr { $$ = DEBUG_BinopExpr(EXP_OP_SUB, $1, $3); } |
| | expr '*' expr { $$ = DEBUG_BinopExpr(EXP_OP_MUL, $1, $3); } |
| | expr '/' expr { $$ = DEBUG_BinopExpr(EXP_OP_DIV, $1, $3); } |
| | expr '%' expr { $$ = DEBUG_BinopExpr(EXP_OP_REM, $1, $3); } |
| | '-' expr %prec OP_SIGN { $$ = DEBUG_UnopExpr(EXP_OP_NEG, $2); } |
| | '+' expr %prec OP_SIGN { $$ = $2; } |
| | '!' expr { $$ = DEBUG_UnopExpr(EXP_OP_NOT, $2); } |
| | '~' expr { $$ = DEBUG_UnopExpr(EXP_OP_LNOT, $2); } |
| | '(' expr ')' { $$ = $2; } |
| | '*' expr %prec OP_DEREF { $$ = DEBUG_UnopExpr(EXP_OP_DEREF, $2); } |
| | '&' expr %prec OP_DEREF { $$ = DEBUG_UnopExpr(EXP_OP_ADDR, $2); } |
| | type_cast expr %prec OP_DEREF { $$ = DEBUG_TypeCastExpr($1, $2); } |
| |
| /* |
| * The lvalue rule builds an expression tree. This is a limited form |
| * of expression that is suitable to be used as an lvalue. |
| */ |
| lval_addr: |
| lval { $$ = DEBUG_EvalExpr($1); } |
| |
| lval: |
| lvalue { $$ = $1; } |
| | '*' expr { $$ = DEBUG_UnopExpr(EXP_OP_FORCE_DEREF, $2); } |
| |
| lvalue: |
| tNUM { $$ = DEBUG_ConstExpr($1); } |
| | tREG { $$ = DEBUG_RegisterExpr($1); } |
| | tIDENTIFIER { $$ = DEBUG_SymbolExpr($1); } |
| | lvalue OP_DRF tIDENTIFIER { $$ = DEBUG_StructPExpr($1, $3); } |
| | lvalue '.' tIDENTIFIER { $$ = DEBUG_StructExpr($1, $3); } |
| | lvalue '[' expr ']' { $$ = DEBUG_BinopExpr(EXP_OP_ARR, $1, $3); } |
| |
| %% |
| |
| void |
| issue_prompt(){ |
| #ifdef DONT_USE_READLINE |
| fprintf(stderr,"Wine-dbg>"); |
| #endif |
| } |
| |
| void mode_command(int newmode) |
| { |
| if ((newmode == 16) || (newmode == 32)) dbg_mode = newmode; |
| else fprintf(stderr,"Invalid mode (use 16 or 32)\n"); |
| } |
| |
| /*********************************************************************** |
| * DEBUG_Freeze |
| */ |
| static void DEBUG_Freeze( BOOL freeze ) |
| { |
| static BOOL frozen = FALSE; |
| |
| if ( freeze && !frozen ) |
| { |
| if ( X11DRV_CritSection.LockSemaphore ) |
| { |
| /* Don't freeze thread currently holding the X crst! */ |
| EnterCriticalSection( &X11DRV_CritSection ); |
| CLIENT_DebuggerRequest( DEBUGGER_FREEZE_ALL ); |
| LeaveCriticalSection( &X11DRV_CritSection ); |
| } |
| else |
| CLIENT_DebuggerRequest( DEBUGGER_FREEZE_ALL ); |
| |
| frozen = TRUE; |
| } |
| |
| if ( !freeze && frozen ) |
| { |
| CLIENT_DebuggerRequest( DEBUGGER_UNFREEZE_ALL ); |
| frozen = FALSE; |
| } |
| } |
| |
| /*********************************************************************** |
| * DEBUG_Exit |
| * |
| * Kill current process. |
| */ |
| void DEBUG_Exit( DWORD exit_code ) |
| { |
| DEBUG_Freeze( FALSE ); |
| |
| TASK_KillTask( 0 ); /* FIXME: should not be necessary */ |
| TerminateProcess( GetCurrentProcess(), exit_code ); |
| } |
| |
| /*********************************************************************** |
| * DEBUG_Main |
| * |
| * Debugger main loop. |
| */ |
| static void DEBUG_Main( BOOL is_debug ) |
| { |
| static int loaded_symbols = 0; |
| static BOOL in_debugger = FALSE; |
| char SymbolTableFile[256]; |
| int newmode; |
| BOOL ret_ok; |
| #ifdef YYDEBUG |
| yydebug = 0; |
| #endif |
| |
| if (in_debugger) |
| { |
| fprintf( stderr, " inside debugger, trying to invoke external debugger.\n" ); |
| DEBUG_ExternalDebugger(); |
| DEBUG_Exit(1); |
| } |
| in_debugger = TRUE; |
| yyin = stdin; |
| |
| DEBUG_SetBreakpoints( FALSE ); |
| |
| if (!is_debug) |
| { |
| #ifdef __i386__ |
| if (IS_SELECTOR_SYSTEM(CS_reg(&DEBUG_context))) |
| fprintf( stderr, " in 32-bit code (0x%08lx).\n", EIP_reg(&DEBUG_context)); |
| else |
| fprintf( stderr, " in 16-bit code (%04x:%04lx).\n", |
| (WORD)CS_reg(&DEBUG_context), EIP_reg(&DEBUG_context) ); |
| #else |
| fprintf( stderr, " (%p).\n", GET_IP(&DEBUG_context) ); |
| #endif |
| } |
| |
| if (!loaded_symbols) |
| { |
| loaded_symbols++; |
| |
| DEBUG_Freeze( TRUE ); |
| |
| #ifdef DBG_need_heap |
| /* |
| * Initialize the debugger heap. |
| */ |
| dbg_heap = HeapCreate(HEAP_NO_SERIALIZE, 0x1000, 0x8000000); /* 128MB */ |
| #endif |
| |
| /* |
| * 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; |
| if (-1 == stat(symfilename, &statbuf) ) |
| symfilename = LIBDIR "wine.sym"; |
| |
| PROFILE_GetWineIniString( "wine", "SymbolTableFile", symfilename, |
| SymbolTableFile, sizeof(SymbolTableFile)); |
| DEBUG_ReadSymbolTable( SymbolTableFile ); |
| } |
| DEBUG_LoadEntryPoints(NULL); |
| DEBUG_ProcessDeferredDebug(); |
| } |
| else |
| { |
| if (DEBUG_LoadEntryPoints("Loading new modules symbols:\n")) |
| DEBUG_ProcessDeferredDebug(); |
| } |
| |
| #if 0 |
| fprintf(stderr, "Entering debugger PC=%x, mode=%d, count=%d\n", |
| EIP_reg(&DEBUG_context), |
| dbg_exec_mode, dbg_exec_count); |
| |
| sleep(1); |
| #endif |
| |
| if (!is_debug || !DEBUG_ShouldContinue( dbg_exec_mode, &dbg_exec_count )) |
| { |
| DBG_ADDR addr; |
| DEBUG_GetCurrentAddress( &addr ); |
| |
| DEBUG_Freeze( TRUE ); |
| |
| /* Put the display in a correct state */ |
| if (USER_Driver) USER_Driver->pBeginDebugging(); |
| |
| #ifdef __i386__ |
| newmode = ISV86(&DEBUG_context) ? 16 : IS_SELECTOR_32BIT(addr.seg) ? 32 : 16; |
| #else |
| newmode = 32; |
| #endif |
| if (newmode != dbg_mode) |
| fprintf(stderr,"In %d bit mode.\n", dbg_mode = newmode); |
| |
| DEBUG_DoDisplay(); |
| |
| if (!is_debug) /* This is a real crash, dump some info */ |
| { |
| DEBUG_InfoRegisters(); |
| DEBUG_InfoStack(); |
| #ifdef __i386__ |
| if (dbg_mode == 16) |
| { |
| LDT_Print( SELECTOR_TO_ENTRY(DS_reg(&DEBUG_context)), 1 ); |
| if (ES_reg(&DEBUG_context) != DS_reg(&DEBUG_context)) |
| LDT_Print( SELECTOR_TO_ENTRY(ES_reg(&DEBUG_context)), 1 ); |
| } |
| LDT_Print( SELECTOR_TO_ENTRY(FS_reg(&DEBUG_context)), 1 ); |
| #endif |
| DEBUG_BackTrace(); |
| } |
| else |
| { |
| /* |
| * Do a quiet backtrace so that we have an idea of what the situation |
| * is WRT the source files. |
| */ |
| DEBUG_SilentBackTrace(); |
| } |
| |
| if (!is_debug || |
| (dbg_exec_mode == EXEC_STEPI_OVER) || |
| (dbg_exec_mode == EXEC_STEPI_INSTR)) |
| { |
| /* Show where we crashed */ |
| curr_frame = 0; |
| DEBUG_PrintAddress( &addr, dbg_mode, TRUE ); |
| fprintf(stderr,": "); |
| if (DBG_CHECK_READ_PTR( &addr, 1 )) |
| { |
| DEBUG_Disasm( &addr, TRUE ); |
| fprintf(stderr,"\n"); |
| } |
| } |
| |
| ret_ok = 0; |
| do |
| { |
| issue_prompt(); |
| yyparse(); |
| flush_symbols(); |
| |
| DEBUG_GetCurrentAddress( &addr ); |
| ret_ok = DEBUG_ValidateRegisters(); |
| if (ret_ok) ret_ok = DBG_CHECK_READ_PTR( &addr, 1 ); |
| } while (!ret_ok); |
| } |
| |
| dbg_exec_mode = DEBUG_RestartExecution( dbg_exec_mode, dbg_exec_count ); |
| /* |
| * This will have gotten absorbed into the breakpoint info |
| * if it was used. Otherwise it would have been ignored. |
| * In any case, we don't mess with it any more. |
| */ |
| if ((dbg_exec_mode == EXEC_CONT) || (dbg_exec_mode == EXEC_PASS)) |
| { |
| dbg_exec_count = 0; |
| |
| DEBUG_Freeze( FALSE ); |
| } |
| |
| in_debugger = FALSE; |
| |
| if (USER_Driver) USER_Driver->pEndDebugging(); |
| } |
| |
| |
| DWORD wine_debugger( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance ) |
| { |
| BOOL is_debug = FALSE; |
| |
| if (first_chance && !Options.debug) return 0; /* pass to app first */ |
| |
| switch(rec->ExceptionCode) |
| { |
| case EXCEPTION_BREAKPOINT: |
| 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" ); |
| switch(rec->ExceptionCode) |
| { |
| case EXCEPTION_INT_DIVIDE_BY_ZERO: |
| fprintf( stderr, "divide by zero" ); |
| break; |
| case EXCEPTION_INT_OVERFLOW: |
| fprintf( stderr, "overflow" ); |
| break; |
| case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: |
| fprintf( stderr, "array bounds " ); |
| break; |
| case EXCEPTION_ILLEGAL_INSTRUCTION: |
| fprintf( stderr, "illegal instruction" ); |
| break; |
| case EXCEPTION_STACK_OVERFLOW: |
| fprintf( stderr, "stack overflow" ); |
| break; |
| case EXCEPTION_PRIV_INSTRUCTION: |
| fprintf( stderr, "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] ); |
| else |
| fprintf( stderr, "page fault" ); |
| break; |
| case EXCEPTION_DATATYPE_MISALIGNMENT: |
| fprintf( stderr, "Alignment" ); |
| break; |
| case CONTROL_C_EXIT: |
| fprintf( stderr, "^C" ); |
| break; |
| case EXCEPTION_CRITICAL_SECTION_WAIT: |
| fprintf( stderr, "critical section %08lx wait failed", rec->ExceptionInformation[0] ); |
| break; |
| default: |
| fprintf( stderr, "%08lx", rec->ExceptionCode ); |
| break; |
| } |
| } |
| |
| DEBUG_context = *context; |
| DEBUG_Main( is_debug ); |
| *context = DEBUG_context; |
| return (dbg_exec_mode == EXEC_PASS) ? 0 : DBG_CONTINUE; |
| } |
| |
| int yyerror(char * s) |
| { |
| fprintf(stderr,"%s\n", s); |
| return 0; |
| } |