From 42bbeedbe40985fc6629b9c05469a89f838ac8f2 Mon Sep 17 00:00:00 2001 From: Zebediah Figura Date: Tue, 12 Jun 2018 17:53:16 -0500 Subject: [PATCH] winedbg: Make be_cpu process-specific. Signed-off-by: Zebediah Figura Signed-off-by: Alexandre Julliard --- programs/winedbg/be_cpu.h | 2 -- programs/winedbg/break.c | 40 +++++++++++------------ programs/winedbg/db_disasm.c | 4 +-- programs/winedbg/dbg.y | 4 +-- programs/winedbg/debugger.h | 3 +- programs/winedbg/expr.c | 4 +-- programs/winedbg/gdbproxy.c | 17 +++++----- programs/winedbg/info.c | 2 +- programs/winedbg/memory.c | 26 +++++++-------- programs/winedbg/stack.c | 10 +++--- programs/winedbg/symbol.c | 2 +- programs/winedbg/tgt_active.c | 9 ++--- programs/winedbg/tgt_minidump.c | 4 +-- programs/winedbg/types.c | 17 +++++----- programs/winedbg/winedbg.c | 58 ++++++++++++++++----------------- 15 files changed, 101 insertions(+), 101 deletions(-) diff --git a/programs/winedbg/be_cpu.h b/programs/winedbg/be_cpu.h index d62b5177a39..751ac9d13cf 100644 --- a/programs/winedbg/be_cpu.h +++ b/programs/winedbg/be_cpu.h @@ -116,8 +116,6 @@ struct backend_cpu BOOL (*store_integer)(const struct dbg_lvalue* lvalue, unsigned size, BOOL is_signed, LONGLONG); }; -extern struct backend_cpu* be_cpu; - /* some handy functions for non segmented CPUs */ void* be_cpu_linearize(HANDLE hThread, const ADDRESS64*); BOOL be_cpu_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr, diff --git a/programs/winedbg/break.c b/programs/winedbg/break.c index cedeed71203..2896c179067 100644 --- a/programs/winedbg/break.c +++ b/programs/winedbg/break.c @@ -63,15 +63,13 @@ void break_set_xpoints(BOOL set) addr = memory_to_linear_addr(&bp[i].addr); if (set) - ret = be_cpu->insert_Xpoint(dbg_curr_process->handle, - dbg_curr_process->process_io, - &dbg_context, bp[i].xpoint_type, addr, - &bp[i].info, size); + ret = dbg_curr_process->be_cpu->insert_Xpoint(dbg_curr_process->handle, + dbg_curr_process->process_io, &dbg_context, bp[i].xpoint_type, + addr, &bp[i].info, size); else - ret = be_cpu->remove_Xpoint(dbg_curr_process->handle, - dbg_curr_process->process_io, - &dbg_context, bp[i].xpoint_type, addr, - bp[i].info, size); + ret = dbg_curr_process->be_cpu->remove_Xpoint(dbg_curr_process->handle, + dbg_curr_process->process_io, &dbg_context, bp[i].xpoint_type, + addr, bp[i].info, size); if (!ret) { dbg_printf("Invalid address ("); @@ -572,9 +570,9 @@ static int find_triggered_watch(void) DWORD64 val = 0; if (bp[i].refcount && bp[i].enabled && !is_xpoint_break(i) && - (be_cpu->is_watchpoint_set(&dbg_context, bp[i].info))) + (dbg_curr_process->be_cpu->is_watchpoint_set(&dbg_context, bp[i].info))) { - be_cpu->clear_watchpoint(&dbg_context, bp[i].info); + dbg_curr_process->be_cpu->clear_watchpoint(&dbg_context, bp[i].info); if (get_watched_value(i, &val)) { @@ -599,7 +597,7 @@ static int find_triggered_watch(void) { if (val != bp[i].w.oldval) { - be_cpu->clear_watchpoint(&dbg_context, bp[i].info); + dbg_curr_process->be_cpu->clear_watchpoint(&dbg_context, bp[i].info); bp[i].w.oldval = val; found = i; /* cannot break, because two watch points may have been triggered on @@ -805,7 +803,7 @@ void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_br /* If not single-stepping, back up to the break instruction */ if (code == EXCEPTION_BREAKPOINT) - addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, TRUE); + addr->Offset += dbg_curr_process->be_cpu->adjust_pc_for_break(&dbg_context, TRUE); dbg_curr_thread->stopped_xpoint = find_xpoint(addr, be_xpoint_break); dbg_curr_process->bp[0].enabled = FALSE; /* disable the step-over breakpoint */ @@ -821,7 +819,7 @@ void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_br { /* If not single-stepping, do not back up over the break instruction */ if (code == EXCEPTION_BREAKPOINT) - addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE); + addr->Offset += dbg_curr_process->be_cpu->adjust_pc_for_break(&dbg_context, FALSE); return; } } @@ -833,7 +831,7 @@ void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_br if (dbg_curr_thread->stopped_xpoint == -1 && code == EXCEPTION_BREAKPOINT) { *is_break = TRUE; - addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE); + addr->Offset += dbg_curr_process->be_cpu->adjust_pc_for_break(&dbg_context, FALSE); } } @@ -890,7 +888,7 @@ void break_restart_execution(int count) dbg_printf("Not stopped at any breakpoint; argument ignored.\n"); } - if (mode == dbg_exec_finish && be_cpu->is_function_return(linear)) + if (mode == dbg_exec_finish && dbg_curr_process->be_cpu->is_function_return(linear)) { mode = ret_mode = dbg_exec_step_into_insn; } @@ -901,7 +899,7 @@ void break_restart_execution(int count) * FIXME - we need to check for things like thunks or trampolines, * as the actual function may in fact have debug info. */ - if (be_cpu->is_function_call(linear, &callee)) + if (dbg_curr_process->be_cpu->is_function_call(linear, &callee)) { status = symbol_get_function_line_status(&callee); #if 0 @@ -936,7 +934,7 @@ void break_restart_execution(int count) switch (mode) { case dbg_exec_cont: /* Continuous execution */ - be_cpu->single_step(&dbg_context, FALSE); + dbg_curr_process->be_cpu->single_step(&dbg_context, FALSE); break_set_xpoints(TRUE); break; @@ -968,16 +966,16 @@ void break_restart_execution(int count) case dbg_exec_finish: case dbg_exec_step_over_insn: /* Stepping over a call */ case dbg_exec_step_over_line: /* Stepping over a call */ - if (be_cpu->is_step_over_insn(linear)) + if (dbg_curr_process->be_cpu->is_step_over_insn(linear)) { - be_cpu->disasm_one_insn(&addr, FALSE); + dbg_curr_process->be_cpu->disasm_one_insn(&addr, FALSE); dbg_curr_process->bp[0].addr = addr; dbg_curr_process->bp[0].enabled = TRUE; dbg_curr_process->bp[0].refcount = 1; dbg_curr_process->bp[0].skipcount = 0; dbg_curr_process->bp[0].xpoint_type = be_xpoint_break; dbg_curr_process->bp[0].condition = NULL; - be_cpu->single_step(&dbg_context, FALSE); + dbg_curr_process->be_cpu->single_step(&dbg_context, FALSE); break_set_xpoints(TRUE); break; } @@ -985,7 +983,7 @@ void break_restart_execution(int count) case dbg_exec_step_into_line: /* Single-stepping a line */ case dbg_exec_step_into_insn: /* Single-stepping an instruction */ - be_cpu->single_step(&dbg_context, TRUE); + dbg_curr_process->be_cpu->single_step(&dbg_context, TRUE); break; default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); } diff --git a/programs/winedbg/db_disasm.c b/programs/winedbg/db_disasm.c index fc25e1cc4ac..9bdfb90439e 100644 --- a/programs/winedbg/db_disasm.c +++ b/programs/winedbg/db_disasm.c @@ -1800,8 +1800,8 @@ void be_i386_disasm_one_insn(ADDRESS64 *addr, int display) short_addr ? 2 : 4, FALSE ); get_value_inc( address.Segment, addr, /* segment */ 2, FALSE ); - be_cpu->build_addr(dbg_curr_thread->handle, &dbg_context, - &address, address.Segment, address.Offset); + dbg_curr_process->be_cpu->build_addr(dbg_curr_thread->handle, + &dbg_context, &address, address.Segment, address.Offset); if( db_display ) { print_address( &address, TRUE ); diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index 61acb909bfa..6b080a55bbd 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -270,8 +270,8 @@ info_command: tINFO tBREAK { break_info(); } | tINFO tSHARE { info_win32_module(0); } | tINFO tSHARE expr_rvalue { info_win32_module($3); } - | tINFO tREGS { be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); } - | tINFO tALLREGS { be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 1); } + | tINFO tREGS { dbg_curr_process->be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); } + | tINFO tALLREGS { dbg_curr_process->be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 1); } | tINFO tSEGMENTS expr_rvalue { info_win32_segments($3 >> 3, 1); } | tINFO tSEGMENTS { info_win32_segments(0, -1); } | tINFO tSTACK tNUM { stack_info($3); } diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index a1aac823dc2..0ceb1509917 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -39,7 +39,7 @@ #include "oaidl.h" #include -#define ADDRSIZE (be_cpu->pointer_size) +#define ADDRSIZE (dbg_curr_process->be_cpu->pointer_size) #define ADDRWIDTH (ADDRSIZE * 2) /* the debugger uses these exceptions for its internal use */ @@ -228,6 +228,7 @@ struct dbg_process void* pio_data; const WCHAR* imageName; struct list threads; + struct backend_cpu* be_cpu; BOOL continue_on_first_exception : 1, active_debuggee : 1; struct dbg_breakpoint bp[MAX_BREAKPOINTS]; diff --git a/programs/winedbg/expr.c b/programs/winedbg/expr.c index 96a617c1f94..d18ff8dc274 100644 --- a/programs/winedbg/expr.c +++ b/programs/winedbg/expr.c @@ -546,8 +546,8 @@ struct dbg_lvalue expr_eval(struct expr* exp) case EXP_OP_SEG: rtn.type.id = dbg_itype_segptr; rtn.type.module = 0; - be_cpu->build_addr(dbg_curr_thread->handle, &dbg_context, &rtn.addr, - types_extract_as_integer(&exp1), types_extract_as_integer(&exp2)); + dbg_curr_process->be_cpu->build_addr(dbg_curr_thread->handle, &dbg_context, &rtn.addr, + types_extract_as_integer(&exp1), types_extract_as_integer(&exp2)); break; case EXP_OP_LOR: exp->un.binop.result = (types_extract_as_integer(&exp1) || types_extract_as_integer(&exp2)); diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index 3ecf6296053..a9a65c29a95 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -886,7 +886,8 @@ static void wait_for_debuggee(struct gdb_context* gdbctx) static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill) { - be_cpu->single_step(&gdbctx->context, FALSE); + assert(gdbctx->process->be_cpu); + gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); resume_debuggee(gdbctx, DBG_CONTINUE); if (!kill) DebugActiveProcessStop(gdbctx->process->pid); @@ -1309,13 +1310,13 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) switch (gdbctx->in_packet[actionIndex[i] + 1]) { case 's': /* step */ - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); /* fall through*/ case 'c': /* continue */ resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID); break; case 'S': /* step Sig, */ - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); /* fall through */ case 'C': /* continue sig */ hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1); @@ -1352,13 +1353,13 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) switch (gdbctx->in_packet[actionIndex[defaultAction] + 1]) { case 's': /* step */ - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); /* fall through */ case 'c': /* continue */ resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID); break; case 'S': - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); /* fall through */ case 'C': /* continue sig */ hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1); @@ -1375,7 +1376,7 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) } /* if(defaultAction >=0) */ wait_for_debuggee(gdbctx); - be_cpu->single_step(&gdbctx->context, FALSE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); return packet_reply_status(gdbctx); } @@ -2090,10 +2091,10 @@ static enum packet_return packet_step(struct gdb_context* gdbctx) if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) fprintf(stderr, "NIY: step on %04x, while last thread is %04x\n", gdbctx->exec_thread->tid, dbg_curr_thread->tid); - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); - be_cpu->single_step(&gdbctx->context, FALSE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); return packet_reply_status(gdbctx); } diff --git a/programs/winedbg/info.c b/programs/winedbg/info.c index 83341c0c79e..c965759a28e 100644 --- a/programs/winedbg/info.c +++ b/programs/winedbg/info.c @@ -974,7 +974,7 @@ void info_win32_exception(void) { case AddrModeFlat: dbg_printf(" in %d-bit code (%s)", - be_cpu->pointer_size * 8, + dbg_curr_process->be_cpu->pointer_size * 8, memory_offset_to_string(hexbuf, addr.Offset, 0)); break; case AddrModeReal: diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c index 970e81aa3e2..6e65fa64adb 100644 --- a/programs/winedbg/memory.c +++ b/programs/winedbg/memory.c @@ -50,20 +50,20 @@ BOOL be_cpu_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr, void* memory_to_linear_addr(const ADDRESS64* addr) { - return be_cpu->linearize(dbg_curr_thread->handle, addr); + return dbg_curr_process->be_cpu->linearize(dbg_curr_thread->handle, addr); } BOOL memory_get_current_pc(ADDRESS64* addr) { - assert(be_cpu->get_addr); - return be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, + assert(dbg_curr_process->be_cpu->get_addr); + return dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, be_cpu_addr_pc, addr); } BOOL memory_get_current_stack(ADDRESS64* addr) { - assert(be_cpu->get_addr); - return be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, + assert(dbg_curr_process->be_cpu->get_addr); + return dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, be_cpu_addr_stack, addr); } @@ -374,17 +374,17 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) { case btInt: case btLong: - if (!be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; if (size == 1) goto print_char; dbg_print_hex(size, val_int); break; case btUInt: case btULong: - if (!be_cpu->fetch_integer(lvalue, size, FALSE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, size, FALSE, &val_int)) return; dbg_print_hex(size, val_int); break; case btFloat: - if (!be_cpu->fetch_float(lvalue, size, &val_real)) return; + if (!dbg_curr_process->be_cpu->fetch_float(lvalue, size, &val_real)) return; dbg_printf("%Lf", val_real); break; case btChar: @@ -392,7 +392,7 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) /* sometimes WCHAR is defined as btChar with size = 2, so discrimate * Ansi/Unicode based on size, not on basetype */ - if (!be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; print_char: if (size == 1 && isprint((char)val_int)) dbg_printf("'%c'", (char)val_int); @@ -407,7 +407,7 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) dbg_printf("%d", (int)val_int); break; case btBool: - if (!be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; dbg_printf("%s", val_int ? "true" : "false"); break; default: @@ -455,7 +455,7 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) * (not supported yet in dbghelp) * Assuming 4 as for an int */ - if (!be_cpu->fetch_integer(lvalue, 4, TRUE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, 4, TRUE, &val_int)) return; if (types_get_info(&type, TI_GET_CHILDRENCOUNT, &count)) { @@ -631,7 +631,7 @@ BOOL memory_disasm_one_insn(ADDRESS64* addr) dbg_printf("-- no code accessible --\n"); return FALSE; } - be_cpu->disasm_one_insn(addr, TRUE); + dbg_curr_process->be_cpu->disasm_one_insn(addr, TRUE); dbg_printf("\n"); return TRUE; } @@ -685,7 +685,7 @@ BOOL memory_get_register(DWORD regno, DWORD_PTR** value, char* buffer, int len) return FALSE; } - for (div = be_cpu->context_vars; div->name; div++) + for (div = dbg_curr_process->be_cpu->context_vars; div->name; div++) { if (div->val == regno) { diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index f49480afb5b..2ab4e607ea2 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -121,7 +121,7 @@ BOOL stack_get_register_frame(const struct dbg_internal_var* div, DWORD_PTR** pv { enum be_cpu_addr kind; - if (!be_cpu->get_register_info(div->val, &kind)) return FALSE; + if (!dbg_curr_process->be_cpu->get_register_info(div->val, &kind)) return FALSE; /* reuse some known registers directly out of stackwalk details */ switch (kind) @@ -198,9 +198,9 @@ unsigned stack_fetch_frames(const CONTEXT* _ctx) dbg_curr_thread->frames = NULL; memset(&sf, 0, sizeof(sf)); - be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_frame, &sf.AddrFrame); - be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_pc, &sf.AddrPC); - be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_stack, &sf.AddrStack); + dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_frame, &sf.AddrFrame); + dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_pc, &sf.AddrPC); + dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_stack, &sf.AddrStack); /* don't confuse StackWalk by passing in inconsistent addresses */ if ((sf.AddrPC.Mode == AddrModeFlat) && (sf.AddrFrame.Mode != AddrModeFlat)) @@ -209,7 +209,7 @@ unsigned stack_fetch_frames(const CONTEXT* _ctx) sf.AddrFrame.Mode = AddrModeFlat; } - while ((ret = StackWalk64(be_cpu->machine, dbg_curr_process->handle, + while ((ret = StackWalk64(dbg_curr_process->be_cpu->machine, dbg_curr_process->handle, dbg_curr_thread->handle, &sf, &ctx, stack_read_mem, SymFunctionTableAccess64, SymGetModuleBase64, NULL)) || nf == 0) /* we always register first frame information */ diff --git a/programs/winedbg/symbol.c b/programs/winedbg/symbol.c index 1040187699c..aa88ffcbc74 100644 --- a/programs/winedbg/symbol.c +++ b/programs/winedbg/symbol.c @@ -590,7 +590,7 @@ enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr) /* some compilers insert thunks in their code without debug info associated * take care of this situation */ - if (be_cpu->is_jump((void*)lin, &jumpee)) + if (dbg_curr_process->be_cpu->is_jump((void*)lin, &jumpee)) return symbol_get_function_line_status(&jumpee); return dbg_no_line_info; } diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 07edccce835..d891cfedd98 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -148,7 +148,8 @@ static BOOL dbg_exception_prolog(BOOL is_debug, const EXCEPTION_RECORD* rec) case AddrMode1616: name = "16 bit"; break; case AddrMode1632: name = "segmented 32 bit"; break; case AddrModeReal: name = "vm86"; break; - case AddrModeFlat: name = be_cpu->pointer_size == 4 ? "32 bit" : "64 bit"; break; + case AddrModeFlat: name = dbg_curr_process->be_cpu->pointer_size == 4 + ? "32 bit" : "64 bit"; break; } dbg_printf("In %s mode.\n", name); dbg_curr_thread->addr_mode = addr.Mode; @@ -158,9 +159,9 @@ static BOOL dbg_exception_prolog(BOOL is_debug, const EXCEPTION_RECORD* rec) if (!is_debug) { /* This is a real crash, dump some info */ - be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); + dbg_curr_process->be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); stack_info(-1); - be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context); + dbg_curr_process->be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context); stack_backtrace(dbg_curr_tid); } else @@ -997,7 +998,7 @@ static BOOL tgt_process_active_close_process(struct dbg_process* pcs, BOOL kill) /* needed for single stepping (ugly). * should this be handled inside the server ??? */ - be_cpu->single_step(&dbg_context, FALSE); + dbg_curr_process->be_cpu->single_step(&dbg_context, FALSE); if (dbg_curr_thread->in_exception) { SetThreadContext(dbg_curr_thread->handle, &dbg_context); diff --git a/programs/winedbg/tgt_minidump.c b/programs/winedbg/tgt_minidump.c index 5bf5a60a751..a17f32bdd6a 100644 --- a/programs/winedbg/tgt_minidump.c +++ b/programs/winedbg/tgt_minidump.c @@ -477,9 +477,9 @@ static enum dbg_start minidump_do_reload(struct tgt_process_minidump_data* data) min(sizeof(dbg_context), mes->ThreadContext.DataSize)); memory_get_current_pc(&addr); stack_fetch_frames(&dbg_context); - be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); + dbg_curr_process->be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); stack_info(-1); - be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context); + dbg_curr_process->be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context); stack_backtrace(mes->ThreadId); source_list_from_addr(&addr, 0); } diff --git a/programs/winedbg/types.c b/programs/winedbg/types.c index 3268d7e4dbf..696a9fd48a5 100644 --- a/programs/winedbg/types.c +++ b/programs/winedbg/types.c @@ -92,11 +92,11 @@ LONGLONG types_extract_as_longlong(const struct dbg_lvalue* lvalue, { case btChar: case btInt: - if (!be_cpu->fetch_integer(lvalue, (unsigned)size, s = TRUE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, (unsigned)size, s = TRUE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case btUInt: - if (!be_cpu->fetch_integer(lvalue, (unsigned)size, s = FALSE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, (unsigned)size, s = FALSE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case btFloat: @@ -106,17 +106,17 @@ LONGLONG types_extract_as_longlong(const struct dbg_lvalue* lvalue, if (issigned) *issigned = s; break; case SymTagPointerType: - if (!be_cpu->fetch_integer(lvalue, sizeof(void*), s = FALSE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, sizeof(void*), s = FALSE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case SymTagArrayType: case SymTagUDT: - if (!be_cpu->fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case SymTagEnum: /* FIXME: we don't handle enum size */ - if (!be_cpu->fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case SymTagFunctionType: @@ -173,7 +173,7 @@ BOOL types_store_value(struct dbg_lvalue* lvalue_to, const struct dbg_lvalue* lv } /* FIXME: should support floats as well */ val = types_extract_as_longlong(lvalue_from, NULL, &is_signed); - return be_cpu->store_integer(lvalue_to, size, is_signed, val); + return dbg_curr_process->be_cpu->store_integer(lvalue_to, size, is_signed, val); } /****************************************************************** @@ -302,9 +302,10 @@ BOOL types_array_index(const struct dbg_lvalue* lvalue, int index, struct dbg_lv result->addr = lvalue->addr; break; case SymTagPointerType: - if (!memory_read_value(lvalue, be_cpu->pointer_size, &result->addr.Offset)) return FALSE; + if (!memory_read_value(lvalue, dbg_curr_process->be_cpu->pointer_size, &result->addr.Offset)) + return FALSE; result->addr.Mode = AddrModeFlat; - switch (be_cpu->pointer_size) + switch (dbg_curr_process->be_cpu->pointer_size) { case 4: result->addr.Offset = (DWORD)result->addr.Offset; break; case 8: break; diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c index e0ad4d87516..b32b24cd0c9 100644 --- a/programs/winedbg/winedbg.c +++ b/programs/winedbg/winedbg.c @@ -241,7 +241,7 @@ const struct dbg_internal_var* dbg_get_internal_var(const char* name) { if (!strcmp(div->name, name)) return div; } - for (div = be_cpu->context_vars; div->name; div++) + for (div = dbg_curr_process->be_cpu->context_vars; div->name; div++) { if (!strcasecmp(div->name, name)) { @@ -279,6 +279,20 @@ struct dbg_process* dbg_get_process_h(HANDLE h) return NULL; } +#ifdef __i386__ +extern struct backend_cpu be_i386; +#elif defined(__powerpc__) +extern struct backend_cpu be_ppc; +#elif defined(__x86_64__) +extern struct backend_cpu be_x86_64; +#elif defined(__arm__) && !defined(__ARMEB__) +extern struct backend_cpu be_arm; +#elif defined(__aarch64__) && !defined(__AARCH64EB__) +extern struct backend_cpu be_arm64; +#else +# error CPU unknown +#endif + struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, HANDLE h) { struct dbg_process* p; @@ -318,6 +332,20 @@ struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, p->source_end_line = -1; list_add_head(&dbg_process_list, &p->entry); + +#ifdef __i386__ + p->be_cpu = &be_i386; +#elif defined(__powerpc__) + p->be_cpu = &be_ppc; +#elif defined(__x86_64__) + p->be_cpu = &be_x86_64; +#elif defined(__arm__) && !defined(__ARMEB__) + p->be_cpu = &be_arm; +#elif defined(__aarch64__) && !defined(__AARCH64EB__) + p->be_cpu = &be_arm64; +#else +# error CPU unknown +#endif return p; } @@ -609,40 +637,12 @@ static LONG CALLBACK top_filter( EXCEPTION_POINTERS *ptr ) return EXCEPTION_EXECUTE_HANDLER; } -struct backend_cpu* be_cpu; -#ifdef __i386__ -extern struct backend_cpu be_i386; -#elif defined(__powerpc__) -extern struct backend_cpu be_ppc; -#elif defined(__x86_64__) -extern struct backend_cpu be_x86_64; -#elif defined(__arm__) && !defined(__ARMEB__) -extern struct backend_cpu be_arm; -#elif defined(__aarch64__) && !defined(__AARCH64EB__) -extern struct backend_cpu be_arm64; -#else -# error CPU unknown -#endif - int main(int argc, char** argv) { int retv = 0; HANDLE hFile = INVALID_HANDLE_VALUE; enum dbg_start ds; -#ifdef __i386__ - be_cpu = &be_i386; -#elif defined(__powerpc__) - be_cpu = &be_ppc; -#elif defined(__x86_64__) - be_cpu = &be_x86_64; -#elif defined(__arm__) && !defined(__ARMEB__) - be_cpu = &be_arm; -#elif defined(__aarch64__) && !defined(__AARCH64EB__) - be_cpu = &be_arm64; -#else -# error CPU unknown -#endif /* Initialize the output */ dbg_houtput = GetStdHandle(STD_OUTPUT_HANDLE);