dlls/dbghelp/dbghelp.c

   1 /*
   2  * File dbghelp.c - generic routines (process) for dbghelp DLL
   3  *
   4  * Copyright (C) 2004, Eric Pouech
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  */
  20
  21 #include "config.h"
  22
  23 #include "dbghelp_private.h"
  24 #include "winerror.h"
  25 #include "psapi.h"
  26 #include "wine/debug.h"
  27 #include "wdbgexts.h"
  28 #include "winnls.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  31
  32 /* TODO
  33  *  - support for symbols' types is still partly missing
  34  *      + C++ support
  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
  39  *        Codeview does BTW.
  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
  45  *    func doesn't work)
  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
  50  *    get a full RE
  51  *  - msc:
  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)
  55  *      + C++ management
  56  *  - stabs:
  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
  64  *      + C++ management
  65  */
  66
  67 unsigned   dbghelp_options = SYMOPT_UNDNAME;
  68
  69 static struct process* process_first /* = NULL */;
  70
  71 /******************************************************************
  72  *              process_find_by_handle
  73  *
  74  */
  75 struct process*    process_find_by_handle(HANDLE hProcess)
  76 {
  77     struct process* p;
  78
  79     for (p = process_first; p && p->handle != hProcess; p = p->next);
  80     if (!p) SetLastError(ERROR_INVALID_HANDLE);
  81     return p;
  82 }
  83
  84 /******************************************************************
  85  *             validate_addr64 (internal)
  86  *
  87  */
  88 BOOL validate_addr64(DWORD64 addr)
  89 {
  90     if (sizeof(void*) == sizeof(int) && (addr >> 32))
  91     {
  92         FIXME("Unsupported address %s\n", wine_dbgstr_longlong(addr));
  93         SetLastError(ERROR_INVALID_PARAMETER);
  94         return FALSE;
  95     }
  96     return TRUE;
  97 }
  98
  99 /******************************************************************
 100  *              fetch_buffer
 101  *
 102  * Ensures process' internal buffer is large enough.
 103  */
 104 void* fetch_buffer(struct process* pcs, unsigned size)
 105 {
 106     if (size > pcs->buffer_size)
 107     {
 108         if (pcs->buffer)
 109             pcs->buffer = HeapReAlloc(GetProcessHeap(), 0, pcs->buffer, size);
 110         else
 111             pcs->buffer = HeapAlloc(GetProcessHeap(), 0, size);
 112         pcs->buffer_size = (pcs->buffer) ? size : 0;
 113     }
 114     return pcs->buffer;
 115 }
 116
 117 const char* wine_dbgstr_addr(const ADDRESS64* addr)
 118 {
 119     if (!addr) return "(null)";
 120     switch (addr->Mode)
 121     {
 122     case AddrModeFlat:
 123         return wine_dbg_sprintf("flat<%s>", wine_dbgstr_longlong(addr->Offset));
 124     case AddrMode1616:
 125         return wine_dbg_sprintf("1616<%04x:%04x>", addr->Segment, (DWORD)addr->Offset);
 126     case AddrMode1632:
 127         return wine_dbg_sprintf("1632<%04x:%08x>", addr->Segment, (DWORD)addr->Offset);
 128     case AddrModeReal:
 129         return wine_dbg_sprintf("real<%04x:%04x>", addr->Segment, (DWORD)addr->Offset);
 130     default:
 131         return "unknown";
 132     }
 133 }
 134
 135 extern struct cpu       cpu_i386, cpu_x86_64, cpu_ppc, cpu_arm, cpu_arm64;
 136
 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__)
 140     &cpu_i386
 141 #elif defined(__x86_64__)
 142     &cpu_x86_64
 143 #elif defined(__powerpc__)
 144     &cpu_ppc
 145 #elif defined(__arm__)
 146     &cpu_arm
 147 #elif defined(__aarch64__)
 148     &cpu_arm64
 149 #else
 150 #error define support for your CPU
 151 #endif
 152     ;
 153
 154 struct cpu* cpu_find(DWORD machine)
 155 {
 156     struct cpu** cpu;
 157
 158     for (cpu = dbghelp_cpus ; *cpu; cpu++)
 159     {
 160         if (cpu[0]->machine == machine) return cpu[0];
 161     }
 162     return NULL;
 163 }
 164
 165 /******************************************************************
 166  *              SymSetSearchPathW (DBGHELP.@)
 167  *
 168  */
 169 BOOL WINAPI SymSetSearchPathW(HANDLE hProcess, PCWSTR searchPath)
 170 {
 171     struct process* pcs = process_find_by_handle(hProcess);
 172
 173     if (!pcs) return FALSE;
 174     if (!searchPath) return FALSE;
 175
 176     HeapFree(GetProcessHeap(), 0, pcs->search_path);
 177     pcs->search_path = lstrcpyW(HeapAlloc(GetProcessHeap(), 0,
 178                                           (lstrlenW(searchPath) + 1) * sizeof(WCHAR)),
 179                                 searchPath);
 180     return TRUE;
 181 }
 182
 183 /******************************************************************
 184  *              SymSetSearchPath (DBGHELP.@)
 185  *
 186  */
 187 BOOL WINAPI SymSetSearchPath(HANDLE hProcess, PCSTR searchPath)
 188 {
 189     BOOL        ret = FALSE;
 190     unsigned    len;
 191     WCHAR*      sp;
 192
 193     len = MultiByteToWideChar(CP_ACP, 0, searchPath, -1, NULL, 0);
 194     if ((sp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
 195     {
 196         MultiByteToWideChar(CP_ACP, 0, searchPath, -1, sp, len);
 197
 198         ret = SymSetSearchPathW(hProcess, sp);
 199         HeapFree(GetProcessHeap(), 0, sp);
 200     }
 201     return ret;
 202 }
 203
 204 /***********************************************************************
 205  *              SymGetSearchPathW (DBGHELP.@)
 206  */
 207 BOOL WINAPI SymGetSearchPathW(HANDLE hProcess, PWSTR szSearchPath,
 208                               DWORD SearchPathLength)
 209 {
 210     struct process* pcs = process_find_by_handle(hProcess);
 211     if (!pcs) return FALSE;
 212
 213     lstrcpynW(szSearchPath, pcs->search_path, SearchPathLength);
 214     return TRUE;
 215 }
 216
 217 /***********************************************************************
 218  *              SymGetSearchPath (DBGHELP.@)
 219  */
 220 BOOL WINAPI SymGetSearchPath(HANDLE hProcess, PSTR szSearchPath,
 221                              DWORD SearchPathLength)
 222 {
 223     WCHAR*      buffer = HeapAlloc(GetProcessHeap(), 0, SearchPathLength * sizeof(WCHAR));
 224     BOOL        ret = FALSE;
 225
 226     if (buffer)
 227     {
 228         ret = SymGetSearchPathW(hProcess, buffer, SearchPathLength);
 229         if (ret)
 230             WideCharToMultiByte(CP_ACP, 0, buffer, SearchPathLength,
 231                                 szSearchPath, SearchPathLength, NULL, NULL);
 232         HeapFree(GetProcessHeap(), 0, buffer);
 233     }
 234     return ret;
 235 }
 236
 237 /******************************************************************
 238  *              invade_process
 239  *
 240  * SymInitialize helper: loads in dbghelp all known (and loaded modules)
 241  * this assumes that hProcess is a handle on a valid process
 242  */
 243 static BOOL WINAPI process_invade_cb(PCWSTR name, ULONG64 base, ULONG size, PVOID user)
 244 {
 245     WCHAR       tmp[MAX_PATH];
 246     HANDLE      hProcess = user;
 247
 248     if (!GetModuleFileNameExW(hProcess, (HMODULE)(DWORD_PTR)base,
 249                               tmp, sizeof(tmp) / sizeof(WCHAR)))
 250         lstrcpynW(tmp, name, sizeof(tmp) / sizeof(WCHAR));
 251
 252     SymLoadModuleExW(hProcess, 0, tmp, name, base, size, NULL, 0);
 253     return TRUE;
 254 }
 255
 256 /******************************************************************
 257  *              check_live_target
 258  *
 259  */
 260 static BOOL check_live_target(struct process* pcs)
 261 {
 262     if (!GetProcessId(pcs->handle)) return FALSE;
 263     if (GetEnvironmentVariableA("DBGHELP_NOLIVE", NULL, 0)) return FALSE;
 264     if (!elf_read_wine_loader_dbg_info(pcs))
 265         macho_read_wine_loader_dbg_info(pcs);
 266     return TRUE;
 267 }
 268
 269 /******************************************************************
 270  *              SymInitializeW (DBGHELP.@)
 271  *
 272  * The initialisation of a dbghelp's context.
 273  * Note that hProcess doesn't need to be a valid process handle (except
 274  * when fInvadeProcess is TRUE).
 275  * Since we also allow loading ELF (pure) libraries and Wine ELF libraries
 276  * containing PE (and NE) module(s), here's how we handle it:
 277  * - we load every module (ELF, NE, PE) passed in SymLoadModule
 278  * - in fInvadeProcess (in SymInitialize) is TRUE, we set up what is called ELF
 279  *   synchronization: hProcess should be a valid process handle, and we hook
 280  *   ourselves on hProcess's loaded ELF-modules, and keep this list in sync with
 281  *   our internal ELF modules representation (loading / unloading). This way,
 282  *   we'll pair every loaded builtin PE module with its ELF counterpart (and
 283  *   access its debug information).
 284  * - if fInvadeProcess (in SymInitialize) is FALSE, we check anyway if the
 285  *   hProcess refers to a running process. We use some heuristics here, so YMMV.
 286  *   If we detect a live target, then we get the same handling as if
 287  *   fInvadeProcess is TRUE (except that the modules are not loaded). Otherwise,
 288  *   we won't be able to make the peering between a builtin PE module and its ELF
 289  *   counterpart. Hence we won't be able to provide the requested debug
 290  *   information. We'll however be able to load native PE modules (and their
 291  *   debug information) without any trouble.
 292  * Note also that this scheme can be intertwined with the deferred loading
 293  * mechanism (ie only load the debug information when we actually need it).
 294  */
 295 BOOL WINAPI SymInitializeW(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeProcess)
 296 {
 297     struct process*     pcs;
 298
 299     TRACE("(%p %s %u)\n", hProcess, debugstr_w(UserSearchPath), fInvadeProcess);
 300
 301     if (process_find_by_handle(hProcess)){
 302         WARN("the symbols for this process have already been initialized!\n");
 303
 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. */
 307         return TRUE;
 308     }
 309
 310     pcs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pcs));
 311     if (!pcs) return FALSE;
 312
 313     pcs->handle = hProcess;
 314
 315     if (UserSearchPath)
 316     {
 317         pcs->search_path = lstrcpyW(HeapAlloc(GetProcessHeap(), 0,
 318                                               (lstrlenW(UserSearchPath) + 1) * sizeof(WCHAR)),
 319                                     UserSearchPath);
 320     }
 321     else
 322     {
 323         unsigned        size;
 324         unsigned        len;
 325         static const WCHAR      sym_path[] = {'_','N','T','_','S','Y','M','B','O','L','_','P','A','T','H',0};
 326         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};
 327
 328         pcs->search_path = HeapAlloc(GetProcessHeap(), 0, (len = MAX_PATH) * sizeof(WCHAR));
 329         while ((size = GetCurrentDirectoryW(len, pcs->search_path)) >= len)
 330             pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, (len *= 2) * sizeof(WCHAR));
 331         pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, (size + 1) * sizeof(WCHAR));
 332
 333         len = GetEnvironmentVariableW(sym_path, NULL, 0);
 334         if (len)
 335         {
 336             pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, (size + 1 + len + 1) * sizeof(WCHAR));
 337             pcs->search_path[size] = ';';
 338             GetEnvironmentVariableW(sym_path, pcs->search_path + size + 1, len);
 339             size += 1 + len;
 340         }
 341         len = GetEnvironmentVariableW(alt_sym_path, NULL, 0);
 342         if (len)
 343         {
 344             pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, (size + 1 + len + 1) * sizeof(WCHAR));
 345             pcs->search_path[size] = ';';
 346             GetEnvironmentVariableW(alt_sym_path, pcs->search_path + size + 1, len);
 347         }
 348     }
 349
 350     pcs->lmodules = NULL;
 351     pcs->dbg_hdr_addr = 0;
 352     pcs->next = process_first;
 353     process_first = pcs;
 354
 355     if (check_live_target(pcs))
 356     {
 357         if (fInvadeProcess)
 358             EnumerateLoadedModulesW64(hProcess, process_invade_cb, hProcess);
 359         elf_synchronize_module_list(pcs);
 360         macho_synchronize_module_list(pcs);
 361     }
 362     else if (fInvadeProcess)
 363     {
 364         SymCleanup(hProcess);
 365         SetLastError(ERROR_INVALID_PARAMETER);
 366         return FALSE;
 367     }
 368
 369     return TRUE;
 370 }
 371
 372 /******************************************************************
 373  *              SymInitialize (DBGHELP.@)
 374  *
 375  *
 376  */
 377 BOOL WINAPI SymInitialize(HANDLE hProcess, PCSTR UserSearchPath, BOOL fInvadeProcess)
 378 {
 379     WCHAR*              sp = NULL;
 380     BOOL                ret;
 381
 382     if (UserSearchPath)
 383     {
 384         unsigned len;
 385
 386         len = MultiByteToWideChar(CP_ACP, 0, UserSearchPath, -1, NULL, 0);
 387         sp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 388         MultiByteToWideChar(CP_ACP, 0, UserSearchPath, -1, sp, len);
 389     }
 390
 391     ret = SymInitializeW(hProcess, sp, fInvadeProcess);
 392     HeapFree(GetProcessHeap(), 0, sp);
 393     return ret;
 394 }
 395
 396 /******************************************************************
 397  *              SymCleanup (DBGHELP.@)
 398  *
 399  */
 400 BOOL WINAPI SymCleanup(HANDLE hProcess)
 401 {
 402     struct process**    ppcs;
 403     struct process*     next;
 404
 405     for (ppcs = &process_first; *ppcs; ppcs = &(*ppcs)->next)
 406     {
 407         if ((*ppcs)->handle == hProcess)
 408         {
 409             while ((*ppcs)->lmodules) module_remove(*ppcs, (*ppcs)->lmodules);
 410
 411             HeapFree(GetProcessHeap(), 0, (*ppcs)->search_path);
 412             next = (*ppcs)->next;
 413             HeapFree(GetProcessHeap(), 0, *ppcs);
 414             *ppcs = next;
 415             return TRUE;
 416         }
 417     }
 418
 419     ERR("this process has not had SymInitialize() called for it!\n");
 420     return FALSE;
 421 }
 422
 423 /******************************************************************
 424  *              SymSetOptions (DBGHELP.@)
 425  *
 426  */
 427 DWORD WINAPI SymSetOptions(DWORD opts)
 428 {
 429     struct process* pcs;
 430
 431     for (pcs = process_first; pcs; pcs = pcs->next)
 432     {
 433         pcs_callback(pcs, CBA_SET_OPTIONS, &opts);
 434     }
 435     return dbghelp_options = opts;
 436 }
 437
 438 /******************************************************************
 439  *              SymGetOptions (DBGHELP.@)
 440  *
 441  */
 442 DWORD WINAPI SymGetOptions(void)
 443 {
 444     return dbghelp_options;
 445 }
 446
 447 /******************************************************************
 448  *              SymSetParentWindow (DBGHELP.@)
 449  *
 450  */
 451 BOOL WINAPI SymSetParentWindow(HWND hwnd)
 452 {
 453     /* Save hwnd so it can be used as parent window */
 454     FIXME("(%p): stub\n", hwnd);
 455     return TRUE;
 456 }
 457
 458 /******************************************************************
 459  *              SymSetContext (DBGHELP.@)
 460  *
 461  */
 462 BOOL WINAPI SymSetContext(HANDLE hProcess, PIMAGEHLP_STACK_FRAME StackFrame,
 463                           PIMAGEHLP_CONTEXT Context)
 464 {
 465     struct process* pcs = process_find_by_handle(hProcess);
 466     if (!pcs) return FALSE;
 467
 468     if (pcs->ctx_frame.ReturnOffset == StackFrame->ReturnOffset &&
 469         pcs->ctx_frame.FrameOffset  == StackFrame->FrameOffset  &&
 470         pcs->ctx_frame.StackOffset  == StackFrame->StackOffset)
 471     {
 472         TRACE("Setting same frame {rtn=%s frm=%s stk=%s}\n",
 473               wine_dbgstr_longlong(pcs->ctx_frame.ReturnOffset),
 474               wine_dbgstr_longlong(pcs->ctx_frame.FrameOffset),
 475               wine_dbgstr_longlong(pcs->ctx_frame.StackOffset));
 476         pcs->ctx_frame.InstructionOffset = StackFrame->InstructionOffset;
 477         SetLastError(ERROR_ACCESS_DENIED); /* latest MSDN says ERROR_SUCCESS */
 478         return FALSE;
 479     }
 480
 481     pcs->ctx_frame = *StackFrame;
 482     /* MSDN states that Context is not (no longer?) used */
 483     return TRUE;
 484 }
 485
 486 /******************************************************************
 487  *              reg_cb64to32 (internal)
 488  *
 489  * Registered callback for converting information from 64 bit to 32 bit
 490  */
 491 static BOOL CALLBACK reg_cb64to32(HANDLE hProcess, ULONG action, ULONG64 data, ULONG64 user)
 492 {
 493     struct process*                     pcs = process_find_by_handle(hProcess);
 494     void*                               data32;
 495     IMAGEHLP_DEFERRED_SYMBOL_LOAD64*    idsl64;
 496     IMAGEHLP_DEFERRED_SYMBOL_LOAD       idsl;
 497
 498     if (!pcs) return FALSE;
 499     switch (action)
 500     {
 501     case CBA_DEBUG_INFO:
 502     case CBA_DEFERRED_SYMBOL_LOAD_CANCEL:
 503     case CBA_SET_OPTIONS:
 504     case CBA_SYMBOLS_UNLOADED:
 505         data32 = (void*)(DWORD_PTR)data;
 506         break;
 507     case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE:
 508     case CBA_DEFERRED_SYMBOL_LOAD_FAILURE:
 509     case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL:
 510     case CBA_DEFERRED_SYMBOL_LOAD_START:
 511         idsl64 = (IMAGEHLP_DEFERRED_SYMBOL_LOAD64*)(DWORD_PTR)data;
 512         if (!validate_addr64(idsl64->BaseOfImage))
 513             return FALSE;
 514         idsl.SizeOfStruct = sizeof(idsl);
 515         idsl.BaseOfImage = (DWORD)idsl64->BaseOfImage;
 516         idsl.CheckSum = idsl64->CheckSum;
 517         idsl.TimeDateStamp = idsl64->TimeDateStamp;
 518         memcpy(idsl.FileName, idsl64->FileName, sizeof(idsl.FileName));
 519         idsl.Reparse = idsl64->Reparse;
 520         data32 = &idsl;
 521         break;
 522     case CBA_DUPLICATE_SYMBOL:
 523     case CBA_EVENT:
 524     case CBA_READ_MEMORY:
 525     default:
 526         FIXME("No mapping for action %u\n", action);
 527         return FALSE;
 528     }
 529     return pcs->reg_cb32(hProcess, action, data32, (PVOID)(DWORD_PTR)user);
 530 }
 531
 532 /******************************************************************
 533  *              pcs_callback (internal)
 534  */
 535 BOOL pcs_callback(const struct process* pcs, ULONG action, void* data)
 536 {
 537     IMAGEHLP_DEFERRED_SYMBOL_LOAD64 idsl;
 538
 539     TRACE("%p %u %p\n", pcs, action, data);
 540
 541     if (!pcs->reg_cb) return FALSE;
 542     if (!pcs->reg_is_unicode)
 543     {
 544         IMAGEHLP_DEFERRED_SYMBOL_LOADW64*   idslW;
 545
 546         switch (action)
 547         {
 548         case CBA_DEBUG_INFO:
 549         case CBA_DEFERRED_SYMBOL_LOAD_CANCEL:
 550         case CBA_SET_OPTIONS:
 551         case CBA_SYMBOLS_UNLOADED:
 552             break;
 553         case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE:
 554         case CBA_DEFERRED_SYMBOL_LOAD_FAILURE:
 555         case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL:
 556         case CBA_DEFERRED_SYMBOL_LOAD_START:
 557             idslW = data;
 558             idsl.SizeOfStruct = sizeof(idsl);
 559             idsl.BaseOfImage = idslW->BaseOfImage;
 560             idsl.CheckSum = idslW->CheckSum;
 561             idsl.TimeDateStamp = idslW->TimeDateStamp;
 562             WideCharToMultiByte(CP_ACP, 0, idslW->FileName, -1,
 563                                 idsl.FileName, sizeof(idsl.FileName), NULL, NULL);
 564             idsl.Reparse = idslW->Reparse;
 565             data = &idsl;
 566             break;
 567         case CBA_DUPLICATE_SYMBOL:
 568         case CBA_EVENT:
 569         case CBA_READ_MEMORY:
 570         default:
 571             FIXME("No mapping for action %u\n", action);
 572             return FALSE;
 573         }
 574     }
 575     return pcs->reg_cb(pcs->handle, action, (ULONG64)(DWORD_PTR)data, pcs->reg_user);
 576 }
 577
 578 /******************************************************************
 579  *              sym_register_cb
 580  *
 581  * Helper for registering a callback.
 582  */
 583 static BOOL sym_register_cb(HANDLE hProcess,
 584                             PSYMBOL_REGISTERED_CALLBACK64 cb,
 585                             PSYMBOL_REGISTERED_CALLBACK cb32,
 586                             DWORD64 user, BOOL unicode)
 587 {
 588     struct process* pcs = process_find_by_handle(hProcess);
 589
 590     if (!pcs) return FALSE;
 591     pcs->reg_cb = cb;
 592     pcs->reg_cb32 = cb32;
 593     pcs->reg_is_unicode = unicode;
 594     pcs->reg_user = user;
 595
 596     return TRUE;
 597 }
 598
 599 /***********************************************************************
 600  *              SymRegisterCallback (DBGHELP.@)
 601  */
 602 BOOL WINAPI SymRegisterCallback(HANDLE hProcess,
 603                                 PSYMBOL_REGISTERED_CALLBACK CallbackFunction,
 604                                 PVOID UserContext)
 605 {
 606     TRACE("(%p, %p, %p)\n",
 607           hProcess, CallbackFunction, UserContext);
 608     return sym_register_cb(hProcess, reg_cb64to32, CallbackFunction, (DWORD_PTR)UserContext, FALSE);
 609 }
 610
 611 /***********************************************************************
 612  *              SymRegisterCallback64 (DBGHELP.@)
 613  */
 614 BOOL WINAPI SymRegisterCallback64(HANDLE hProcess,
 615                                   PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
 616                                   ULONG64 UserContext)
 617 {
 618     TRACE("(%p, %p, %s)\n",
 619           hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext));
 620     return sym_register_cb(hProcess, CallbackFunction, NULL, UserContext, FALSE);
 621 }
 622
 623 /***********************************************************************
 624  *              SymRegisterCallbackW64 (DBGHELP.@)
 625  */
 626 BOOL WINAPI SymRegisterCallbackW64(HANDLE hProcess,
 627                                    PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
 628                                    ULONG64 UserContext)
 629 {
 630     TRACE("(%p, %p, %s)\n",
 631           hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext));
 632     return sym_register_cb(hProcess, CallbackFunction, NULL, UserContext, TRUE);
 633 }
 634
 635 /* This is imagehlp version not dbghelp !! */
 636 static API_VERSION api_version = { 4, 0, 2, 0 };
 637
 638 /***********************************************************************
 639  *           ImagehlpApiVersion (DBGHELP.@)
 640  */
 641 LPAPI_VERSION WINAPI ImagehlpApiVersion(VOID)
 642 {
 643     return &api_version;
 644 }
 645
 646 /***********************************************************************
 647  *           ImagehlpApiVersionEx (DBGHELP.@)
 648  */
 649 LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion)
 650 {
 651     if (!AppVersion) return NULL;
 652
 653     AppVersion->MajorVersion = api_version.MajorVersion;
 654     AppVersion->MinorVersion = api_version.MinorVersion;
 655     AppVersion->Revision = api_version.Revision;
 656     AppVersion->Reserved = api_version.Reserved;
 657
 658     return AppVersion;
 659 }
 660
 661 /******************************************************************
 662  *              ExtensionApiVersion (DBGHELP.@)
 663  */
 664 LPEXT_API_VERSION WINAPI ExtensionApiVersion(void)
 665 {
 666     static EXT_API_VERSION      eav = {5, 5, 5, 0};
 667     return &eav;
 668 }
 669
 670 /******************************************************************
 671  *              WinDbgExtensionDllInit (DBGHELP.@)
 672  */
 673 void WINAPI WinDbgExtensionDllInit(PWINDBG_EXTENSION_APIS lpExtensionApis,
 674                                    unsigned short major, unsigned short minor)
 675 {
 676 }