2 * File dbghelp.c - generic routines (process) for dbghelp DLL
4 * Copyright (C) 2004, Eric Pouech
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "dbghelp_private.h"
26 #include "wine/debug.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp
);
33 * - support for symbols' types is still partly missing
35 * + we should store the underlying type for an enum in the symt_enum struct
36 * + for enums, we store the names & values (associated to the enum type),
37 * but those values are not directly usable from a debugger (that's why, I
38 * assume, that we have also to define constants for enum values, as
40 * + SymEnumTypes should only return *user* defined types (UDT, typedefs...) not
41 * all the types stored/used in the modules (like char*)
42 * - SymGetLine{Next|Prev} don't work as expected (they don't seem to work across
43 * functions, and even across function blocks...). Basically, for *Next* to work
44 * it requires an address after the prolog of the func (the base address of the
46 * - most options (dbghelp_options) are not used (loading lines...)
47 * - in symbol lookup by name, we don't use RE everywhere we should. Moreover, when
48 * we're supposed to use RE, it doesn't make use of our hash tables. Therefore,
49 * we could use hash if name isn't a RE, and fall back to a full search when we
52 * + we should add parameters' types to the function's signature
53 * while processing a function's parameters
54 * + add support for function-less labels (as MSC seems to define them)
57 * + when, in a same module, the same definition is used in several compilation
58 * units, we get several definitions of the same object (especially
59 * struct/union). we should find a way not to duplicate them
60 * + in some cases (dlls/user/dialog16.c DIALOG_GetControl16), the same static
61 * global variable is defined several times (at different scopes). We are
62 * getting several of those while looking for a unique symbol. Part of the
63 * issue is that we don't give a scope to a static variable inside a function
67 unsigned dbghelp_options
= SYMOPT_UNDNAME
;
69 static struct process
* process_first
/* = NULL */;
71 /******************************************************************
72 * process_find_by_handle
75 struct process
* process_find_by_handle(HANDLE hProcess
)
79 for (p
= process_first
; p
&& p
->handle
!= hProcess
; p
= p
->next
);
80 if (!p
) SetLastError(ERROR_INVALID_HANDLE
);
84 /******************************************************************
85 * validate_addr64 (internal)
88 BOOL
validate_addr64(DWORD64 addr
)
90 if (sizeof(void*) == sizeof(int) && (addr
>> 32))
92 FIXME("Unsupported address %s\n", wine_dbgstr_longlong(addr
));
93 SetLastError(ERROR_INVALID_PARAMETER
);
99 /******************************************************************
102 * Ensures process' internal buffer is large enough.
104 void* fetch_buffer(struct process
* pcs
, unsigned size
)
106 if (size
> pcs
->buffer_size
)
109 pcs
->buffer
= HeapReAlloc(GetProcessHeap(), 0, pcs
->buffer
, size
);
111 pcs
->buffer
= HeapAlloc(GetProcessHeap(), 0, size
);
112 pcs
->buffer_size
= (pcs
->buffer
) ? size
: 0;
117 const char* wine_dbgstr_addr(const ADDRESS64
* addr
)
119 if (!addr
) return "(null)";
123 return wine_dbg_sprintf("flat<%s>", wine_dbgstr_longlong(addr
->Offset
));
125 return wine_dbg_sprintf("1616<%04x:%04x>", addr
->Segment
, (DWORD
)addr
->Offset
);
127 return wine_dbg_sprintf("1632<%04x:%08x>", addr
->Segment
, (DWORD
)addr
->Offset
);
129 return wine_dbg_sprintf("real<%04x:%04x>", addr
->Segment
, (DWORD
)addr
->Offset
);
135 extern struct cpu cpu_i386
, cpu_x86_64
, cpu_ppc
, cpu_arm
, cpu_arm64
;
137 static struct cpu
* dbghelp_cpus
[] = {&cpu_i386
, &cpu_x86_64
, &cpu_ppc
, &cpu_arm
, &cpu_arm64
, NULL
};
138 struct cpu
* dbghelp_current_cpu
=
139 #if defined(__i386__)
141 #elif defined(__x86_64__)
143 #elif defined(__powerpc__)
145 #elif defined(__arm__)
147 #elif defined(__aarch64__)
150 #error define support for your CPU
154 struct cpu
* cpu_find(DWORD machine
)
158 for (cpu
= dbghelp_cpus
; *cpu
; cpu
++)
160 if (cpu
[0]->machine
== machine
) return cpu
[0];
165 /******************************************************************
166 * SymSetSearchPathW (DBGHELP.@)
169 BOOL WINAPI
SymSetSearchPathW(HANDLE hProcess
, PCWSTR searchPath
)
171 struct process
* pcs
= process_find_by_handle(hProcess
);
173 if (!pcs
) return FALSE
;
174 if (!searchPath
) return FALSE
;
176 HeapFree(GetProcessHeap(), 0, pcs
->search_path
);
177 pcs
->search_path
= lstrcpyW(HeapAlloc(GetProcessHeap(), 0,
178 (lstrlenW(searchPath
) + 1) * sizeof(WCHAR
)),
183 /******************************************************************
184 * SymSetSearchPath (DBGHELP.@)
187 BOOL WINAPI
SymSetSearchPath(HANDLE hProcess
, PCSTR searchPath
)
193 len
= MultiByteToWideChar(CP_ACP
, 0, searchPath
, -1, NULL
, 0);
194 if ((sp
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
))))
196 MultiByteToWideChar(CP_ACP
, 0, searchPath
, -1, sp
, len
);
198 ret
= SymSetSearchPathW(hProcess
, sp
);
199 HeapFree(GetProcessHeap(), 0, sp
);
204 /***********************************************************************
205 * SymGetSearchPathW (DBGHELP.@)
207 BOOL WINAPI
SymGetSearchPathW(HANDLE hProcess
, PWSTR szSearchPath
,
208 DWORD SearchPathLength
)
210 struct process
* pcs
= process_find_by_handle(hProcess
);
211 if (!pcs
) return FALSE
;
213 lstrcpynW(szSearchPath
, pcs
->search_path
, SearchPathLength
);
217 /***********************************************************************
218 * SymGetSearchPath (DBGHELP.@)
220 BOOL WINAPI
SymGetSearchPath(HANDLE hProcess
, PSTR szSearchPath
,
221 DWORD SearchPathLength
)
223 WCHAR
* buffer
= HeapAlloc(GetProcessHeap(), 0, SearchPathLength
* sizeof(WCHAR
));
228 ret
= SymGetSearchPathW(hProcess
, buffer
, SearchPathLength
);
230 WideCharToMultiByte(CP_ACP
, 0, buffer
, SearchPathLength
,
231 szSearchPath
, SearchPathLength
, NULL
, NULL
);
232 HeapFree(GetProcessHeap(), 0, buffer
);
237 /******************************************************************
240 * SymInitialize helper: loads in dbghelp all known (and loaded modules)
241 * this assumes that hProcess is a handle on a valid process
243 static BOOL WINAPI
process_invade_cb(PCWSTR name
, ULONG64 base
, ULONG size
, PVOID user
)
246 HANDLE hProcess
= user
;
248 if (!GetModuleFileNameExW(hProcess
, (HMODULE
)(DWORD_PTR
)base
, tmp
, ARRAY_SIZE(tmp
)))
249 lstrcpynW(tmp
, name
, ARRAY_SIZE(tmp
));
251 SymLoadModuleExW(hProcess
, 0, tmp
, name
, base
, size
, NULL
, 0);
255 /******************************************************************
259 static BOOL
check_live_target(struct process
* pcs
)
261 if (!GetProcessId(pcs
->handle
)) return FALSE
;
262 if (GetEnvironmentVariableA("DBGHELP_NOLIVE", NULL
, 0)) return FALSE
;
263 if (!elf_read_wine_loader_dbg_info(pcs
))
264 macho_read_wine_loader_dbg_info(pcs
);
268 /******************************************************************
269 * SymInitializeW (DBGHELP.@)
271 * The initialisation of a dbghelp's context.
272 * Note that hProcess doesn't need to be a valid process handle (except
273 * when fInvadeProcess is TRUE).
274 * Since we also allow loading ELF (pure) libraries and Wine ELF libraries
275 * containing PE (and NE) module(s), here's how we handle it:
276 * - we load every module (ELF, NE, PE) passed in SymLoadModule
277 * - in fInvadeProcess (in SymInitialize) is TRUE, we set up what is called ELF
278 * synchronization: hProcess should be a valid process handle, and we hook
279 * ourselves on hProcess's loaded ELF-modules, and keep this list in sync with
280 * our internal ELF modules representation (loading / unloading). This way,
281 * we'll pair every loaded builtin PE module with its ELF counterpart (and
282 * access its debug information).
283 * - if fInvadeProcess (in SymInitialize) is FALSE, we check anyway if the
284 * hProcess refers to a running process. We use some heuristics here, so YMMV.
285 * If we detect a live target, then we get the same handling as if
286 * fInvadeProcess is TRUE (except that the modules are not loaded). Otherwise,
287 * we won't be able to make the peering between a builtin PE module and its ELF
288 * counterpart. Hence we won't be able to provide the requested debug
289 * information. We'll however be able to load native PE modules (and their
290 * debug information) without any trouble.
291 * Note also that this scheme can be intertwined with the deferred loading
292 * mechanism (ie only load the debug information when we actually need it).
294 BOOL WINAPI
SymInitializeW(HANDLE hProcess
, PCWSTR UserSearchPath
, BOOL fInvadeProcess
)
297 BOOL wow64
, child_wow64
;
299 TRACE("(%p %s %u)\n", hProcess
, debugstr_w(UserSearchPath
), fInvadeProcess
);
301 if (process_find_by_handle(hProcess
)){
302 WARN("the symbols for this process have already been initialized!\n");
304 /* MSDN says to only call this function once unless SymCleanup() has been called since the last call.
305 It also says to call SymRefreshModuleList() instead if you just want the module list refreshed.
306 Native still returns TRUE even if the process has already been initialized. */
310 pcs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*pcs
));
311 if (!pcs
) return FALSE
;
313 pcs
->handle
= hProcess
;
315 IsWow64Process(GetCurrentProcess(), &wow64
);
317 if (!IsWow64Process(hProcess
, &child_wow64
))
319 pcs
->is_64bit
= (sizeof(void *) == 8 || wow64
) && !child_wow64
;
323 pcs
->search_path
= lstrcpyW(HeapAlloc(GetProcessHeap(), 0,
324 (lstrlenW(UserSearchPath
) + 1) * sizeof(WCHAR
)),
331 static const WCHAR sym_path
[] = {'_','N','T','_','S','Y','M','B','O','L','_','P','A','T','H',0};
332 static const WCHAR alt_sym_path
[] = {'_','N','T','_','A','L','T','E','R','N','A','T','E','_','S','Y','M','B','O','L','_','P','A','T','H',0};
334 pcs
->search_path
= HeapAlloc(GetProcessHeap(), 0, (len
= MAX_PATH
) * sizeof(WCHAR
));
335 while ((size
= GetCurrentDirectoryW(len
, pcs
->search_path
)) >= len
)
336 pcs
->search_path
= HeapReAlloc(GetProcessHeap(), 0, pcs
->search_path
, (len
*= 2) * sizeof(WCHAR
));
337 pcs
->search_path
= HeapReAlloc(GetProcessHeap(), 0, pcs
->search_path
, (size
+ 1) * sizeof(WCHAR
));
339 len
= GetEnvironmentVariableW(sym_path
, NULL
, 0);
342 pcs
->search_path
= HeapReAlloc(GetProcessHeap(), 0, pcs
->search_path
, (size
+ 1 + len
+ 1) * sizeof(WCHAR
));
343 pcs
->search_path
[size
] = ';';
344 GetEnvironmentVariableW(sym_path
, pcs
->search_path
+ size
+ 1, len
);
347 len
= GetEnvironmentVariableW(alt_sym_path
, NULL
, 0);
350 pcs
->search_path
= HeapReAlloc(GetProcessHeap(), 0, pcs
->search_path
, (size
+ 1 + len
+ 1) * sizeof(WCHAR
));
351 pcs
->search_path
[size
] = ';';
352 GetEnvironmentVariableW(alt_sym_path
, pcs
->search_path
+ size
+ 1, len
);
356 pcs
->lmodules
= NULL
;
357 pcs
->dbg_hdr_addr
= 0;
358 pcs
->next
= process_first
;
361 if (check_live_target(pcs
))
364 EnumerateLoadedModulesW64(hProcess
, process_invade_cb
, hProcess
);
365 elf_synchronize_module_list(pcs
);
366 macho_synchronize_module_list(pcs
);
368 else if (fInvadeProcess
)
370 SymCleanup(hProcess
);
371 SetLastError(ERROR_INVALID_PARAMETER
);
378 /******************************************************************
379 * SymInitialize (DBGHELP.@)
383 BOOL WINAPI
SymInitialize(HANDLE hProcess
, PCSTR UserSearchPath
, BOOL fInvadeProcess
)
392 len
= MultiByteToWideChar(CP_ACP
, 0, UserSearchPath
, -1, NULL
, 0);
393 sp
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
394 MultiByteToWideChar(CP_ACP
, 0, UserSearchPath
, -1, sp
, len
);
397 ret
= SymInitializeW(hProcess
, sp
, fInvadeProcess
);
398 HeapFree(GetProcessHeap(), 0, sp
);
402 /******************************************************************
403 * SymCleanup (DBGHELP.@)
406 BOOL WINAPI
SymCleanup(HANDLE hProcess
)
408 struct process
** ppcs
;
409 struct process
* next
;
411 for (ppcs
= &process_first
; *ppcs
; ppcs
= &(*ppcs
)->next
)
413 if ((*ppcs
)->handle
== hProcess
)
415 while ((*ppcs
)->lmodules
) module_remove(*ppcs
, (*ppcs
)->lmodules
);
417 HeapFree(GetProcessHeap(), 0, (*ppcs
)->search_path
);
418 next
= (*ppcs
)->next
;
419 HeapFree(GetProcessHeap(), 0, *ppcs
);
425 ERR("this process has not had SymInitialize() called for it!\n");
429 /******************************************************************
430 * SymSetOptions (DBGHELP.@)
433 DWORD WINAPI
SymSetOptions(DWORD opts
)
437 for (pcs
= process_first
; pcs
; pcs
= pcs
->next
)
439 pcs_callback(pcs
, CBA_SET_OPTIONS
, &opts
);
441 return dbghelp_options
= opts
;
444 /******************************************************************
445 * SymGetOptions (DBGHELP.@)
448 DWORD WINAPI
SymGetOptions(void)
450 return dbghelp_options
;
453 /******************************************************************
454 * SymSetParentWindow (DBGHELP.@)
457 BOOL WINAPI
SymSetParentWindow(HWND hwnd
)
459 /* Save hwnd so it can be used as parent window */
460 FIXME("(%p): stub\n", hwnd
);
464 /******************************************************************
465 * SymSetContext (DBGHELP.@)
468 BOOL WINAPI
SymSetContext(HANDLE hProcess
, PIMAGEHLP_STACK_FRAME StackFrame
,
469 PIMAGEHLP_CONTEXT Context
)
471 struct process
* pcs
= process_find_by_handle(hProcess
);
472 if (!pcs
) return FALSE
;
474 if (pcs
->ctx_frame
.ReturnOffset
== StackFrame
->ReturnOffset
&&
475 pcs
->ctx_frame
.FrameOffset
== StackFrame
->FrameOffset
&&
476 pcs
->ctx_frame
.StackOffset
== StackFrame
->StackOffset
)
478 TRACE("Setting same frame {rtn=%s frm=%s stk=%s}\n",
479 wine_dbgstr_longlong(pcs
->ctx_frame
.ReturnOffset
),
480 wine_dbgstr_longlong(pcs
->ctx_frame
.FrameOffset
),
481 wine_dbgstr_longlong(pcs
->ctx_frame
.StackOffset
));
482 pcs
->ctx_frame
.InstructionOffset
= StackFrame
->InstructionOffset
;
483 SetLastError(ERROR_ACCESS_DENIED
); /* latest MSDN says ERROR_SUCCESS */
487 pcs
->ctx_frame
= *StackFrame
;
488 /* MSDN states that Context is not (no longer?) used */
492 /******************************************************************
493 * reg_cb64to32 (internal)
495 * Registered callback for converting information from 64 bit to 32 bit
497 static BOOL CALLBACK
reg_cb64to32(HANDLE hProcess
, ULONG action
, ULONG64 data
, ULONG64 user
)
499 struct process
* pcs
= process_find_by_handle(hProcess
);
501 IMAGEHLP_DEFERRED_SYMBOL_LOAD64
* idsl64
;
502 IMAGEHLP_DEFERRED_SYMBOL_LOAD idsl
;
504 if (!pcs
) return FALSE
;
508 case CBA_DEFERRED_SYMBOL_LOAD_CANCEL
:
509 case CBA_SET_OPTIONS
:
510 case CBA_SYMBOLS_UNLOADED
:
511 data32
= (void*)(DWORD_PTR
)data
;
513 case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE
:
514 case CBA_DEFERRED_SYMBOL_LOAD_FAILURE
:
515 case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL
:
516 case CBA_DEFERRED_SYMBOL_LOAD_START
:
517 idsl64
= (IMAGEHLP_DEFERRED_SYMBOL_LOAD64
*)(DWORD_PTR
)data
;
518 if (!validate_addr64(idsl64
->BaseOfImage
))
520 idsl
.SizeOfStruct
= sizeof(idsl
);
521 idsl
.BaseOfImage
= (DWORD
)idsl64
->BaseOfImage
;
522 idsl
.CheckSum
= idsl64
->CheckSum
;
523 idsl
.TimeDateStamp
= idsl64
->TimeDateStamp
;
524 memcpy(idsl
.FileName
, idsl64
->FileName
, sizeof(idsl
.FileName
));
525 idsl
.Reparse
= idsl64
->Reparse
;
528 case CBA_DUPLICATE_SYMBOL
:
530 case CBA_READ_MEMORY
:
532 FIXME("No mapping for action %u\n", action
);
535 return pcs
->reg_cb32(hProcess
, action
, data32
, (PVOID
)(DWORD_PTR
)user
);
538 /******************************************************************
539 * pcs_callback (internal)
541 BOOL
pcs_callback(const struct process
* pcs
, ULONG action
, void* data
)
543 IMAGEHLP_DEFERRED_SYMBOL_LOAD64 idsl
;
545 TRACE("%p %u %p\n", pcs
, action
, data
);
547 if (!pcs
->reg_cb
) return FALSE
;
548 if (!pcs
->reg_is_unicode
)
550 IMAGEHLP_DEFERRED_SYMBOL_LOADW64
* idslW
;
555 case CBA_DEFERRED_SYMBOL_LOAD_CANCEL
:
556 case CBA_SET_OPTIONS
:
557 case CBA_SYMBOLS_UNLOADED
:
559 case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE
:
560 case CBA_DEFERRED_SYMBOL_LOAD_FAILURE
:
561 case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL
:
562 case CBA_DEFERRED_SYMBOL_LOAD_START
:
564 idsl
.SizeOfStruct
= sizeof(idsl
);
565 idsl
.BaseOfImage
= idslW
->BaseOfImage
;
566 idsl
.CheckSum
= idslW
->CheckSum
;
567 idsl
.TimeDateStamp
= idslW
->TimeDateStamp
;
568 WideCharToMultiByte(CP_ACP
, 0, idslW
->FileName
, -1,
569 idsl
.FileName
, sizeof(idsl
.FileName
), NULL
, NULL
);
570 idsl
.Reparse
= idslW
->Reparse
;
573 case CBA_DUPLICATE_SYMBOL
:
575 case CBA_READ_MEMORY
:
577 FIXME("No mapping for action %u\n", action
);
581 return pcs
->reg_cb(pcs
->handle
, action
, (ULONG64
)(DWORD_PTR
)data
, pcs
->reg_user
);
584 /******************************************************************
587 * Helper for registering a callback.
589 static BOOL
sym_register_cb(HANDLE hProcess
,
590 PSYMBOL_REGISTERED_CALLBACK64 cb
,
591 PSYMBOL_REGISTERED_CALLBACK cb32
,
592 DWORD64 user
, BOOL unicode
)
594 struct process
* pcs
= process_find_by_handle(hProcess
);
596 if (!pcs
) return FALSE
;
598 pcs
->reg_cb32
= cb32
;
599 pcs
->reg_is_unicode
= unicode
;
600 pcs
->reg_user
= user
;
605 /***********************************************************************
606 * SymRegisterCallback (DBGHELP.@)
608 BOOL WINAPI
SymRegisterCallback(HANDLE hProcess
,
609 PSYMBOL_REGISTERED_CALLBACK CallbackFunction
,
612 TRACE("(%p, %p, %p)\n",
613 hProcess
, CallbackFunction
, UserContext
);
614 return sym_register_cb(hProcess
, reg_cb64to32
, CallbackFunction
, (DWORD_PTR
)UserContext
, FALSE
);
617 /***********************************************************************
618 * SymRegisterCallback64 (DBGHELP.@)
620 BOOL WINAPI
SymRegisterCallback64(HANDLE hProcess
,
621 PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction
,
624 TRACE("(%p, %p, %s)\n",
625 hProcess
, CallbackFunction
, wine_dbgstr_longlong(UserContext
));
626 return sym_register_cb(hProcess
, CallbackFunction
, NULL
, UserContext
, FALSE
);
629 /***********************************************************************
630 * SymRegisterCallbackW64 (DBGHELP.@)
632 BOOL WINAPI
SymRegisterCallbackW64(HANDLE hProcess
,
633 PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction
,
636 TRACE("(%p, %p, %s)\n",
637 hProcess
, CallbackFunction
, wine_dbgstr_longlong(UserContext
));
638 return sym_register_cb(hProcess
, CallbackFunction
, NULL
, UserContext
, TRUE
);
641 /* This is imagehlp version not dbghelp !! */
642 static API_VERSION api_version
= { 4, 0, 2, 0 };
644 /***********************************************************************
645 * ImagehlpApiVersion (DBGHELP.@)
647 LPAPI_VERSION WINAPI
ImagehlpApiVersion(VOID
)
652 /***********************************************************************
653 * ImagehlpApiVersionEx (DBGHELP.@)
655 LPAPI_VERSION WINAPI
ImagehlpApiVersionEx(LPAPI_VERSION AppVersion
)
657 if (!AppVersion
) return NULL
;
659 AppVersion
->MajorVersion
= api_version
.MajorVersion
;
660 AppVersion
->MinorVersion
= api_version
.MinorVersion
;
661 AppVersion
->Revision
= api_version
.Revision
;
662 AppVersion
->Reserved
= api_version
.Reserved
;
667 /******************************************************************
668 * ExtensionApiVersion (DBGHELP.@)
670 LPEXT_API_VERSION WINAPI
ExtensionApiVersion(void)
672 static EXT_API_VERSION eav
= {5, 5, 5, 0};
676 /******************************************************************
677 * WinDbgExtensionDllInit (DBGHELP.@)
679 void WINAPI
WinDbgExtensionDllInit(PWINDBG_EXTENSION_APIS lpExtensionApis
,
680 unsigned short major
, unsigned short minor
)