Skip to content
Snippets Groups Projects
Commit 88520041 authored by eric pouech's avatar eric pouech Committed by Alexandre Julliard
Browse files

winedbg: Use SymSetScopeFromAddr() instead of SymSetContext().


This allows to simplify a bit the frame internal storage
(no longer using IMAGEHLP_STACK_FRAME structure).

Signed-off-by: default avatarEric Pouech <eric.pouech@gmail.com>
Signed-off-by: Alexandre Julliard's avatarAlexandre Julliard <julliard@winehq.org>
parent 83f85f5c
No related branches found
No related tags found
No related merge requests found
...@@ -386,7 +386,6 @@ extern void source_free_files(struct dbg_process* p); ...@@ -386,7 +386,6 @@ extern void source_free_files(struct dbg_process* p);
extern void stack_info(int len); extern void stack_info(int len);
extern void stack_backtrace(DWORD threadID); extern void stack_backtrace(DWORD threadID);
extern BOOL stack_set_frame(int newframe); extern BOOL stack_set_frame(int newframe);
extern BOOL stack_get_current_frame(IMAGEHLP_STACK_FRAME* ihsf);
extern BOOL stack_get_register_frame(const struct dbg_internal_var* div, DWORD_PTR** pval); extern BOOL stack_get_register_frame(const struct dbg_internal_var* div, DWORD_PTR** pval);
extern unsigned stack_fetch_frames(const dbg_ctx_t *ctx); extern unsigned stack_fetch_frames(const dbg_ctx_t *ctx);
extern BOOL stack_get_current_symbol(SYMBOL_INFO* sym); extern BOOL stack_get_current_symbol(SYMBOL_INFO* sym);
......
...@@ -64,6 +64,26 @@ void stack_info(int len) ...@@ -64,6 +64,26 @@ void stack_info(int len)
} }
} }
static BOOL stack_set_local_scope(void)
{
struct dbg_frame* frm = stack_get_thread_frame(dbg_curr_thread, dbg_curr_thread->curr_frame);
if (!frm) return FALSE;
/* if we're not the first frame, linear_pc is the return address
* after the call instruction (at least on most processors I know of).
* However, there are cases where this address is outside of the
* current function or inline site.
* This happens when the called function is marked <NO RETURN>, in which
* case the compiler can omit the epilog (gcc 4 does it).
* This happens also for inline sites, where the epilog (of the inline
* site) isn't present.
* Therefore, we decrement linear_pc in order to ensure that
* the considered address is really inside the current function or inline site.
*/
return SymSetScopeFromAddr(dbg_curr_process->handle,
(dbg_curr_thread->curr_frame) ? frm->linear_pc - 1 : frm->linear_pc);
}
static BOOL stack_set_frame_internal(int newframe) static BOOL stack_set_frame_internal(int newframe)
{ {
if (newframe >= dbg_curr_thread->num_frames) if (newframe >= dbg_curr_thread->num_frames)
...@@ -73,42 +93,12 @@ static BOOL stack_set_frame_internal(int newframe) ...@@ -73,42 +93,12 @@ static BOOL stack_set_frame_internal(int newframe)
if (dbg_curr_thread->curr_frame != newframe) if (dbg_curr_thread->curr_frame != newframe)
{ {
IMAGEHLP_STACK_FRAME ihsf;
dbg_curr_thread->curr_frame = newframe; dbg_curr_thread->curr_frame = newframe;
stack_get_current_frame(&ihsf); stack_set_local_scope();
SymSetContext(dbg_curr_process->handle, &ihsf, NULL);
} }
return TRUE; return TRUE;
} }
static BOOL stack_get_frame(int nf, IMAGEHLP_STACK_FRAME* ihsf)
{
memset(ihsf, 0, sizeof(*ihsf));
ihsf->InstructionOffset = dbg_curr_thread->frames[nf].linear_pc;
/* if we're not the first frame, InstructionOffset is the return address
* after the call instruction (at least on most processors I know of).
* However, there are cases where this address is outside of the current function.
* This happens when the called function is marked <NO RETURN>, in which
* case the compiler can omit the epilog (gcc 4 does it)
* Therefore, we decrement InstructionOffset in order to ensure that
* the considered address is really inside the current function.
*/
if (nf) ihsf->InstructionOffset--;
ihsf->FrameOffset = dbg_curr_thread->frames[nf].linear_frame;
ihsf->StackOffset = dbg_curr_thread->frames[nf].linear_stack;
return TRUE;
}
BOOL stack_get_current_frame(IMAGEHLP_STACK_FRAME* ihsf)
{
/*
* If we don't have a valid backtrace, then just return.
*/
if (dbg_curr_thread->frames == NULL) return FALSE;
return stack_get_frame(dbg_curr_thread->curr_frame, ihsf);
}
BOOL stack_get_register_frame(const struct dbg_internal_var* div, DWORD_PTR** pval) BOOL stack_get_register_frame(const struct dbg_internal_var* div, DWORD_PTR** pval)
{ {
struct dbg_frame* currfrm = stack_get_curr_frame(); struct dbg_frame* currfrm = stack_get_curr_frame();
...@@ -155,12 +145,11 @@ BOOL stack_set_frame(int newframe) ...@@ -155,12 +145,11 @@ BOOL stack_set_frame(int newframe)
*/ */
BOOL stack_get_current_symbol(SYMBOL_INFO* symbol) BOOL stack_get_current_symbol(SYMBOL_INFO* symbol)
{ {
IMAGEHLP_STACK_FRAME ihsf;
DWORD64 disp; DWORD64 disp;
struct dbg_frame* frm = stack_get_curr_frame();
if (!stack_get_current_frame(&ihsf)) return FALSE; if (frm == NULL) return FALSE;
return SymFromAddr(dbg_curr_process->handle, ihsf.InstructionOffset, return SymFromAddr(dbg_curr_process->handle, frm->linear_pc, &disp, symbol);
&disp, symbol);
} }
static BOOL CALLBACK stack_read_mem(HANDLE hProc, DWORD64 addr, static BOOL CALLBACK stack_read_mem(HANDLE hProc, DWORD64 addr,
...@@ -260,27 +249,26 @@ static BOOL WINAPI sym_enum_cb(PSYMBOL_INFO sym_info, ULONG size, PVOID user) ...@@ -260,27 +249,26 @@ static BOOL WINAPI sym_enum_cb(PSYMBOL_INFO sym_info, ULONG size, PVOID user)
return TRUE; return TRUE;
} }
static void stack_print_addr_and_args(int nf) static void stack_print_addr_and_args(void)
{ {
char buffer[sizeof(SYMBOL_INFO) + 256]; char buffer[sizeof(SYMBOL_INFO) + 256];
SYMBOL_INFO* si = (SYMBOL_INFO*)buffer; SYMBOL_INFO* si = (SYMBOL_INFO*)buffer;
IMAGEHLP_STACK_FRAME ihsf;
IMAGEHLP_LINE64 il; IMAGEHLP_LINE64 il;
IMAGEHLP_MODULE im; IMAGEHLP_MODULE im;
DWORD64 disp64; DWORD64 disp64;
struct dbg_frame* frm = stack_get_curr_frame();
print_bare_address(&dbg_curr_thread->frames[nf].addr_pc); if (!frm) return;
print_bare_address(&frm->addr_pc);
stack_get_frame(nf, &ihsf);
/* grab module where symbol is. If we don't have a module, we cannot print more */ /* grab module where symbol is. If we don't have a module, we cannot print more */
im.SizeOfStruct = sizeof(im); im.SizeOfStruct = sizeof(im);
if (!SymGetModuleInfo(dbg_curr_process->handle, ihsf.InstructionOffset, &im)) if (!SymGetModuleInfo(dbg_curr_process->handle, frm->linear_pc, &im))
return; return;
si->SizeOfStruct = sizeof(*si); si->SizeOfStruct = sizeof(*si);
si->MaxNameLen = 256; si->MaxNameLen = 256;
if (SymFromAddr(dbg_curr_process->handle, ihsf.InstructionOffset, &disp64, si)) if (SymFromAddr(dbg_curr_process->handle, frm->linear_pc, &disp64, si))
{ {
struct sym_enum se; struct sym_enum se;
DWORD disp; DWORD disp;
...@@ -288,21 +276,19 @@ static void stack_print_addr_and_args(int nf) ...@@ -288,21 +276,19 @@ static void stack_print_addr_and_args(int nf)
dbg_printf(" %s", si->Name); dbg_printf(" %s", si->Name);
if (disp64) dbg_printf("+0x%I64x", disp64); if (disp64) dbg_printf("+0x%I64x", disp64);
SymSetContext(dbg_curr_process->handle, &ihsf, NULL); stack_set_local_scope();
se.first = TRUE; se.first = TRUE;
se.frame = ihsf.FrameOffset; se.frame = frm->linear_frame;
dbg_printf("("); dbg_printf("(");
SymEnumSymbols(dbg_curr_process->handle, 0, NULL, sym_enum_cb, &se); SymEnumSymbols(dbg_curr_process->handle, 0, NULL, sym_enum_cb, &se);
dbg_printf(")"); dbg_printf(")");
il.SizeOfStruct = sizeof(il); il.SizeOfStruct = sizeof(il);
if (SymGetLineFromAddr64(dbg_curr_process->handle, if (SymGetLineFromAddr64(dbg_curr_process->handle, frm->linear_pc, &disp, &il))
ihsf.InstructionOffset, &disp, &il))
dbg_printf(" [%s:%u]", il.FileName, il.LineNumber); dbg_printf(" [%s:%u]", il.FileName, il.LineNumber);
dbg_printf(" in %s", im.ModuleName); dbg_printf(" in %s", im.ModuleName);
} }
else dbg_printf(" in %s (+0x%I64x)", else dbg_printf(" in %s (+0x%Ix)", im.ModuleName, frm->linear_pc - im.BaseOfImage);
im.ModuleName, ihsf.InstructionOffset - im.BaseOfImage);
} }
/****************************************************************** /******************************************************************
...@@ -313,7 +299,6 @@ static void stack_print_addr_and_args(int nf) ...@@ -313,7 +299,6 @@ static void stack_print_addr_and_args(int nf)
static void backtrace(void) static void backtrace(void)
{ {
unsigned cf = dbg_curr_thread->curr_frame; unsigned cf = dbg_curr_thread->curr_frame;
IMAGEHLP_STACK_FRAME ihsf;
dbg_printf("Backtrace:\n"); dbg_printf("Backtrace:\n");
for (dbg_curr_thread->curr_frame = 0; for (dbg_curr_thread->curr_frame = 0;
...@@ -323,7 +308,7 @@ static void backtrace(void) ...@@ -323,7 +308,7 @@ static void backtrace(void)
dbg_printf("%s%d ", dbg_printf("%s%d ",
(cf == dbg_curr_thread->curr_frame ? "=>" : " "), (cf == dbg_curr_thread->curr_frame ? "=>" : " "),
dbg_curr_thread->curr_frame); dbg_curr_thread->curr_frame);
stack_print_addr_and_args(dbg_curr_thread->curr_frame); stack_print_addr_and_args();
dbg_printf(" ("); dbg_printf(" (");
print_bare_address(&dbg_curr_thread->frames[dbg_curr_thread->curr_frame].addr_frame); print_bare_address(&dbg_curr_thread->frames[dbg_curr_thread->curr_frame].addr_frame);
dbg_printf(")\n"); dbg_printf(")\n");
...@@ -331,8 +316,7 @@ static void backtrace(void) ...@@ -331,8 +316,7 @@ static void backtrace(void)
/* reset context to current stack frame */ /* reset context to current stack frame */
dbg_curr_thread->curr_frame = cf; dbg_curr_thread->curr_frame = cf;
if (!dbg_curr_thread->frames) return; if (!dbg_curr_thread->frames) return;
stack_get_frame(dbg_curr_thread->curr_frame, &ihsf); stack_set_local_scope();
SymSetContext(dbg_curr_process->handle, &ihsf, NULL);
} }
/****************************************************************** /******************************************************************
......
...@@ -366,7 +366,7 @@ enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno, ...@@ -366,7 +366,7 @@ enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno,
int i; int i;
char buffer[512]; char buffer[512];
BOOL opt; BOOL opt;
IMAGEHLP_STACK_FRAME ihsf; struct dbg_frame* frm;
if (strlen(name) + 4 > sizeof(buffer)) if (strlen(name) + 4 > sizeof(buffer))
{ {
...@@ -421,9 +421,9 @@ enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno, ...@@ -421,9 +421,9 @@ enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno,
SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt); SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
/* now grab local symbols */ /* now grab local symbols */
if (stack_get_current_frame(&ihsf) && sgv.num < NUMDBGV) if ((frm = stack_get_curr_frame()) && sgv.num < NUMDBGV)
{ {
sgv.frame_offset = ihsf.FrameOffset; sgv.frame_offset = frm->linear_frame;
SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv); SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv);
} }
...@@ -491,16 +491,16 @@ enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno, ...@@ -491,16 +491,16 @@ enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno,
BOOL symbol_is_local(const char* name) BOOL symbol_is_local(const char* name)
{ {
struct sgv_data sgv; struct sgv_data sgv;
IMAGEHLP_STACK_FRAME ihsf; struct dbg_frame* frm;
sgv.num = 0; sgv.num = 0;
sgv.num_thunks = 0; sgv.num_thunks = 0;
sgv.name = name; sgv.name = name;
sgv.do_thunks = FALSE; sgv.do_thunks = FALSE;
if (stack_get_current_frame(&ihsf)) if ((frm = stack_get_curr_frame()))
{ {
sgv.frame_offset = ihsf.FrameOffset; sgv.frame_offset = frm->linear_frame;
SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv); SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv);
} }
return sgv.num > 0; return sgv.num > 0;
...@@ -748,15 +748,16 @@ static BOOL CALLBACK info_locals_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx) ...@@ -748,15 +748,16 @@ static BOOL CALLBACK info_locals_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
BOOL symbol_info_locals(void) BOOL symbol_info_locals(void)
{ {
IMAGEHLP_STACK_FRAME ihsf;
ADDRESS64 addr; ADDRESS64 addr;
struct dbg_frame* frm;
if (!(frm = stack_get_curr_frame())) return FALSE;
stack_get_current_frame(&ihsf);
addr.Mode = AddrModeFlat; addr.Mode = AddrModeFlat;
addr.Offset = ihsf.InstructionOffset; addr.Offset = frm->linear_pc;
print_address(&addr, FALSE); print_address(&addr, FALSE);
dbg_printf(": (%0*lx)\n", ADDRWIDTH, (DWORD_PTR)ihsf.FrameOffset); dbg_printf(": (%0*lx)\n", ADDRWIDTH, (DWORD_PTR)frm->linear_frame);
SymEnumSymbols(dbg_curr_process->handle, 0, NULL, info_locals_cb, (void*)(DWORD_PTR)ihsf.FrameOffset); SymEnumSymbols(dbg_curr_process->handle, 0, NULL, info_locals_cb, (void*)frm->linear_frame);
return TRUE; return TRUE;
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment