sync with trunk (r46275)

[reactos.git] / dll / win32 / dbghelp / dbghelp.c

diff --git a/dll/win32/dbghelp/dbghelp.c b/dll/win32/dbghelp/dbghelp.c
index 1bfc338..d9a828f 100644 (file)
--- a/dll/win32/dbghelp/dbghelp.c
+++ b/dll/win32/dbghelp/dbghelp.c
@@ -106,7 +106,7 @@ struct process*    process_find_by_handle(HANDLE hProcess)
  */
 BOOL validate_addr64(DWORD64 addr)
 {
-    if (addr >> 32)
+    if (sizeof(void*) == sizeof(int) && (addr >> 32))
     {
         FIXME("Unsupported address %s\n", wine_dbgstr_longlong(addr));
         SetLastError(ERROR_INVALID_PARAMETER);
@@ -133,6 +133,48 @@ void* fetch_buffer(struct process* pcs, unsigned size)
     return pcs->buffer;
 }
 
+const char* wine_dbgstr_addr(const ADDRESS64* addr)
+{
+    if (!addr) return "(null)";
+    switch (addr->Mode)
+    {
+    case AddrModeFlat:
+        return wine_dbg_sprintf("flat<%s>", wine_dbgstr_longlong(addr->Offset));
+    case AddrMode1616:
+        return wine_dbg_sprintf("1616<%04x:%04x>", addr->Segment, (DWORD)addr->Offset);
+    case AddrMode1632:
+        return wine_dbg_sprintf("1632<%04x:%08x>", addr->Segment, (DWORD)addr->Offset);
+    case AddrModeReal:
+        return wine_dbg_sprintf("real<%04x:%04x>", addr->Segment, (DWORD)addr->Offset);
+    default:
+        return "unknown";
+    }
+}
+
+extern struct cpu       cpu_i386, cpu_x86_64;
+
+static struct cpu*      dbghelp_cpus[] = {&cpu_i386, &cpu_x86_64, NULL};
+struct cpu*             dbghelp_current_cpu =
+#if defined(__i386__)
+    &cpu_i386
+#elif defined(__x86_64__)
+    &cpu_x86_64
+#else
+#error define support for your CPU
+#endif
+    ;
+
+struct cpu* cpu_find(DWORD machine)
+{
+    struct cpu** cpu;
+
+    for (cpu = dbghelp_cpus ; *cpu; cpu++)
+    {
+        if (cpu[0]->machine == machine) return cpu[0];
+    }
+    return NULL;
+}
+
 /******************************************************************
  *             SymSetSearchPathW (DBGHELP.@)
  *
@@ -211,16 +253,16 @@ BOOL WINAPI SymGetSearchPath(HANDLE hProcess, PSTR szSearchPath,
  * SymInitialize helper: loads in dbghelp all known (and loaded modules)
  * this assumes that hProcess is a handle on a valid process
  */
-static BOOL WINAPI process_invade_cb(PCSTR name, ULONG base, ULONG size, PVOID user)
+static BOOL WINAPI process_invade_cb(PCWSTR name, ULONG64 base, ULONG size, PVOID user)
 {
-    char        tmp[MAX_PATH];
+    WCHAR       tmp[MAX_PATH];
     HANDLE      hProcess = user;
 
-    if (!GetModuleFileNameExA(hProcess, (HMODULE)base, 
-                              tmp, sizeof(tmp)))
-        lstrcpynA(tmp, name, sizeof(tmp));
+    if (!GetModuleFileNameExW(hProcess, (HMODULE)(DWORD_PTR)base,
+                             tmp, sizeof(tmp) / sizeof(WCHAR)))
+        lstrcpynW(tmp, name, sizeof(tmp) / sizeof(WCHAR));
 
-    SymLoadModule(hProcess, 0, tmp, name, base, size);
+    SymLoadModuleExW(hProcess, 0, tmp, name, base, size, NULL, 0);
     return TRUE;
 }
 
@@ -232,7 +274,8 @@ static BOOL check_live_target(struct process* pcs)
 {
     if (!GetProcessId(pcs->handle)) return FALSE;
     if (GetEnvironmentVariableA("DBGHELP_NOLIVE", NULL, 0)) return FALSE;
-    elf_read_wine_loader_dbg_info(pcs);
+    if (!elf_read_wine_loader_dbg_info(pcs))
+        macho_read_wine_loader_dbg_info(pcs);
     return TRUE;
 }
 
@@ -325,8 +368,9 @@ BOOL WINAPI SymInitializeW(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeP
     if (check_live_target(pcs))
     {
         if (fInvadeProcess)
-            EnumerateLoadedModules(hProcess, process_invade_cb, hProcess);
+            EnumerateLoadedModulesW64(hProcess, process_invade_cb, hProcess);
         elf_synchronize_module_list(pcs);
+        macho_synchronize_module_list(pcs);
     }
     else if (fInvadeProcess)
     {
@@ -459,25 +503,25 @@ BOOL WINAPI SymSetContext(HANDLE hProcess, PIMAGEHLP_STACK_FRAME StackFrame,
  */
 static BOOL CALLBACK reg_cb64to32(HANDLE hProcess, ULONG action, ULONG64 data, ULONG64 user)
 {
-    PSYMBOL_REGISTERED_CALLBACK         cb32 = (PSYMBOL_REGISTERED_CALLBACK)(DWORD)(user >> 32);
-    DWORD                               user32 = (DWORD)user;
+    struct process*                     pcs = process_find_by_handle(hProcess);
     void*                               data32;
     IMAGEHLP_DEFERRED_SYMBOL_LOAD64*    idsl64;
     IMAGEHLP_DEFERRED_SYMBOL_LOAD       idsl;
 
+    if (!pcs) return FALSE;
     switch (action)
     {
     case CBA_DEBUG_INFO:
     case CBA_DEFERRED_SYMBOL_LOAD_CANCEL:
     case CBA_SET_OPTIONS:
     case CBA_SYMBOLS_UNLOADED:
-        data32 = (void*)(DWORD)data;
+        data32 = (void*)(DWORD_PTR)data;
         break;
     case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE:
     case CBA_DEFERRED_SYMBOL_LOAD_FAILURE:
     case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL:
     case CBA_DEFERRED_SYMBOL_LOAD_START:
-        idsl64 = (IMAGEHLP_DEFERRED_SYMBOL_LOAD64*)(DWORD)data;
+        idsl64 = (IMAGEHLP_DEFERRED_SYMBOL_LOAD64*)(DWORD_PTR)data;
         if (!validate_addr64(idsl64->BaseOfImage))
             return FALSE;
         idsl.SizeOfStruct = sizeof(idsl);
@@ -495,7 +539,7 @@ static BOOL CALLBACK reg_cb64to32(HANDLE hProcess, ULONG action, ULONG64 data, U
         FIXME("No mapping for action %u\n", action);
         return FALSE;
     }
-    return cb32(hProcess, action, data32, (PVOID)user32);
+    return pcs->reg_cb32(hProcess, action, data32, (PVOID)(DWORD_PTR)user);
 }
 
 /******************************************************************
@@ -522,7 +566,7 @@ BOOL pcs_callback(const struct process* pcs, ULONG action, void* data)
         case CBA_DEFERRED_SYMBOL_LOAD_FAILURE:
         case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL:
         case CBA_DEFERRED_SYMBOL_LOAD_START:
-            idslW = (IMAGEHLP_DEFERRED_SYMBOL_LOADW64*)(DWORD)data;
+            idslW = data;
             idsl.SizeOfStruct = sizeof(idsl);
             idsl.BaseOfImage = idslW->BaseOfImage;
             idsl.CheckSum = idslW->CheckSum;
@@ -548,14 +592,16 @@ BOOL pcs_callback(const struct process* pcs, ULONG action, void* data)
  *
  * Helper for registering a callback.
  */
-static BOOL sym_register_cb(HANDLE hProcess, 
+static BOOL sym_register_cb(HANDLE hProcess,
                             PSYMBOL_REGISTERED_CALLBACK64 cb,
+                            PSYMBOL_REGISTERED_CALLBACK cb32,
                             DWORD64 user, BOOL unicode)
 {
     struct process* pcs = process_find_by_handle(hProcess);
 
     if (!pcs) return FALSE;
     pcs->reg_cb = cb;
+    pcs->reg_cb32 = cb32;
     pcs->reg_is_unicode = unicode;
     pcs->reg_user = user;
 
@@ -569,10 +615,9 @@ BOOL WINAPI SymRegisterCallback(HANDLE hProcess,
                                 PSYMBOL_REGISTERED_CALLBACK CallbackFunction,
                                 PVOID UserContext)
 {
-    DWORD64 tmp = ((ULONGLONG)(DWORD)CallbackFunction << 32) | (DWORD)UserContext;
     TRACE("(%p, %p, %p)\n", 
           hProcess, CallbackFunction, UserContext);
-    return sym_register_cb(hProcess, reg_cb64to32, tmp, FALSE);
+    return sym_register_cb(hProcess, reg_cb64to32, CallbackFunction, (DWORD_PTR)UserContext, FALSE);
 }
 
 /***********************************************************************
@@ -584,7 +629,7 @@ BOOL WINAPI SymRegisterCallback64(HANDLE hProcess,
 {
     TRACE("(%p, %p, %s)\n", 
           hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext));
-    return sym_register_cb(hProcess, CallbackFunction, UserContext, FALSE);
+    return sym_register_cb(hProcess, CallbackFunction, NULL, UserContext, FALSE);
 }
 
 /***********************************************************************
@@ -596,7 +641,7 @@ BOOL WINAPI SymRegisterCallbackW64(HANDLE hProcess,
 {
     TRACE("(%p, %p, %s)\n", 
           hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext));
-    return sym_register_cb(hProcess, CallbackFunction, UserContext, TRUE);
+    return sym_register_cb(hProcess, CallbackFunction, NULL, UserContext, TRUE);
 }
 
 /* This is imagehlp version not dbghelp !! */