dlls/dbgeng/dbgeng.c

   1 /*
   2  * Support for Microsoft Debugging Extension API
   3  *
   4  * Copyright (C) 2010 Volodymyr Shcherbyna
   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 <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winternl.h"
  28 #include "psapi.h"
  29
  30 #include "initguid.h"
  31 #include "dbgeng.h"
  32
  33 #include "wine/debug.h"
  34 #include "wine/heap.h"
  35 #include "wine/list.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(dbgeng);
  38
  39 extern NTSTATUS WINAPI NtSuspendProcess(HANDLE handle);
  40 extern NTSTATUS WINAPI NtResumeProcess(HANDLE handle);
  41
  42 struct module_info
  43 {
  44     DEBUG_MODULE_PARAMETERS params;
  45     char image_name[MAX_PATH];
  46 };
  47
  48 struct target_process
  49 {
  50     struct list entry;
  51     unsigned int pid;
  52     unsigned int attach_flags;
  53     HANDLE handle;
  54     struct
  55     {
  56         struct module_info *info;
  57         unsigned int loaded;
  58         unsigned int unloaded;
  59         BOOL initialized;
  60     } modules;
  61     ULONG cpu_type;
  62 };
  63
  64 struct debug_client
  65 {
  66     IDebugClient7 IDebugClient_iface;
  67     IDebugDataSpaces IDebugDataSpaces_iface;
  68     IDebugSymbols3 IDebugSymbols3_iface;
  69     IDebugControl2 IDebugControl2_iface;
  70     IDebugAdvanced IDebugAdvanced_iface;
  71     IDebugSystemObjects IDebugSystemObjects_iface;
  72     LONG refcount;
  73     ULONG engine_options;
  74     struct list targets;
  75     IDebugEventCallbacks *event_callbacks;
  76 };
  77
  78 static struct target_process *debug_client_get_target(struct debug_client *debug_client)
  79 {
  80     if (list_empty(&debug_client->targets))
  81         return NULL;
  82
  83     return LIST_ENTRY(list_head(&debug_client->targets), struct target_process, entry);
  84 }
  85
  86 static HRESULT debug_target_return_string(const char *str, char *buffer, unsigned int buffer_size,
  87         unsigned int *size)
  88 {
  89     unsigned int len = strlen(str), dst_len;
  90
  91     if (size)
  92         *size = len + 1;
  93
  94     if (buffer && buffer_size)
  95     {
  96         dst_len = min(len, buffer_size - 1);
  97         if (dst_len)
  98             memcpy(buffer, str, dst_len);
  99         buffer[dst_len] = 0;
 100     }
 101
 102     return len < buffer_size ? S_OK : S_FALSE;
 103 }
 104
 105 static WORD debug_target_get_module_machine(struct target_process *target, HMODULE module)
 106 {
 107     IMAGE_DOS_HEADER dos = { 0 };
 108     WORD machine = 0;
 109
 110     ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
 111     if (dos.e_magic == IMAGE_DOS_SIGNATURE)
 112     {
 113         ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /* PE signature */, &machine,
 114                 sizeof(machine), NULL);
 115     }
 116
 117     return machine;
 118 }
 119
 120 static DWORD debug_target_get_module_timestamp(struct target_process *target, HMODULE module)
 121 {
 122     IMAGE_DOS_HEADER dos = { 0 };
 123     DWORD timestamp = 0;
 124
 125     ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
 126     if (dos.e_magic == IMAGE_DOS_SIGNATURE)
 127     {
 128         ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /* PE signature */ +
 129                 FIELD_OFFSET(IMAGE_FILE_HEADER, TimeDateStamp), &timestamp, sizeof(timestamp), NULL);
 130     }
 131
 132     return timestamp;
 133 }
 134
 135 static HRESULT debug_target_init_modules_info(struct target_process *target)
 136 {
 137     unsigned int i, count;
 138     HMODULE *modules;
 139     MODULEINFO info;
 140     DWORD needed;
 141
 142     if (target->modules.initialized)
 143         return S_OK;
 144
 145     if (!target->handle)
 146         return E_UNEXPECTED;
 147
 148     needed = 0;
 149     EnumProcessModules(target->handle, NULL, 0, &needed);
 150     if (!needed)
 151         return E_FAIL;
 152
 153     count = needed / sizeof(HMODULE);
 154
 155     if (!(modules = heap_alloc(count * sizeof(*modules))))
 156         return E_OUTOFMEMORY;
 157
 158     if (!(target->modules.info = heap_alloc_zero(count * sizeof(*target->modules.info))))
 159     {
 160         heap_free(modules);
 161         return E_OUTOFMEMORY;
 162     }
 163
 164     if (EnumProcessModules(target->handle, modules, count * sizeof(*modules), &needed))
 165     {
 166         for (i = 0; i < count; ++i)
 167         {
 168             if (!GetModuleInformation(target->handle, modules[i], &info, sizeof(info)))
 169             {
 170                 WARN("Failed to get module information, error %d.\n", GetLastError());
 171                 continue;
 172             }
 173
 174             target->modules.info[i].params.Base = (ULONG_PTR)info.lpBaseOfDll;
 175             target->modules.info[i].params.Size = info.SizeOfImage;
 176             target->modules.info[i].params.TimeDateStamp = debug_target_get_module_timestamp(target, modules[i]);
 177
 178             GetModuleFileNameExA(target->handle, modules[i], target->modules.info[i].image_name,
 179                     ARRAY_SIZE(target->modules.info[i].image_name));
 180         }
 181     }
 182
 183     target->cpu_type = debug_target_get_module_machine(target, modules[0]);
 184
 185     heap_free(modules);
 186
 187     target->modules.loaded = count;
 188     target->modules.unloaded = 0; /* FIXME */
 189
 190     target->modules.initialized = TRUE;
 191
 192     return S_OK;
 193 }
 194
 195 static const struct module_info *debug_target_get_module_info(struct target_process *target, unsigned int i)
 196 {
 197     if (FAILED(debug_target_init_modules_info(target)))
 198         return NULL;
 199
 200     if (i >= target->modules.loaded)
 201         return NULL;
 202
 203     return &target->modules.info[i];
 204 }
 205
 206 static const struct module_info *debug_target_get_module_info_by_base(struct target_process *target, ULONG64 base)
 207 {
 208     unsigned int i;
 209
 210     if (FAILED(debug_target_init_modules_info(target)))
 211         return NULL;
 212
 213     for (i = 0; i < target->modules.loaded; ++i)
 214     {
 215         if (target->modules.info[i].params.Base == base)
 216             return &target->modules.info[i];
 217     }
 218
 219     return NULL;
 220 }
 221
 222 static void debug_client_detach_target(struct target_process *target)
 223 {
 224     NTSTATUS status;
 225
 226     if (!target->handle)
 227         return;
 228
 229     if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
 230     {
 231         BOOL resume = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
 232
 233         if (resume)
 234         {
 235             if ((status = NtResumeProcess(target->handle)))
 236                 WARN("Failed to resume process, status %#x.\n", status);
 237         }
 238     }
 239
 240     CloseHandle(target->handle);
 241     target->handle = NULL;
 242 }
 243
 244 static struct debug_client *impl_from_IDebugClient(IDebugClient7 *iface)
 245 {
 246     return CONTAINING_RECORD(iface, struct debug_client, IDebugClient_iface);
 247 }
 248
 249 static struct debug_client *impl_from_IDebugDataSpaces(IDebugDataSpaces *iface)
 250 {
 251     return CONTAINING_RECORD(iface, struct debug_client, IDebugDataSpaces_iface);
 252 }
 253
 254 static struct debug_client *impl_from_IDebugSymbols3(IDebugSymbols3 *iface)
 255 {
 256     return CONTAINING_RECORD(iface, struct debug_client, IDebugSymbols3_iface);
 257 }
 258
 259 static struct debug_client *impl_from_IDebugControl2(IDebugControl2 *iface)
 260 {
 261     return CONTAINING_RECORD(iface, struct debug_client, IDebugControl2_iface);
 262 }
 263
 264 static struct debug_client *impl_from_IDebugAdvanced(IDebugAdvanced *iface)
 265 {
 266     return CONTAINING_RECORD(iface, struct debug_client, IDebugAdvanced_iface);
 267 }
 268
 269 static struct debug_client *impl_from_IDebugSystemObjects(IDebugSystemObjects *iface)
 270 {
 271     return CONTAINING_RECORD(iface, struct debug_client, IDebugSystemObjects_iface);
 272 }
 273
 274 static HRESULT STDMETHODCALLTYPE debugclient_QueryInterface(IDebugClient7 *iface, REFIID riid, void **obj)
 275 {
 276     struct debug_client *debug_client = impl_from_IDebugClient(iface);
 277
 278     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 279
 280     if (IsEqualIID(riid, &IID_IDebugClient) ||
 281         IsEqualIID(riid, &IID_IDebugClient2) ||
 282         IsEqualIID(riid, &IID_IDebugClient3) ||
 283         IsEqualIID(riid, &IID_IDebugClient4) ||
 284         IsEqualIID(riid, &IID_IDebugClient5) ||
 285         IsEqualIID(riid, &IID_IDebugClient6) ||
 286         IsEqualIID(riid, &IID_IDebugClient7) ||
 287         IsEqualIID(riid, &IID_IUnknown))
 288     {
 289         *obj = iface;
 290     }
 291     else if (IsEqualIID(riid, &IID_IDebugDataSpaces))
 292     {
 293         *obj = &debug_client->IDebugDataSpaces_iface;
 294     }
 295     else if (IsEqualIID(riid, &IID_IDebugSymbols)
 296              || IsEqualIID(riid, &IID_IDebugSymbols2)
 297              || IsEqualIID(riid, &IID_IDebugSymbols3))
 298     {
 299         *obj = &debug_client->IDebugSymbols3_iface;
 300     }
 301     else if (IsEqualIID(riid, &IID_IDebugControl2)
 302             || IsEqualIID(riid, &IID_IDebugControl))
 303     {
 304         *obj = &debug_client->IDebugControl2_iface;
 305     }
 306     else if (IsEqualIID(riid, &IID_IDebugAdvanced))
 307     {
 308         *obj = &debug_client->IDebugAdvanced_iface;
 309     }
 310     else if (IsEqualIID(riid, &IID_IDebugSystemObjects))
 311     {
 312         *obj = &debug_client->IDebugSystemObjects_iface;
 313     }
 314     else
 315     {
 316         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 317         *obj = NULL;
 318         return E_NOINTERFACE;
 319     }
 320
 321     IUnknown_AddRef((IUnknown *)*obj);
 322     return S_OK;
 323 }
 324
 325 static ULONG STDMETHODCALLTYPE debugclient_AddRef(IDebugClient7 *iface)
 326 {
 327     struct debug_client *debug_client = impl_from_IDebugClient(iface);
 328     ULONG refcount = InterlockedIncrement(&debug_client->refcount);
 329
 330     TRACE("%p, %d.\n", iface, refcount);
 331
 332     return refcount;
 333 }
 334
 335 static void debug_target_free(struct target_process *target)
 336 {
 337     heap_free(target->modules.info);
 338     heap_free(target);
 339 }
 340
 341 static ULONG STDMETHODCALLTYPE debugclient_Release(IDebugClient7 *iface)
 342 {
 343     struct debug_client *debug_client = impl_from_IDebugClient(iface);
 344     ULONG refcount = InterlockedDecrement(&debug_client->refcount);
 345     struct target_process *cur, *cur2;
 346
 347     TRACE("%p, %d.\n", debug_client, refcount);
 348
 349     if (!refcount)
 350     {
 351         LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &debug_client->targets, struct target_process, entry)
 352         {
 353             debug_client_detach_target(cur);
 354             list_remove(&cur->entry);
 355             debug_target_free(cur);
 356         }
 357         if (debug_client->event_callbacks)
 358             debug_client->event_callbacks->lpVtbl->Release(debug_client->event_callbacks);
 359         heap_free(debug_client);
 360     }
 361
 362     return refcount;
 363 }
 364
 365 static HRESULT STDMETHODCALLTYPE debugclient_AttachKernel(IDebugClient7 *iface, ULONG flags, const char *options)
 366 {
 367     FIXME("%p, %#x, %s stub.\n", iface, flags, debugstr_a(options));
 368
 369     return E_NOTIMPL;
 370 }
 371
 372 static HRESULT STDMETHODCALLTYPE debugclient_GetKernelConnectionOptions(IDebugClient7 *iface, char *buffer,
 373         ULONG buffer_size, ULONG *options_size)
 374 {
 375     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, options_size);
 376
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT STDMETHODCALLTYPE debugclient_SetKernelConnectionOptions(IDebugClient7 *iface, const char *options)
 381 {
 382     FIXME("%p, %s stub.\n", iface, debugstr_a(options));
 383
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT STDMETHODCALLTYPE debugclient_StartProcessServer(IDebugClient7 *iface, ULONG flags, const char *options,
 388         void *reserved)
 389 {
 390     FIXME("%p, %#x, %s, %p stub.\n", iface, flags, debugstr_a(options), reserved);
 391
 392     return E_NOTIMPL;
 393 }
 394
 395 static HRESULT STDMETHODCALLTYPE debugclient_ConnectProcessServer(IDebugClient7 *iface, const char *remote_options,
 396         ULONG64 *server)
 397 {
 398     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(remote_options), server);
 399
 400     return E_NOTIMPL;
 401 }
 402
 403 static HRESULT STDMETHODCALLTYPE debugclient_DisconnectProcessServer(IDebugClient7 *iface, ULONG64 server)
 404 {
 405     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(server));
 406
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessSystemIds(IDebugClient7 *iface, ULONG64 server,
 411         ULONG *ids, ULONG count, ULONG *actual_count)
 412 {
 413     FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(server), ids, count, actual_count);
 414
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessSystemIdByExecutableName(IDebugClient7 *iface,
 419         ULONG64 server, const char *exe_name, ULONG flags, ULONG *id)
 420 {
 421     FIXME("%p, %s, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(exe_name), flags, id);
 422
 423     return E_NOTIMPL;
 424 }
 425
 426 static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessDescription(IDebugClient7 *iface, ULONG64 server,
 427         ULONG systemid, ULONG flags, char *exe_name, ULONG exe_name_size, ULONG *actual_exe_name_size,
 428         char *description, ULONG description_size, ULONG *actual_description_size)
 429 {
 430     FIXME("%p, %s, %u, %#x, %p, %u, %p, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(server), systemid, flags,
 431             exe_name, exe_name_size, actual_exe_name_size, description, description_size, actual_description_size);
 432
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT STDMETHODCALLTYPE debugclient_AttachProcess(IDebugClient7 *iface, ULONG64 server, ULONG pid, ULONG flags)
 437 {
 438     struct debug_client *debug_client = impl_from_IDebugClient(iface);
 439     struct target_process *process;
 440
 441     TRACE("%p, %s, %u, %#x.\n", iface, wine_dbgstr_longlong(server), pid, flags);
 442
 443     if (server)
 444     {
 445         FIXME("Remote debugging is not supported.\n");
 446         return E_NOTIMPL;
 447     }
 448
 449     if (!(process = heap_alloc_zero(sizeof(*process))))
 450         return E_OUTOFMEMORY;
 451
 452     process->pid = pid;
 453     process->attach_flags = flags;
 454
 455     list_add_head(&debug_client->targets, &process->entry);
 456
 457     return S_OK;
 458 }
 459
 460 static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess(IDebugClient7 *iface, ULONG64 server, char *cmdline,
 461         ULONG flags)
 462 {
 463     FIXME("%p, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(cmdline), flags);
 464
 465     return E_NOTIMPL;
 466 }
 467
 468 static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach(IDebugClient7 *iface, ULONG64 server, char *cmdline,
 469         ULONG create_flags, ULONG pid, ULONG attach_flags)
 470 {
 471     FIXME("%p, %s, %s, %#x, %u, %#x stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(cmdline), create_flags,
 472             pid, attach_flags);
 473
 474     return E_NOTIMPL;
 475 }
 476
 477 static HRESULT STDMETHODCALLTYPE debugclient_GetProcessOptions(IDebugClient7 *iface, ULONG *options)
 478 {
 479     FIXME("%p, %p stub.\n", iface, options);
 480
 481     return E_NOTIMPL;
 482 }
 483
 484 static HRESULT STDMETHODCALLTYPE debugclient_AddProcessOptions(IDebugClient7 *iface, ULONG options)
 485 {
 486     FIXME("%p, %#x stub.\n", iface, options);
 487
 488     return E_NOTIMPL;
 489 }
 490
 491 static HRESULT STDMETHODCALLTYPE debugclient_RemoveProcessOptions(IDebugClient7 *iface, ULONG options)
 492 {
 493     FIXME("%p, %#x stub.\n", iface, options);
 494
 495     return E_NOTIMPL;
 496 }
 497
 498 static HRESULT STDMETHODCALLTYPE debugclient_SetProcessOptions(IDebugClient7 *iface, ULONG options)
 499 {
 500     FIXME("%p, %#x stub.\n", iface, options);
 501
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT STDMETHODCALLTYPE debugclient_OpenDumpFile(IDebugClient7 *iface, const char *filename)
 506 {
 507     FIXME("%p, %s stub.\n", iface, debugstr_a(filename));
 508
 509     return E_NOTIMPL;
 510 }
 511
 512 static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFile(IDebugClient7 *iface, const char *filename, ULONG qualifier)
 513 {
 514     FIXME("%p, %s, %u stub.\n", iface, debugstr_a(filename), qualifier);
 515
 516     return E_NOTIMPL;
 517 }
 518
 519 static HRESULT STDMETHODCALLTYPE debugclient_ConnectSession(IDebugClient7 *iface, ULONG flags, ULONG history_limit)
 520 {
 521     FIXME("%p, %#x, %u stub.\n", iface, flags, history_limit);
 522
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT STDMETHODCALLTYPE debugclient_StartServer(IDebugClient7 *iface, const char *options)
 527 {
 528     FIXME("%p, %s stub.\n", iface, debugstr_a(options));
 529
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT STDMETHODCALLTYPE debugclient_OutputServers(IDebugClient7 *iface, ULONG output_control,
 534         const char *machine, ULONG flags)
 535 {
 536     FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(machine), flags);
 537
 538     return E_NOTIMPL;
 539 }
 540
 541 static HRESULT STDMETHODCALLTYPE debugclient_TerminateProcesses(IDebugClient7 *iface)
 542 {
 543     FIXME("%p stub.\n", iface);
 544
 545     return E_NOTIMPL;
 546 }
 547
 548 static HRESULT STDMETHODCALLTYPE debugclient_DetachProcesses(IDebugClient7 *iface)
 549 {
 550     struct debug_client *debug_client = impl_from_IDebugClient(iface);
 551     struct target_process *target;
 552
 553     TRACE("%p.\n", iface);
 554
 555     LIST_FOR_EACH_ENTRY(target, &debug_client->targets, struct target_process, entry)
 556     {
 557         debug_client_detach_target(target);
 558     }
 559
 560     return S_OK;
 561 }
 562
 563 static HRESULT STDMETHODCALLTYPE debugclient_EndSession(IDebugClient7 *iface, ULONG flags)
 564 {
 565     FIXME("%p, %#x stub.\n", iface, flags);
 566
 567     return E_NOTIMPL;
 568 }
 569
 570 static HRESULT STDMETHODCALLTYPE debugclient_GetExitCode(IDebugClient7 *iface, ULONG *code)
 571 {
 572     FIXME("%p, %p stub.\n", iface, code);
 573
 574     return E_NOTIMPL;
 575 }
 576
 577 static HRESULT STDMETHODCALLTYPE debugclient_DispatchCallbacks(IDebugClient7 *iface, ULONG timeout)
 578 {
 579     FIXME("%p, %u stub.\n", iface, timeout);
 580
 581     return E_NOTIMPL;
 582 }
 583
 584 static HRESULT STDMETHODCALLTYPE debugclient_ExitDispatch(IDebugClient7 *iface, IDebugClient *client)
 585 {
 586     FIXME("%p, %p stub.\n", iface, client);
 587
 588     return E_NOTIMPL;
 589 }
 590
 591 static HRESULT STDMETHODCALLTYPE debugclient_CreateClient(IDebugClient7 *iface, IDebugClient **client)
 592 {
 593     FIXME("%p, %p stub.\n", iface, client);
 594
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT STDMETHODCALLTYPE debugclient_GetInputCallbacks(IDebugClient7 *iface, IDebugInputCallbacks **callbacks)
 599 {
 600     FIXME("%p, %p stub.\n", iface, callbacks);
 601
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT STDMETHODCALLTYPE debugclient_SetInputCallbacks(IDebugClient7 *iface, IDebugInputCallbacks *callbacks)
 606 {
 607     FIXME("%p, %p stub.\n", iface, callbacks);
 608
 609     return E_NOTIMPL;
 610 }
 611
 612 static HRESULT STDMETHODCALLTYPE debugclient_GetOutputCallbacks(IDebugClient7 *iface, IDebugOutputCallbacks **callbacks)
 613 {
 614     FIXME("%p, %p stub.\n", iface, callbacks);
 615
 616     return E_NOTIMPL;
 617 }
 618
 619 static HRESULT STDMETHODCALLTYPE debugclient_SetOutputCallbacks(IDebugClient7 *iface, IDebugOutputCallbacks *callbacks)
 620 {
 621     FIXME("%p, %p stub.\n", iface, callbacks);
 622
 623     return E_NOTIMPL;
 624 }
 625
 626 static HRESULT STDMETHODCALLTYPE debugclient_GetOutputMask(IDebugClient7 *iface, ULONG *mask)
 627 {
 628     FIXME("%p, %p stub.\n", iface, mask);
 629
 630     return E_NOTIMPL;
 631 }
 632
 633 static HRESULT STDMETHODCALLTYPE debugclient_SetOutputMask(IDebugClient7 *iface, ULONG mask)
 634 {
 635     FIXME("%p, %#x stub.\n", iface, mask);
 636
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT STDMETHODCALLTYPE debugclient_GetOtherOutputMask(IDebugClient7 *iface, IDebugClient *client, ULONG *mask)
 641 {
 642     FIXME("%p, %p, %p stub.\n", iface, client, mask);
 643
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT STDMETHODCALLTYPE debugclient_SetOtherOutputMask(IDebugClient7 *iface, IDebugClient *client, ULONG mask)
 648 {
 649     FIXME("%p, %p, %#x stub.\n", iface, client, mask);
 650
 651     return E_NOTIMPL;
 652 }
 653
 654 static HRESULT STDMETHODCALLTYPE debugclient_GetOutputWidth(IDebugClient7 *iface, ULONG *columns)
 655 {
 656     FIXME("%p, %p stub.\n", iface, columns);
 657
 658     return E_NOTIMPL;
 659 }
 660
 661 static HRESULT STDMETHODCALLTYPE debugclient_SetOutputWidth(IDebugClient7 *iface, ULONG columns)
 662 {
 663     FIXME("%p, %u stub.\n", iface, columns);
 664
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT STDMETHODCALLTYPE debugclient_GetOutputLinePrefix(IDebugClient7 *iface, char *buffer, ULONG buffer_size,
 669         ULONG *prefix_size)
 670 {
 671     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, prefix_size);
 672
 673     return E_NOTIMPL;
 674 }
 675
 676 static HRESULT STDMETHODCALLTYPE debugclient_SetOutputLinePrefix(IDebugClient7 *iface, const char *prefix)
 677 {
 678     FIXME("%p, %s stub.\n", iface, debugstr_a(prefix));
 679
 680     return E_NOTIMPL;
 681 }
 682
 683 static HRESULT STDMETHODCALLTYPE debugclient_GetIdentity(IDebugClient7 *iface, char *buffer, ULONG buffer_size,
 684         ULONG *identity_size)
 685 {
 686     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, identity_size);
 687
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT STDMETHODCALLTYPE debugclient_OutputIdentity(IDebugClient7 *iface, ULONG output_control, ULONG flags,
 692         const char *format)
 693 {
 694     FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, flags, debugstr_a(format));
 695
 696     return E_NOTIMPL;
 697 }
 698
 699 static HRESULT STDMETHODCALLTYPE debugclient_GetEventCallbacks(IDebugClient7 *iface, IDebugEventCallbacks **callbacks)
 700 {
 701     struct debug_client *debug_client = impl_from_IDebugClient(iface);
 702
 703     TRACE("%p, %p.\n", iface, callbacks);
 704
 705     if (debug_client->event_callbacks)
 706     {
 707         *callbacks = debug_client->event_callbacks;
 708         (*callbacks)->lpVtbl->AddRef(*callbacks);
 709     }
 710
 711     return S_OK;
 712 }
 713
 714 static HRESULT STDMETHODCALLTYPE debugclient_SetEventCallbacks(IDebugClient7 *iface, IDebugEventCallbacks *callbacks)
 715 {
 716     struct debug_client *debug_client = impl_from_IDebugClient(iface);
 717
 718     TRACE("%p, %p.\n", iface, callbacks);
 719
 720     if (debug_client->event_callbacks)
 721         debug_client->event_callbacks->lpVtbl->Release(debug_client->event_callbacks);
 722     if ((debug_client->event_callbacks = callbacks))
 723         debug_client->event_callbacks->lpVtbl->AddRef(debug_client->event_callbacks);
 724
 725     return S_OK;
 726 }
 727
 728 static HRESULT STDMETHODCALLTYPE debugclient_FlushCallbacks(IDebugClient7 *iface)
 729 {
 730     FIXME("%p stub.\n", iface);
 731
 732     return E_NOTIMPL;
 733 }
 734
 735 static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFile2(IDebugClient7 *iface, const char *dumpfile, ULONG qualifier,
 736             ULONG flags, const char *comment)
 737 {
 738     FIXME("%p, %s, %d, 0x%08x, %s.\n", iface, debugstr_a(dumpfile), qualifier, flags, debugstr_a(comment));
 739     return E_NOTIMPL;
 740 }
 741
 742 static HRESULT STDMETHODCALLTYPE debugclient_AddDumpInformationFile(IDebugClient7 *iface, const char *infofile, ULONG type)
 743 {
 744     FIXME("%p, %s, %d.\n", iface, debugstr_a(infofile), type);
 745     return E_NOTIMPL;
 746 }
 747
 748 static HRESULT STDMETHODCALLTYPE debugclient_EndProcessServer(IDebugClient7 *iface, ULONG64 server)
 749 {
 750     FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(server));
 751     return E_NOTIMPL;
 752 }
 753
 754 static HRESULT STDMETHODCALLTYPE debugclient_WaitForProcessServerEnd(IDebugClient7 *iface, ULONG timeout)
 755 {
 756     FIXME("%p, %d.\n", iface, timeout);
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT STDMETHODCALLTYPE debugclient_IsKernelDebuggerEnabled(IDebugClient7 *iface)
 761 {
 762     FIXME("%p.\n", iface);
 763     return E_NOTIMPL;
 764 }
 765
 766 static HRESULT STDMETHODCALLTYPE debugclient_TerminateCurrentProcess(IDebugClient7 *iface)
 767 {
 768     FIXME("%p.\n", iface);
 769     return E_NOTIMPL;
 770 }
 771
 772 static HRESULT STDMETHODCALLTYPE debugclient_DetachCurrentProcess(IDebugClient7 *iface)
 773 {
 774     FIXME("%p.\n", iface);
 775     return E_NOTIMPL;
 776 }
 777
 778 static HRESULT STDMETHODCALLTYPE debugclient_AbandonCurrentProcess(IDebugClient7 *iface)
 779 {
 780     FIXME("%p.\n", iface);
 781     return E_NOTIMPL;
 782 }
 783
 784 static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessSystemIdByExecutableNameWide(IDebugClient7 *iface, ULONG64 server,
 785             const WCHAR *exename, ULONG flags, ULONG *id)
 786 {
 787     FIXME("%p, %s, %s, 0x%08x, %p.\n", iface, wine_dbgstr_longlong(server), debugstr_w(exename), flags, id);
 788     return E_NOTIMPL;
 789 }
 790
 791 static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessDescriptionWide(IDebugClient7 *iface, ULONG64 server, ULONG id,
 792             ULONG flags, WCHAR *exename, ULONG size,  ULONG *actualsize, WCHAR *description, ULONG desc_size, ULONG *actual_desc_size)
 793 {
 794     FIXME("%p, %s, %d, 0x%08x, %s, %d, %p, %s, %d, %p.\n", iface, wine_dbgstr_longlong(server), id, flags, debugstr_w(exename), size,
 795             actualsize, debugstr_w(description), desc_size, actual_desc_size );
 796     return E_NOTIMPL;
 797 }
 798
 799 static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessWide(IDebugClient7 *iface, ULONG64 server, WCHAR *commandline, ULONG flags)
 800 {
 801     FIXME("%p, %s, %s, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(commandline), flags);
 802     return E_NOTIMPL;
 803 }
 804
 805 static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttachWide(IDebugClient7 *iface, ULONG64 server, WCHAR *commandline,
 806             ULONG flags, ULONG processid, ULONG attachflags)
 807 {
 808     FIXME("%p, %s, %s, 0x%08x, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(commandline), flags, processid, attachflags);
 809     return E_NOTIMPL;
 810 }
 811
 812 static HRESULT STDMETHODCALLTYPE debugclient_OpenDumpFileWide(IDebugClient7 *iface, const WCHAR *filename, ULONG64 handle)
 813 {
 814     FIXME("%p, %s, %s.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle));
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFileWide(IDebugClient7 *iface, const WCHAR *filename, ULONG64 handle,
 819             ULONG qualifier, ULONG flags, const WCHAR *comment)
 820 {
 821     FIXME("%p, %s, %s, %d, 0x%08x, %s.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle),
 822                 qualifier, flags, debugstr_w(comment));
 823     return E_NOTIMPL;
 824 }
 825
 826 static HRESULT STDMETHODCALLTYPE debugclient_AddDumpInformationFileWide(IDebugClient7 *iface, const WCHAR *filename,
 827             ULONG64 handle, ULONG type)
 828 {
 829     FIXME("%p, %s, %s, %d.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle), type);
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT STDMETHODCALLTYPE debugclient_GetNumberDumpFiles(IDebugClient7 *iface, ULONG *count)
 834 {
 835     FIXME("%p, %p.\n", iface, count);
 836     return E_NOTIMPL;
 837 }
 838
 839 static HRESULT STDMETHODCALLTYPE debugclient_GetDumpFile(IDebugClient7 *iface, ULONG index, char *buffer, ULONG buf_size,
 840             ULONG *name_size, ULONG64 *handle, ULONG *type)
 841 {
 842     FIXME("%p, %d, %p, %d, %p, %p, %p.\n", iface, index, buffer, buf_size, name_size, handle, type);
 843     return E_NOTIMPL;
 844 }
 845
 846 static HRESULT STDMETHODCALLTYPE debugclient_GetDumpFileWide(IDebugClient7 *iface, ULONG index, WCHAR *buffer, ULONG buf_size,
 847             ULONG *name_size, ULONG64 *handle, ULONG *type)
 848 {
 849     FIXME("%p, %d, %p, %d, %p, %p, %p.\n", iface, index, buffer, buf_size, name_size, handle, type);
 850     return E_NOTIMPL;
 851 }
 852
 853 static HRESULT STDMETHODCALLTYPE debugclient_AttachKernelWide(IDebugClient7 *iface, ULONG flags, const WCHAR *options)
 854 {
 855     FIXME("%p, 0x%08x, %s.\n", iface, flags, debugstr_w(options));
 856     return E_NOTIMPL;
 857 }
 858
 859 static HRESULT STDMETHODCALLTYPE debugclient_GetKernelConnectionOptionsWide(IDebugClient7 *iface, WCHAR *buffer,
 860                 ULONG buf_size, ULONG *size)
 861 {
 862     FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, size);
 863     return E_NOTIMPL;
 864 }
 865
 866 static HRESULT STDMETHODCALLTYPE debugclient_SetKernelConnectionOptionsWide(IDebugClient7 *iface, const WCHAR *options)
 867 {
 868     FIXME("%p, %p.\n", iface, options);
 869     return E_NOTIMPL;
 870 }
 871
 872 static HRESULT STDMETHODCALLTYPE debugclient_StartProcessServerWide(IDebugClient7 *iface, ULONG flags, const WCHAR *options, void *reserved)
 873 {
 874     FIXME("%p, 0x%08x, %s, %p.\n", iface, flags, debugstr_w(options), reserved);
 875     return E_NOTIMPL;
 876 }
 877
 878 static HRESULT STDMETHODCALLTYPE debugclient_ConnectProcessServerWide(IDebugClient7 *iface, const WCHAR *options, ULONG64 *server)
 879 {
 880     FIXME("%p, %s, %p.\n", iface, debugstr_w(options), server);
 881     return E_NOTIMPL;
 882 }
 883
 884 static HRESULT STDMETHODCALLTYPE debugclient_StartServerWide(IDebugClient7 *iface, const WCHAR *options)
 885 {
 886     FIXME("%p, %s.\n", iface, debugstr_w(options));
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT STDMETHODCALLTYPE debugclient_OutputServersWide(IDebugClient7 *iface, ULONG control, const WCHAR *machine, ULONG flags)
 891 {
 892     FIXME("%p, %d, %s, 0x%08x.\n", iface, control, debugstr_w(machine), flags);
 893     return E_NOTIMPL;
 894 }
 895
 896 static HRESULT STDMETHODCALLTYPE debugclient_GetOutputCallbacksWide(IDebugClient7 *iface, IDebugOutputCallbacksWide **callbacks)
 897 {
 898     FIXME("%p, %p.\n", iface, callbacks);
 899     return E_NOTIMPL;
 900 }
 901
 902 static HRESULT STDMETHODCALLTYPE debugclient_SetOutputCallbacksWide(IDebugClient7 *iface, IDebugOutputCallbacksWide *callbacks)
 903 {
 904     FIXME("%p, %p.\n", iface, callbacks);
 905     return E_NOTIMPL;
 906 }
 907
 908 static HRESULT STDMETHODCALLTYPE debugclient_GetOutputLinePrefixWide(IDebugClient7 *iface, WCHAR *buffer, ULONG buf_size, ULONG *size)
 909 {
 910     FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, size);
 911     return E_NOTIMPL;
 912 }
 913
 914 static HRESULT STDMETHODCALLTYPE debugclient_SetOutputLinePrefixWide(IDebugClient7 *iface, const WCHAR *prefix)
 915 {
 916     FIXME("%p, %s.\n", iface, debugstr_w(prefix));
 917     return E_NOTIMPL;
 918 }
 919
 920 static HRESULT STDMETHODCALLTYPE debugclient_GetIdentityWide(IDebugClient7 *iface, WCHAR *buffer, ULONG buf_size, ULONG *identity)
 921 {
 922     FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, identity);
 923     return E_NOTIMPL;
 924 }
 925
 926 static HRESULT STDMETHODCALLTYPE debugclient_OutputIdentityWide(IDebugClient7 *iface, ULONG control, ULONG flags, const WCHAR *format)
 927 {
 928     FIXME("%p, %d, 0x%08x, %s.\n", iface, control, flags, debugstr_w(format));
 929     return E_NOTIMPL;
 930 }
 931
 932 static HRESULT STDMETHODCALLTYPE debugclient_GetEventCallbacksWide(IDebugClient7 *iface, IDebugEventCallbacksWide **callbacks)
 933 {
 934     FIXME("%p, %p .\n", iface, callbacks);
 935     return E_NOTIMPL;
 936 }
 937
 938 static HRESULT STDMETHODCALLTYPE debugclient_SetEventCallbacksWide(IDebugClient7 *iface, IDebugEventCallbacksWide *callbacks)
 939 {
 940     FIXME("%p .\n", iface);
 941     return E_NOTIMPL;
 942 }
 943
 944 static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess2(IDebugClient7 *iface, ULONG64 server, char *command, void *options,
 945             ULONG buf_size, const char *initial, const char *environment)
 946 {
 947     FIXME("%p %s, %s, %p, %d, %s, %s.\n", iface, wine_dbgstr_longlong(server), debugstr_a(command), options,
 948             buf_size, debugstr_a(initial), debugstr_a(environment));
 949     return E_NOTIMPL;
 950 }
 951
 952 static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess2Wide(IDebugClient7 *iface, ULONG64 server, WCHAR *command, void *options,
 953             ULONG size, const WCHAR *initial, const WCHAR *environment)
 954 {
 955     FIXME("%p %s, %s, %p, %d, %s, %s.\n", iface, wine_dbgstr_longlong(server), debugstr_w(command), options,
 956             size, debugstr_w(initial), debugstr_w(environment));
 957     return E_NOTIMPL;
 958 }
 959
 960 static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach2(IDebugClient7 *iface, ULONG64 server, char *command,
 961             void *options, ULONG buf_size, const char *initial, const char *environment, ULONG processid, ULONG flags)
 962 {
 963     FIXME("%p %s, %s, %p, %d, %s, %s, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_a(command), options,
 964             buf_size, debugstr_a(initial), debugstr_a(environment), processid, flags);
 965     return E_NOTIMPL;
 966 }
 967
 968 static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach2Wide(IDebugClient7 *iface, ULONG64 server, WCHAR *command,
 969             void *buffer, ULONG buf_size, const WCHAR *initial, const WCHAR *environment, ULONG processid, ULONG flags)
 970 {
 971     FIXME("%p %s, %s, %p, %d, %s, %s, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(command), buffer,
 972             buf_size, debugstr_w(initial), debugstr_w(environment), processid, flags);
 973     return E_NOTIMPL;
 974 }
 975
 976 static HRESULT STDMETHODCALLTYPE debugclient_PushOutputLinePrefix(IDebugClient7 *iface, const char *prefix, ULONG64 *handle)
 977 {
 978     FIXME("%p, %p.\n", iface, handle);
 979     return E_NOTIMPL;
 980 }
 981
 982 static HRESULT STDMETHODCALLTYPE debugclient_PushOutputLinePrefixWide(IDebugClient7 *iface, const WCHAR *prefix, ULONG64 *handle)
 983 {
 984     FIXME("%p, %p.\n", iface, handle);
 985     return E_NOTIMPL;
 986 }
 987
 988 static HRESULT STDMETHODCALLTYPE debugclient_PopOutputLinePrefix(IDebugClient7 *iface, ULONG64 handle)
 989 {
 990     FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(handle));
 991     return E_NOTIMPL;
 992 }
 993
 994 static HRESULT STDMETHODCALLTYPE debugclient_GetNumberInputCallbacks(IDebugClient7 *iface, ULONG *count)
 995 {
 996     FIXME("%p, %p.\n", iface, count);
 997     return E_NOTIMPL;
 998 }
 999
1000 static HRESULT STDMETHODCALLTYPE debugclient_GetNumberOutputCallbacks(IDebugClient7 *iface, ULONG *count)
1001 {
1002     FIXME("%p, %p.\n", iface, count);
1003     return E_NOTIMPL;
1004 }
1005
1006 static HRESULT STDMETHODCALLTYPE debugclient_GetNumberEventCallbacks(IDebugClient7 *iface, ULONG flags, ULONG *count)
1007 {
1008     FIXME("%p, 0x%08x, %p.\n", iface, flags, count);
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT STDMETHODCALLTYPE debugclient_GetQuitLockString(IDebugClient7 *iface, char *buffer, ULONG buf_size, ULONG *size)
1013 {
1014     FIXME("%p, %s, %d, %p.\n", iface, debugstr_a(buffer), buf_size, size);
1015     return E_NOTIMPL;
1016 }
1017
1018 static HRESULT STDMETHODCALLTYPE debugclient_SetQuitLockString(IDebugClient7 *iface, char *string)
1019 {
1020     FIXME("%p, %s.\n", iface, debugstr_a(string));
1021     return E_NOTIMPL;
1022 }
1023
1024 static HRESULT STDMETHODCALLTYPE debugclient_GetQuitLockStringWide(IDebugClient7 *iface, WCHAR *buffer, ULONG buf_size, ULONG *size)
1025 {
1026     FIXME("%p, %s, %d, %p.\n", iface, debugstr_w(buffer), buf_size, size);
1027     return E_NOTIMPL;
1028 }
1029
1030 static HRESULT STDMETHODCALLTYPE debugclient_SetQuitLockStringWide(IDebugClient7 *iface, const WCHAR *string)
1031 {
1032     FIXME("%p, %s.\n", iface, debugstr_w(string));
1033     return E_NOTIMPL;
1034 }
1035
1036 static HRESULT STDMETHODCALLTYPE debugclient_SetEventContextCallbacks(IDebugClient7 *iface, IDebugEventContextCallbacks *callbacks)
1037 {
1038     FIXME("%p, %p.\n", iface, callbacks);
1039     return E_NOTIMPL;
1040 }
1041
1042 static HRESULT STDMETHODCALLTYPE debugclient_SetClientContext(IDebugClient7 *iface, void *context, ULONG size)
1043 {
1044     FIXME("%p, %p, %d.\n", iface, context, size);
1045     return E_NOTIMPL;
1046 }
1047
1048 static const IDebugClient7Vtbl debugclientvtbl =
1049 {
1050     debugclient_QueryInterface,
1051     debugclient_AddRef,
1052     debugclient_Release,
1053     debugclient_AttachKernel,
1054     debugclient_GetKernelConnectionOptions,
1055     debugclient_SetKernelConnectionOptions,
1056     debugclient_StartProcessServer,
1057     debugclient_ConnectProcessServer,
1058     debugclient_DisconnectProcessServer,
1059     debugclient_GetRunningProcessSystemIds,
1060     debugclient_GetRunningProcessSystemIdByExecutableName,
1061     debugclient_GetRunningProcessDescription,
1062     debugclient_AttachProcess,
1063     debugclient_CreateProcess,
1064     debugclient_CreateProcessAndAttach,
1065     debugclient_GetProcessOptions,
1066     debugclient_AddProcessOptions,
1067     debugclient_RemoveProcessOptions,
1068     debugclient_SetProcessOptions,
1069     debugclient_OpenDumpFile,
1070     debugclient_WriteDumpFile,
1071     debugclient_ConnectSession,
1072     debugclient_StartServer,
1073     debugclient_OutputServers,
1074     debugclient_TerminateProcesses,
1075     debugclient_DetachProcesses,
1076     debugclient_EndSession,
1077     debugclient_GetExitCode,
1078     debugclient_DispatchCallbacks,
1079     debugclient_ExitDispatch,
1080     debugclient_CreateClient,
1081     debugclient_GetInputCallbacks,
1082     debugclient_SetInputCallbacks,
1083     debugclient_GetOutputCallbacks,
1084     debugclient_SetOutputCallbacks,
1085     debugclient_GetOutputMask,
1086     debugclient_SetOutputMask,
1087     debugclient_GetOtherOutputMask,
1088     debugclient_SetOtherOutputMask,
1089     debugclient_GetOutputWidth,
1090     debugclient_SetOutputWidth,
1091     debugclient_GetOutputLinePrefix,
1092     debugclient_SetOutputLinePrefix,
1093     debugclient_GetIdentity,
1094     debugclient_OutputIdentity,
1095     debugclient_GetEventCallbacks,
1096     debugclient_SetEventCallbacks,
1097     debugclient_FlushCallbacks,
1098     /* IDebugClient2 */
1099     debugclient_WriteDumpFile2,
1100     debugclient_AddDumpInformationFile,
1101     debugclient_EndProcessServer,
1102     debugclient_WaitForProcessServerEnd,
1103     debugclient_IsKernelDebuggerEnabled,
1104     debugclient_TerminateCurrentProcess,
1105     debugclient_DetachCurrentProcess,
1106     debugclient_AbandonCurrentProcess,
1107     /* IDebugClient3 */
1108     debugclient_GetRunningProcessSystemIdByExecutableNameWide,
1109     debugclient_GetRunningProcessDescriptionWide,
1110     debugclient_CreateProcessWide,
1111     debugclient_CreateProcessAndAttachWide,
1112     /* IDebugClient4 */
1113     debugclient_OpenDumpFileWide,
1114     debugclient_WriteDumpFileWide,
1115     debugclient_AddDumpInformationFileWide,
1116     debugclient_GetNumberDumpFiles,
1117     debugclient_GetDumpFile,
1118     debugclient_GetDumpFileWide,
1119     /* IDebugClient5 */
1120     debugclient_AttachKernelWide,
1121     debugclient_GetKernelConnectionOptionsWide,
1122     debugclient_SetKernelConnectionOptionsWide,
1123     debugclient_StartProcessServerWide,
1124     debugclient_ConnectProcessServerWide,
1125     debugclient_StartServerWide,
1126     debugclient_OutputServersWide,
1127     debugclient_GetOutputCallbacksWide,
1128     debugclient_SetOutputCallbacksWide,
1129     debugclient_GetOutputLinePrefixWide,
1130     debugclient_SetOutputLinePrefixWide,
1131     debugclient_GetIdentityWide,
1132     debugclient_OutputIdentityWide,
1133     debugclient_GetEventCallbacksWide,
1134     debugclient_SetEventCallbacksWide,
1135     debugclient_CreateProcess2,
1136     debugclient_CreateProcess2Wide,
1137     debugclient_CreateProcessAndAttach2,
1138     debugclient_CreateProcessAndAttach2Wide,
1139     debugclient_PushOutputLinePrefix,
1140     debugclient_PushOutputLinePrefixWide,
1141     debugclient_PopOutputLinePrefix,
1142     debugclient_GetNumberInputCallbacks,
1143     debugclient_GetNumberOutputCallbacks,
1144     debugclient_GetNumberEventCallbacks,
1145     debugclient_GetQuitLockString,
1146     debugclient_SetQuitLockString,
1147     debugclient_GetQuitLockStringWide,
1148     debugclient_SetQuitLockStringWide,
1149     /* IDebugClient6 */
1150     debugclient_SetEventContextCallbacks,
1151     /* IDebugClient7 */
1152     debugclient_SetClientContext,
1153 };
1154
1155 static HRESULT STDMETHODCALLTYPE debugdataspaces_QueryInterface(IDebugDataSpaces *iface, REFIID riid, void **obj)
1156 {
1157     struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
1158     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1159     return IUnknown_QueryInterface(unk, riid, obj);
1160 }
1161
1162 static ULONG STDMETHODCALLTYPE debugdataspaces_AddRef(IDebugDataSpaces *iface)
1163 {
1164     struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
1165     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1166     return IUnknown_AddRef(unk);
1167 }
1168
1169 static ULONG STDMETHODCALLTYPE debugdataspaces_Release(IDebugDataSpaces *iface)
1170 {
1171     struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
1172     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1173     return IUnknown_Release(unk);
1174 }
1175
1176 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadVirtual(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
1177         ULONG buffer_size, ULONG *read_len)
1178 {
1179     struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
1180     static struct target_process *target;
1181     HRESULT hr = S_OK;
1182     SIZE_T length;
1183
1184     TRACE("%p, %s, %p, %u, %p.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1185
1186     if (!(target = debug_client_get_target(debug_client)))
1187         return E_UNEXPECTED;
1188
1189     if (ReadProcessMemory(target->handle, (const void *)(ULONG_PTR)offset, buffer, buffer_size, &length))
1190     {
1191         if (read_len)
1192             *read_len = length;
1193     }
1194     else
1195     {
1196         hr = HRESULT_FROM_WIN32(GetLastError());
1197         WARN("Failed to read process memory %#x.\n", hr);
1198     }
1199
1200     return hr;
1201 }
1202
1203 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteVirtual(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
1204         ULONG buffer_size, ULONG *written)
1205 {
1206     FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1207
1208     return E_NOTIMPL;
1209 }
1210
1211 static HRESULT STDMETHODCALLTYPE debugdataspaces_SearchVirtual(IDebugDataSpaces *iface, ULONG64 offset, ULONG64 length,
1212         void *pattern, ULONG pattern_size, ULONG pattern_granularity, ULONG64 *ret_offset)
1213 {
1214     FIXME("%p, %s, %s, %p, %u, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(length),
1215             pattern, pattern_size, pattern_granularity, ret_offset);
1216
1217     return E_NOTIMPL;
1218 }
1219
1220 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadVirtualUncached(IDebugDataSpaces *iface, ULONG64 offset,
1221         void *buffer, ULONG buffer_size, ULONG *read_len)
1222 {
1223     FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1224
1225     return E_NOTIMPL;
1226 }
1227
1228 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteVirtualUncached(IDebugDataSpaces *iface, ULONG64 offset,
1229         void *buffer, ULONG buffer_size, ULONG *written)
1230 {
1231     FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1232
1233     return E_NOTIMPL;
1234 }
1235
1236 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadPointersVirtual(IDebugDataSpaces *iface, ULONG count,
1237         ULONG64 offset, ULONG64 *pointers)
1238 {
1239     FIXME("%p, %u, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset), pointers);
1240
1241     return E_NOTIMPL;
1242 }
1243
1244 static HRESULT STDMETHODCALLTYPE debugdataspaces_WritePointersVirtual(IDebugDataSpaces *iface, ULONG count,
1245         ULONG64 offset, ULONG64 *pointers)
1246 {
1247     FIXME("%p, %u, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset), pointers);
1248
1249     return E_NOTIMPL;
1250 }
1251
1252 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadPhysical(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
1253         ULONG buffer_size, ULONG *read_len)
1254 {
1255     FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1256
1257     return E_NOTIMPL;
1258 }
1259
1260 static HRESULT STDMETHODCALLTYPE debugdataspaces_WritePhysical(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
1261         ULONG buffer_size, ULONG *written)
1262 {
1263     FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1264
1265     return E_NOTIMPL;
1266 }
1267
1268 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadControl(IDebugDataSpaces *iface, ULONG processor, ULONG64 offset,
1269         void *buffer, ULONG buffer_size, ULONG *read_len)
1270 {
1271     FIXME("%p, %u, %s, %p, %u, %p stub.\n", iface, processor, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1272
1273     return E_NOTIMPL;
1274 }
1275
1276 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteControl(IDebugDataSpaces *iface, ULONG processor, ULONG64 offset,
1277         void *buffer, ULONG buffer_size, ULONG *written)
1278 {
1279     FIXME("%p, %u, %s, %p, %u, %p stub.\n", iface, processor, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1280
1281     return E_NOTIMPL;
1282 }
1283
1284 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadIo(IDebugDataSpaces *iface, ULONG type, ULONG bus_number,
1285         ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG *read_len)
1286 {
1287     FIXME("%p, %u, %u, %u, %s, %p, %u, %p stub.\n", iface, type, bus_number, address_space, wine_dbgstr_longlong(offset),
1288             buffer, buffer_size, read_len);
1289
1290     return E_NOTIMPL;
1291 }
1292
1293 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteIo(IDebugDataSpaces *iface, ULONG type, ULONG bus_number,
1294         ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG *written)
1295 {
1296     FIXME("%p, %u, %u, %u, %s, %p, %u, %p stub.\n", iface, type, bus_number, address_space, wine_dbgstr_longlong(offset),
1297             buffer, buffer_size, written);
1298
1299     return E_NOTIMPL;
1300 }
1301
1302 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadMsr(IDebugDataSpaces *iface, ULONG msr, ULONG64 *value)
1303 {
1304     FIXME("%p, %u, %p stub.\n", iface, msr, value);
1305
1306     return E_NOTIMPL;
1307 }
1308
1309 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteMsr(IDebugDataSpaces *iface, ULONG msr, ULONG64 value)
1310 {
1311     FIXME("%p, %u, %s stub.\n", iface, msr, wine_dbgstr_longlong(value));
1312
1313     return E_NOTIMPL;
1314 }
1315
1316 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadBusData(IDebugDataSpaces *iface, ULONG data_type,
1317         ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG buffer_size, ULONG *read_len)
1318 {
1319     FIXME("%p, %u, %u, %u, %u, %p, %u, %p stub.\n", iface, data_type, bus_number, slot_number, offset, buffer,
1320             buffer_size, read_len);
1321
1322     return E_NOTIMPL;
1323 }
1324
1325 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteBusData(IDebugDataSpaces *iface, ULONG data_type,
1326         ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG buffer_size, ULONG *written)
1327 {
1328     FIXME("%p, %u, %u, %u, %u, %p, %u, %p stub.\n", iface, data_type, bus_number, slot_number, offset, buffer,
1329             buffer_size, written);
1330
1331     return E_NOTIMPL;
1332 }
1333
1334 static HRESULT STDMETHODCALLTYPE debugdataspaces_CheckLowMemory(IDebugDataSpaces *iface)
1335 {
1336     FIXME("%p stub.\n", iface);
1337
1338     return E_NOTIMPL;
1339 }
1340
1341 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadDebuggerData(IDebugDataSpaces *iface, ULONG index, void *buffer,
1342         ULONG buffer_size, ULONG *data_size)
1343 {
1344     FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, data_size);
1345
1346     return E_NOTIMPL;
1347 }
1348
1349 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadProcessorSystemData(IDebugDataSpaces *iface, ULONG processor,
1350         ULONG index, void *buffer, ULONG buffer_size, ULONG *data_size)
1351 {
1352     FIXME("%p, %u, %u, %p, %u, %p stub.\n", iface, processor, index, buffer, buffer_size, data_size);
1353
1354     return E_NOTIMPL;
1355 }
1356
1357 static const IDebugDataSpacesVtbl debugdataspacesvtbl =
1358 {
1359     debugdataspaces_QueryInterface,
1360     debugdataspaces_AddRef,
1361     debugdataspaces_Release,
1362     debugdataspaces_ReadVirtual,
1363     debugdataspaces_WriteVirtual,
1364     debugdataspaces_SearchVirtual,
1365     debugdataspaces_ReadVirtualUncached,
1366     debugdataspaces_WriteVirtualUncached,
1367     debugdataspaces_ReadPointersVirtual,
1368     debugdataspaces_WritePointersVirtual,
1369     debugdataspaces_ReadPhysical,
1370     debugdataspaces_WritePhysical,
1371     debugdataspaces_ReadControl,
1372     debugdataspaces_WriteControl,
1373     debugdataspaces_ReadIo,
1374     debugdataspaces_WriteIo,
1375     debugdataspaces_ReadMsr,
1376     debugdataspaces_WriteMsr,
1377     debugdataspaces_ReadBusData,
1378     debugdataspaces_WriteBusData,
1379     debugdataspaces_CheckLowMemory,
1380     debugdataspaces_ReadDebuggerData,
1381     debugdataspaces_ReadProcessorSystemData,
1382 };
1383
1384 static HRESULT STDMETHODCALLTYPE debugsymbols_QueryInterface(IDebugSymbols3 *iface, REFIID riid, void **obj)
1385 {
1386     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1387     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1388     return IUnknown_QueryInterface(unk, riid, obj);
1389 }
1390
1391 static ULONG STDMETHODCALLTYPE debugsymbols_AddRef(IDebugSymbols3 *iface)
1392 {
1393     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1394     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1395     return IUnknown_AddRef(unk);
1396 }
1397
1398 static ULONG STDMETHODCALLTYPE debugsymbols_Release(IDebugSymbols3 *iface)
1399 {
1400     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1401     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1402     return IUnknown_Release(unk);
1403 }
1404
1405 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolOptions(IDebugSymbols3 *iface, ULONG *options)
1406 {
1407     FIXME("%p, %p stub.\n", iface, options);
1408
1409     return E_NOTIMPL;
1410 }
1411
1412 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSymbolOptions(IDebugSymbols3 *iface, ULONG options)
1413 {
1414     FIXME("%p, %#x stub.\n", iface, options);
1415
1416     return E_NOTIMPL;
1417 }
1418
1419 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSymbolOptions(IDebugSymbols3 *iface, ULONG options)
1420 {
1421     FIXME("%p, %#x stub.\n", iface, options);
1422
1423     return E_NOTIMPL;
1424 }
1425
1426 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolOptions(IDebugSymbols3 *iface, ULONG options)
1427 {
1428     FIXME("%p, %#x stub.\n", iface, options);
1429
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffset(IDebugSymbols3 *iface, ULONG64 offset, char *buffer,
1434         ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
1435 {
1436     FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size,
1437             name_size, displacement);
1438
1439     return E_NOTIMPL;
1440 }
1441
1442 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByName(IDebugSymbols3 *iface, const char *symbol,
1443         ULONG64 *offset)
1444 {
1445     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), offset);
1446
1447     return E_NOTIMPL;
1448 }
1449
1450 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffset(IDebugSymbols3 *iface, ULONG64 offset, LONG delta,
1451         char *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
1452 {
1453     FIXME("%p, %s, %d, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
1454             name_size, displacement);
1455
1456     return E_NOTIMPL;
1457 }
1458
1459 static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffset(IDebugSymbols3 *iface, ULONG64 offset, ULONG *line,
1460         char *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
1461 {
1462     FIXME("%p, %s, %p, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
1463             file_size, displacement);
1464
1465     return E_NOTIMPL;
1466 }
1467
1468 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLine(IDebugSymbols3 *iface, ULONG line, const char *file,
1469         ULONG64 *offset)
1470 {
1471     FIXME("%p, %u, %s, %p stub.\n", iface, line, debugstr_a(file), offset);
1472
1473     return E_NOTIMPL;
1474 }
1475
1476 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNumberModules(IDebugSymbols3 *iface, ULONG *loaded, ULONG *unloaded)
1477 {
1478     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1479     static struct target_process *target;
1480     HRESULT hr;
1481
1482     TRACE("%p, %p, %p.\n", iface, loaded, unloaded);
1483
1484     if (!(target = debug_client_get_target(debug_client)))
1485         return E_UNEXPECTED;
1486
1487     if (FAILED(hr = debug_target_init_modules_info(target)))
1488         return hr;
1489
1490     *loaded = target->modules.loaded;
1491     *unloaded = target->modules.unloaded;
1492
1493     return S_OK;
1494 }
1495
1496 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByIndex(IDebugSymbols3 *iface, ULONG index, ULONG64 *base)
1497 {
1498     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1499     const struct module_info *info;
1500     struct target_process *target;
1501
1502     TRACE("%p, %u, %p.\n", iface, index, base);
1503
1504     if (!(target = debug_client_get_target(debug_client)))
1505         return E_UNEXPECTED;
1506
1507     if (!(info = debug_target_get_module_info(target, index)))
1508         return E_INVALIDARG;
1509
1510     *base = info->params.Base;
1511
1512     return S_OK;
1513 }
1514
1515 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName(IDebugSymbols3 *iface, const char *name,
1516         ULONG start_index, ULONG *index, ULONG64 *base)
1517 {
1518     FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_a(name), start_index, index, base);
1519
1520     return E_NOTIMPL;
1521 }
1522
1523 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset(IDebugSymbols3 *iface, ULONG64 offset,
1524         ULONG start_index, ULONG *index, ULONG64 *base)
1525 {
1526     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1527     static struct target_process *target;
1528     const struct module_info *info;
1529
1530     TRACE("%p, %s, %u, %p, %p.\n", iface, wine_dbgstr_longlong(offset), start_index, index, base);
1531
1532     if (!(target = debug_client_get_target(debug_client)))
1533         return E_UNEXPECTED;
1534
1535     while ((info = debug_target_get_module_info(target, start_index)))
1536     {
1537         if (offset >= info->params.Base && offset < info->params.Base + info->params.Size)
1538         {
1539             if (index)
1540                 *index = start_index;
1541             if (base)
1542                 *base = info->params.Base;
1543             return S_OK;
1544         }
1545
1546         start_index++;
1547     }
1548
1549     return E_INVALIDARG;
1550 }
1551
1552 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNames(IDebugSymbols3 *iface, ULONG index, ULONG64 base,
1553         char *image_name, ULONG image_name_buffer_size, ULONG *image_name_size, char *module_name,
1554         ULONG module_name_buffer_size, ULONG *module_name_size, char *loaded_image_name,
1555         ULONG loaded_image_name_buffer_size, ULONG *loaded_image_size)
1556 {
1557     FIXME("%p, %u, %s, %p, %u, %p, %p, %u, %p, %p, %u, %p stub.\n", iface, index, wine_dbgstr_longlong(base),
1558             image_name, image_name_buffer_size, image_name_size, module_name, module_name_buffer_size,
1559             module_name_size, loaded_image_name, loaded_image_name_buffer_size, loaded_image_size);
1560
1561     return E_NOTIMPL;
1562 }
1563
1564 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleParameters(IDebugSymbols3 *iface, ULONG count, ULONG64 *bases,
1565         ULONG start, DEBUG_MODULE_PARAMETERS *params)
1566 {
1567     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1568     const struct module_info *info;
1569     struct target_process *target;
1570     unsigned int i;
1571
1572     TRACE("%p, %u, %p, %u, %p.\n", iface, count, bases, start, params);
1573
1574     if (!(target = debug_client_get_target(debug_client)))
1575         return E_UNEXPECTED;
1576
1577     if (bases)
1578     {
1579         for (i = 0; i < count; ++i)
1580         {
1581             if ((info = debug_target_get_module_info_by_base(target, bases[i])))
1582             {
1583                 params[i] = info->params;
1584             }
1585             else
1586             {
1587                 memset(&params[i], 0, sizeof(*params));
1588                 params[i].Base = DEBUG_INVALID_OFFSET;
1589             }
1590         }
1591     }
1592     else
1593     {
1594         for (i = start; i < start + count; ++i)
1595         {
1596             if (!(info = debug_target_get_module_info(target, i)))
1597                 return E_INVALIDARG;
1598             params[i] = info->params;
1599         }
1600     }
1601
1602     return S_OK;
1603 }
1604
1605 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModule(IDebugSymbols3 *iface, const char *symbol, ULONG64 *base)
1606 {
1607     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), base);
1608
1609     return E_NOTIMPL;
1610 }
1611
1612 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeName(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
1613         char *buffer, ULONG buffer_size, ULONG *name_size)
1614 {
1615     FIXME("%p, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, buffer,
1616             buffer_size, name_size);
1617
1618     return E_NOTIMPL;
1619 }
1620
1621 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeId(IDebugSymbols3 *iface, ULONG64 base, const char *name,
1622         ULONG *type_id)
1623 {
1624     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), debugstr_a(name), type_id);
1625
1626     return E_NOTIMPL;
1627 }
1628
1629 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeSize(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
1630         ULONG *size)
1631 {
1632     FIXME("%p, %s, %u, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, size);
1633
1634     return E_NOTIMPL;
1635 }
1636
1637 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffset(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
1638         const char *field, ULONG *offset)
1639 {
1640     FIXME("%p, %s, %u, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, debugstr_a(field), offset);
1641
1642     return E_NOTIMPL;
1643 }
1644
1645 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeId(IDebugSymbols3 *iface, const char *symbol, ULONG *type_id,
1646         ULONG64 *base)
1647 {
1648     FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_a(symbol), type_id, base);
1649
1650     return E_NOTIMPL;
1651 }
1652
1653 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetTypeId(IDebugSymbols3 *iface, ULONG64 offset, ULONG *type_id,
1654         ULONG64 *base)
1655 {
1656     FIXME("%p, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), type_id, base);
1657
1658     return E_NOTIMPL;
1659 }
1660
1661 static HRESULT STDMETHODCALLTYPE debugsymbols_ReadTypedDataVirtual(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
1662         ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
1663 {
1664     FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1665             type_id, buffer, buffer_size, read_len);
1666
1667     return E_NOTIMPL;
1668 }
1669
1670 static HRESULT STDMETHODCALLTYPE debugsymbols_WriteTypedDataVirtual(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
1671         ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
1672 {
1673     FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1674             type_id, buffer, buffer_size, written);
1675
1676     return E_NOTIMPL;
1677 }
1678
1679 static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataVirtual(IDebugSymbols3 *iface, ULONG output_control,
1680         ULONG64 offset, ULONG64 base, ULONG type_id, ULONG flags)
1681 {
1682     FIXME("%p, %#x, %s, %s, %u, %#x stub.\n", iface, output_control, wine_dbgstr_longlong(offset),
1683             wine_dbgstr_longlong(base), type_id, flags);
1684
1685     return E_NOTIMPL;
1686 }
1687
1688 static HRESULT STDMETHODCALLTYPE debugsymbols_ReadTypedDataPhysical(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
1689         ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
1690 {
1691     FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1692             type_id, buffer, buffer_size, read_len);
1693
1694     return E_NOTIMPL;
1695 }
1696
1697 static HRESULT STDMETHODCALLTYPE debugsymbols_WriteTypedDataPhysical(IDebugSymbols3 *iface, ULONG64 offset,
1698         ULONG64 base, ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
1699 {
1700     FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1701             type_id, buffer, buffer_size, written);
1702
1703     return E_NOTIMPL;
1704 }
1705
1706 static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataPhysical(IDebugSymbols3 *iface, ULONG output_control,
1707         ULONG64 offset, ULONG64 base, ULONG type_id, ULONG flags)
1708 {
1709     FIXME("%p, %#x, %s, %s, %u, %#x stub.\n", iface, output_control, wine_dbgstr_longlong(offset),
1710             wine_dbgstr_longlong(base), type_id, flags);
1711
1712     return E_NOTIMPL;
1713 }
1714
1715 static HRESULT STDMETHODCALLTYPE debugsymbols_GetScope(IDebugSymbols3 *iface, ULONG64 *instr_offset,
1716         DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
1717 {
1718     FIXME("%p, %p, %p, %p, %u stub.\n", iface, instr_offset, frame, scope_context, scope_context_size);
1719
1720     return E_NOTIMPL;
1721 }
1722
1723 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScope(IDebugSymbols3 *iface, ULONG64 instr_offset,
1724         DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
1725 {
1726     FIXME("%p, %s, %p, %p, %u stub.\n", iface, wine_dbgstr_longlong(instr_offset), frame, scope_context,
1727             scope_context_size);
1728
1729     return E_NOTIMPL;
1730 }
1731
1732 static HRESULT STDMETHODCALLTYPE debugsymbols_ResetScope(IDebugSymbols3 *iface)
1733 {
1734     FIXME("%p stub.\n", iface);
1735
1736     return E_NOTIMPL;
1737 }
1738
1739 static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup(IDebugSymbols3 *iface, ULONG flags,
1740         IDebugSymbolGroup *update, IDebugSymbolGroup **symbols)
1741 {
1742     FIXME("%p, %#x, %p, %p stub.\n", iface, flags, update, symbols);
1743
1744     return E_NOTIMPL;
1745 }
1746
1747 static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup(IDebugSymbols3 *iface, IDebugSymbolGroup **group)
1748 {
1749     FIXME("%p, %p stub.\n", iface, group);
1750
1751     return E_NOTIMPL;
1752 }
1753
1754 static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatch(IDebugSymbols3 *iface, const char *pattern,
1755         ULONG64 *handle)
1756 {
1757     FIXME("%p, %s, %p stub.\n", iface, pattern, handle);
1758
1759     return E_NOTIMPL;
1760 }
1761
1762 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatch(IDebugSymbols3 *iface, ULONG64 handle, char *buffer,
1763         ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
1764 {
1765     FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
1766
1767     return E_NOTIMPL;
1768 }
1769
1770 static HRESULT STDMETHODCALLTYPE debugsymbols_EndSymbolMatch(IDebugSymbols3 *iface, ULONG64 handle)
1771 {
1772     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
1773
1774     return E_NOTIMPL;
1775 }
1776
1777 static HRESULT STDMETHODCALLTYPE debugsymbols_Reload(IDebugSymbols3 *iface, const char *path)
1778 {
1779     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1780
1781     return E_NOTIMPL;
1782 }
1783
1784 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
1785         ULONG *path_size)
1786 {
1787     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
1788
1789     return E_NOTIMPL;
1790 }
1791
1792 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPath(IDebugSymbols3 *iface, const char *path)
1793 {
1794     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1795
1796     return E_NOTIMPL;
1797 }
1798
1799 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPath(IDebugSymbols3 *iface, const char *path)
1800 {
1801     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1802
1803     return E_NOTIMPL;
1804 }
1805
1806 static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
1807         ULONG *path_size)
1808 {
1809     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
1810
1811     return E_NOTIMPL;
1812 }
1813
1814 static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePath(IDebugSymbols3 *iface, const char *path)
1815 {
1816     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1817
1818     return E_NOTIMPL;
1819 }
1820
1821 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePath(IDebugSymbols3 *iface, const char *path)
1822 {
1823     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1824
1825     return E_NOTIMPL;
1826 }
1827
1828 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
1829         ULONG *path_size)
1830 {
1831     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
1832
1833     return E_NOTIMPL;
1834 }
1835
1836 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElement(IDebugSymbols3 *iface, ULONG index, char *buffer,
1837         ULONG buffer_size, ULONG *element_size)
1838 {
1839     FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, element_size);
1840
1841     return E_NOTIMPL;
1842 }
1843
1844 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePath(IDebugSymbols3 *iface, const char *path)
1845 {
1846     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1847
1848     return E_NOTIMPL;
1849 }
1850
1851 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePath(IDebugSymbols3 *iface, const char *path)
1852 {
1853     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1854
1855     return E_NOTIMPL;
1856 }
1857
1858 static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFile(IDebugSymbols3 *iface, ULONG start, const char *file,
1859         ULONG flags, ULONG *found_element, char *buffer, ULONG buffer_size, ULONG *found_size)
1860 {
1861     FIXME("%p, %u, %s, %#x, %p, %p, %u, %p stub.\n", iface, start, debugstr_a(file), flags, found_element, buffer,
1862             buffer_size, found_size);
1863
1864     return E_NOTIMPL;
1865 }
1866
1867 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsets(IDebugSymbols3 *iface, const char *file,
1868         ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
1869 {
1870     FIXME("%p, %s, %p, %u, %p stub.\n", iface, debugstr_a(file), buffer, buffer_lines, file_lines);
1871
1872     return E_NOTIMPL;
1873 }
1874
1875 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleVersionInformation(IDebugSymbols3 *iface, ULONG index,
1876         ULONG64 base, const char *item, void *buffer, ULONG buffer_size, ULONG *info_size)
1877 {
1878     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1879     const struct module_info *info;
1880     struct target_process *target;
1881     void *version_info, *ptr;
1882     HRESULT hr = E_FAIL;
1883     DWORD handle, size;
1884
1885     TRACE("%p, %u, %s, %s, %p, %u, %p.\n", iface, index, wine_dbgstr_longlong(base), debugstr_a(item), buffer,
1886             buffer_size, info_size);
1887
1888     if (!(target = debug_client_get_target(debug_client)))
1889         return E_UNEXPECTED;
1890
1891     if (index == DEBUG_ANY_ID)
1892         info = debug_target_get_module_info_by_base(target, base);
1893     else
1894         info = debug_target_get_module_info(target, index);
1895
1896     if (!info)
1897     {
1898         WARN("Was unable to locate module.\n");
1899         return E_INVALIDARG;
1900     }
1901
1902     if (!(size = GetFileVersionInfoSizeA(info->image_name, &handle)))
1903         return E_FAIL;
1904
1905     if (!(version_info = heap_alloc(size)))
1906         return E_OUTOFMEMORY;
1907
1908     if (GetFileVersionInfoA(info->image_name, handle, size, version_info))
1909     {
1910         if (VerQueryValueA(version_info, item, &ptr, &size))
1911         {
1912             if (info_size)
1913                 *info_size = size;
1914
1915             if (buffer && buffer_size)
1916             {
1917                 unsigned int dst_len = min(size, buffer_size);
1918                 if (dst_len)
1919                     memcpy(buffer, ptr, dst_len);
1920             }
1921
1922             hr = buffer && buffer_size < size ? S_FALSE : S_OK;
1923         }
1924     }
1925
1926     heap_free(version_info);
1927
1928     return hr;
1929 }
1930
1931 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameString(IDebugSymbols3 *iface, ULONG which, ULONG index,
1932         ULONG64 base, char *buffer, ULONG buffer_size, ULONG *name_size)
1933 {
1934     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1935     const struct module_info *info;
1936     struct target_process *target;
1937     HRESULT hr;
1938
1939     TRACE("%p, %u, %u, %s, %p, %u, %p.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
1940             name_size);
1941
1942     if (!(target = debug_client_get_target(debug_client)))
1943         return E_UNEXPECTED;
1944
1945     if (index == DEBUG_ANY_ID)
1946         info = debug_target_get_module_info_by_base(target, base);
1947     else
1948         info = debug_target_get_module_info(target, index);
1949
1950     if (!info)
1951     {
1952         WARN("Was unable to locate module.\n");
1953         return E_INVALIDARG;
1954     }
1955
1956     switch (which)
1957     {
1958         case DEBUG_MODNAME_IMAGE:
1959             hr = debug_target_return_string(info->image_name, buffer, buffer_size, name_size);
1960             break;
1961         case DEBUG_MODNAME_MODULE:
1962         case DEBUG_MODNAME_LOADED_IMAGE:
1963         case DEBUG_MODNAME_SYMBOL_FILE:
1964         case DEBUG_MODNAME_MAPPED_IMAGE:
1965             FIXME("Unsupported name info %d.\n", which);
1966             return E_NOTIMPL;
1967         default:
1968             WARN("Unknown name info %d.\n", which);
1969             return E_INVALIDARG;
1970     }
1971
1972     return hr;
1973 }
1974
1975 static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantName(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
1976         ULONG64 value, char *buffer, ULONG buffer_size, ULONG *name_size)
1977 {
1978     FIXME("%p, %s, %u, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
1979             wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
1980
1981     return E_NOTIMPL;
1982 }
1983
1984 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldName(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
1985         ULONG field_index, char *buffer, ULONG buffer_size, ULONG *name_size)
1986 {
1987     FIXME("%p, %s, %u, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
1988             buffer_size, name_size);
1989
1990     return E_NOTIMPL;
1991 }
1992
1993 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeOptions(IDebugSymbols3 *iface, ULONG *options)
1994 {
1995     FIXME("%p, %p stub.\n", iface, options);
1996
1997     return E_NOTIMPL;
1998 }
1999
2000 static HRESULT STDMETHODCALLTYPE debugsymbols_AddTypeOptions(IDebugSymbols3 *iface, ULONG options)
2001 {
2002     FIXME("%p, %#x stub.\n", iface, options);
2003
2004     return E_NOTIMPL;
2005 }
2006
2007 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveTypeOptions(IDebugSymbols3 *iface, ULONG options)
2008 {
2009     FIXME("%p, %#x stub.\n", iface, options);
2010
2011     return E_NOTIMPL;
2012 }
2013
2014 static HRESULT STDMETHODCALLTYPE debugsymbols_SetTypeOptions(IDebugSymbols3 *iface, ULONG options)
2015 {
2016     FIXME("%p, %#x stub.\n", iface, options);
2017
2018     return E_NOTIMPL;
2019 }
2020
2021 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset, WCHAR *buffer,
2022         ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
2023 {
2024     FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, name_size,
2025             displacement);
2026
2027     return E_NOTIMPL;
2028 }
2029
2030 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2031         ULONG64 *offset)
2032 {
2033     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), offset);
2034
2035     return E_NOTIMPL;
2036 }
2037
2038 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset,
2039         LONG delta, WCHAR *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
2040 {
2041     FIXME("%p, %s, %d, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
2042             name_size, displacement);
2043
2044     return E_NOTIMPL;
2045 }
2046
2047 static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset, ULONG *line,
2048         WCHAR *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
2049 {
2050     FIXME("%p, %s, %p, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
2051             file_size, displacement);
2052
2053     return E_NOTIMPL;
2054 }
2055
2056 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLineWide(IDebugSymbols3 *iface, ULONG line, const WCHAR *file,
2057         ULONG64 *offset)
2058 {
2059     FIXME("%p, %u, %s, %p stub.\n", iface, line, debugstr_w(file), offset);
2060
2061     return E_NOTIMPL;
2062 }
2063
2064 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleNameWide(IDebugSymbols3 *iface, const WCHAR *name,
2065         ULONG start_index, ULONG *index, ULONG64 *base)
2066 {
2067     FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_w(name), start_index, index, base);
2068
2069     return E_NOTIMPL;
2070 }
2071
2072 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModuleWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2073         ULONG64 *base)
2074 {
2075     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), base);
2076
2077     return E_NOTIMPL;
2078 }
2079
2080 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2081         WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2082 {
2083     FIXME("%p, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, buffer, buffer_size,
2084             name_size);
2085
2086     return E_NOTIMPL;
2087 }
2088
2089 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeIdWide(IDebugSymbols3 *iface, ULONG64 module, const WCHAR *name,
2090         ULONG *type_id)
2091 {
2092     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), debugstr_w(name), type_id);
2093
2094     return E_NOTIMPL;
2095 }
2096
2097 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffsetWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2098         const WCHAR *field, ULONG *offset)
2099 {
2100     FIXME("%p, %s, %u, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, debugstr_w(field), offset);
2101
2102     return E_NOTIMPL;
2103 }
2104
2105 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeIdWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2106         ULONG *type_id, ULONG64 *module)
2107 {
2108     FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_w(symbol), type_id, module);
2109
2110     return E_NOTIMPL;
2111 }
2112
2113 static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup2(IDebugSymbols3 *iface, ULONG flags,
2114         PDEBUG_SYMBOL_GROUP2 update, PDEBUG_SYMBOL_GROUP2 *symbols)
2115 {
2116     FIXME("%p, %#x, %p, %p stub.\n", iface, flags, update, symbols);
2117
2118     return E_NOTIMPL;
2119 }
2120
2121 static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup2(IDebugSymbols3 *iface, PDEBUG_SYMBOL_GROUP2 *group)
2122 {
2123     FIXME("%p, %p stub.\n", iface, group);
2124
2125     return E_NOTIMPL;
2126 }
2127
2128 static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatchWide(IDebugSymbols3 *iface, const WCHAR *pattern,
2129         ULONG64 *handle)
2130 {
2131     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(pattern), handle);
2132
2133     return E_NOTIMPL;
2134 }
2135
2136 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatchWide(IDebugSymbols3 *iface, ULONG64 handle,
2137         WCHAR *buffer, ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
2138 {
2139     FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
2140
2141     return E_NOTIMPL;
2142 }
2143
2144 static HRESULT STDMETHODCALLTYPE debugsymbols_ReloadWide(IDebugSymbols3 *iface, const WCHAR *module)
2145 {
2146     FIXME("%p, %s stub.\n", iface, debugstr_w(module));
2147
2148     return E_NOTIMPL;
2149 }
2150
2151 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2152         ULONG *path_size)
2153 {
2154     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
2155
2156     return E_NOTIMPL;
2157 }
2158
2159 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *path)
2160 {
2161     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2162
2163     return E_NOTIMPL;
2164 }
2165
2166 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2167 {
2168     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2169
2170     return E_NOTIMPL;
2171 }
2172
2173 static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2174         ULONG *path_size)
2175 {
2176     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
2177
2178     return E_NOTIMPL;
2179 }
2180
2181 static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePathWide(IDebugSymbols3 *iface, const WCHAR *path)
2182 {
2183     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2184
2185     return E_NOTIMPL;
2186 }
2187
2188 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2189 {
2190     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2191
2192     return E_NOTIMPL;
2193 }
2194
2195 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2196         ULONG *path_size)
2197 {
2198     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
2199
2200     return E_NOTIMPL;
2201 }
2202
2203 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElementWide(IDebugSymbols3 *iface, ULONG index,
2204         WCHAR *buffer, ULONG buffer_size, ULONG *element_size)
2205 {
2206     FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, element_size);
2207
2208     return E_NOTIMPL;
2209 }
2210
2211 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePathWide(IDebugSymbols3 *iface, const WCHAR *path)
2212 {
2213     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2214
2215     return E_NOTIMPL;
2216 }
2217
2218 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2219 {
2220     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2221
2222     return E_NOTIMPL;
2223 }
2224
2225 static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFileWide(IDebugSymbols3 *iface, ULONG start_element,
2226         const WCHAR *file, ULONG flags, ULONG *found_element, WCHAR *buffer, ULONG buffer_size, ULONG *found_size)
2227 {
2228     FIXME("%p, %u, %s, %#x, %p, %p, %u, %p stub.\n", iface, start_element, debugstr_w(file), flags, found_element,
2229             buffer, buffer_size, found_size);
2230
2231     return E_NOTIMPL;
2232 }
2233
2234 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsetsWide(IDebugSymbols3 *iface, const WCHAR *file,
2235         ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
2236 {
2237     FIXME("%p, %s, %p, %u, %p stub.\n", iface, debugstr_w(file), buffer, buffer_lines, file_lines);
2238
2239     return E_NOTIMPL;
2240 }
2241
2242 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleVersionInformationWide(IDebugSymbols3 *iface, ULONG index,
2243         ULONG64 base, const WCHAR *item, void *buffer, ULONG buffer_size, ULONG *version_info_size)
2244 {
2245     FIXME("%p, %u, %s, %s, %p, %u, %p stub.\n", iface, index, wine_dbgstr_longlong(base), debugstr_w(item), buffer,
2246             buffer_size, version_info_size);
2247
2248     return E_NOTIMPL;
2249 }
2250
2251 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameStringWide(IDebugSymbols3 *iface, ULONG which, ULONG index,
2252         ULONG64 base, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2253 {
2254     FIXME("%p, %u, %u, %s, %p, %u, %p stub.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
2255             name_size);
2256
2257     return E_NOTIMPL;
2258 }
2259
2260 static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2261         ULONG64 value, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2262 {
2263     FIXME("%p, %s, %u, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
2264             wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
2265
2266     return E_NOTIMPL;
2267 }
2268
2269 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2270         ULONG field_index, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2271 {
2272     FIXME("%p, %s, %u, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
2273             buffer_size, name_size);
2274
2275     return E_NOTIMPL;
2276 }
2277
2278 static HRESULT STDMETHODCALLTYPE debugsymbols_IsManagedModule(IDebugSymbols3 *iface, ULONG index, ULONG64 base)
2279 {
2280     FIXME("%p, %u, %s stub.\n", iface, index, wine_dbgstr_longlong(base));
2281
2282     return E_NOTIMPL;
2283 }
2284
2285 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2(IDebugSymbols3 *iface, const char *name,
2286         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2287 {
2288     FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, debugstr_a(name), start_index, flags, index, base);
2289
2290     return E_NOTIMPL;
2291 }
2292
2293 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2Wide(IDebugSymbols3 *iface, const WCHAR *name,
2294         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2295 {
2296     FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, debugstr_w(name), start_index, flags, index, base);
2297
2298     return E_NOTIMPL;
2299 }
2300
2301 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset2(IDebugSymbols3 *iface, ULONG64 offset,
2302         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2303 {
2304     FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), start_index, flags, index, base);
2305
2306     return E_NOTIMPL;
2307 }
2308
2309 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModule(IDebugSymbols3 *iface, ULONG64 base, ULONG size,
2310         const char *image_path, const char *module_name, ULONG flags)
2311 {
2312     FIXME("%p, %s, %u, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_a(image_path),
2313             debugstr_a(module_name), flags);
2314
2315     return E_NOTIMPL;
2316 }
2317
2318 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModuleWide(IDebugSymbols3 *iface, ULONG64 base, ULONG size,
2319         const WCHAR *image_path, const WCHAR *module_name, ULONG flags)
2320 {
2321     FIXME("%p, %s, %u, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_w(image_path),
2322             debugstr_w(module_name), flags);
2323
2324     return E_NOTIMPL;
2325 }
2326
2327 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticModule(IDebugSymbols3 *iface, ULONG64 base)
2328 {
2329     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(base));
2330
2331     return E_NOTIMPL;
2332 }
2333
2334 static HRESULT STDMETHODCALLTYPE debugsymbols_GetCurrentScopeFrameIndex(IDebugSymbols3 *iface, ULONG *index)
2335 {
2336     FIXME("%p, %p stub.\n", iface, index);
2337
2338     return E_NOTIMPL;
2339 }
2340
2341 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFrameByIndex(IDebugSymbols3 *iface, ULONG index)
2342 {
2343     FIXME("%p, %u stub.\n", iface, index);
2344
2345     return E_NOTIMPL;
2346 }
2347
2348 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromJitDebugInfo(IDebugSymbols3 *iface, ULONG output_control,
2349         ULONG64 info_offset)
2350 {
2351     FIXME("%p, %u, %s stub.\n", iface, output_control, wine_dbgstr_longlong(info_offset));
2352
2353     return E_NOTIMPL;
2354 }
2355
2356 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromStoredEvent(IDebugSymbols3 *iface)
2357 {
2358     FIXME("%p stub.\n", iface);
2359
2360     return E_NOTIMPL;
2361 }
2362
2363 static HRESULT STDMETHODCALLTYPE debugsymbols_OutputSymbolByOffset(IDebugSymbols3 *iface, ULONG output_control,
2364         ULONG flags, ULONG64 offset)
2365 {
2366     FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, flags, wine_dbgstr_longlong(offset));
2367
2368     return E_NOTIMPL;
2369 }
2370
2371 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFunctionEntryByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2372         ULONG flags, void *buffer, ULONG buffer_size, ULONG *needed_size)
2373 {
2374     FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
2375             needed_size);
2376
2377     return E_NOTIMPL;
2378 }
2379
2380 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffset(IDebugSymbols3 *iface, ULONG64 module,
2381         ULONG container_type_id, const char *field, ULONG *field_type_id, ULONG *offset)
2382 {
2383     FIXME("%p, %s, %u, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_a(field),
2384             field_type_id, offset);
2385
2386     return E_NOTIMPL;
2387 }
2388
2389 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffsetWide(IDebugSymbols3 *iface, ULONG64 module,
2390         ULONG container_type_id, const WCHAR *field, ULONG *field_type_id, ULONG *offset)
2391 {
2392     FIXME("%p, %s, %u, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_w(field),
2393             field_type_id, offset);
2394
2395     return E_NOTIMPL;
2396 }
2397
2398 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbol(IDebugSymbols3 *iface, ULONG64 offset, ULONG size,
2399         const char *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
2400 {
2401     FIXME("%p, %s, %u, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_a(name), flags, id);
2402
2403     return E_NOTIMPL;
2404 }
2405
2406 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbolWide(IDebugSymbols3 *iface, ULONG64 offset, ULONG size,
2407         const WCHAR *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
2408 {
2409     FIXME("%p, %s, %u, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_w(name), flags, id);
2410
2411     return E_NOTIMPL;
2412 }
2413
2414 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticSymbol(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id)
2415 {
2416     FIXME("%p, %p stub.\n", iface, id);
2417
2418     return E_NOTIMPL;
2419 }
2420
2421 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2422         ULONG flags, DEBUG_MODULE_AND_ID *ids, LONG64 *displacements, ULONG count, ULONG *entries)
2423 {
2424     FIXME("%p, %s, %#x, %p, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, ids, displacements, count,
2425             entries);
2426
2427     return E_NOTIMPL;
2428 }
2429
2430 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByName(IDebugSymbols3 *iface, const char *symbol,
2431         ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
2432 {
2433     FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_a(symbol), flags, ids, count, entries);
2434
2435     return E_NOTIMPL;
2436 }
2437
2438 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2439         ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
2440 {
2441     FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_w(symbol), flags, ids, count, entries);
2442
2443     return E_NOTIMPL;
2444 }
2445
2446 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryByToken(IDebugSymbols3 *iface, ULONG64 base, ULONG token,
2447         DEBUG_MODULE_AND_ID *id)
2448 {
2449     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), id);
2450
2451     return E_NOTIMPL;
2452 }
2453
2454 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryInformation(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2455         DEBUG_SYMBOL_ENTRY *info)
2456 {
2457     FIXME("%p, %p, %p stub.\n", iface, id, info);
2458
2459     return E_NOTIMPL;
2460 }
2461
2462 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryString(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2463         ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
2464 {
2465     FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
2466
2467     return E_NOTIMPL;
2468 }
2469
2470 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryStringWide(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2471         ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
2472 {
2473     FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
2474
2475     return E_NOTIMPL;
2476 }
2477
2478 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryOffsetRegions(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2479         ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG regions_count, ULONG *regions_avail)
2480 {
2481     FIXME("%p, %p, %#x, %p, %u, %p stub.\n", iface, id, flags, regions, regions_count, regions_avail);
2482
2483     return E_NOTIMPL;
2484 }
2485
2486 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryBySymbolEntry(IDebugSymbols3 *iface,
2487         DEBUG_MODULE_AND_ID *from_id, ULONG flags, DEBUG_MODULE_AND_ID *to_id)
2488 {
2489     FIXME("%p, %p, %#x, %p stub.\n", iface, from_id, flags, to_id);
2490
2491     return E_NOTIMPL;
2492 }
2493
2494 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2495         ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2496 {
2497     FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, entries, count, entries_avail);
2498
2499     return E_NOTIMPL;
2500 }
2501
2502 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLine(IDebugSymbols3 *iface, ULONG line,
2503         const char *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2504 {
2505     FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_a(file), flags, entries, count, entries_avail);
2506
2507     return E_NOTIMPL;
2508 }
2509
2510 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLineWide(IDebugSymbols3 *iface, ULONG line,
2511         const WCHAR *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2512 {
2513     FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_w(file), flags, entries, count, entries_avail);
2514
2515     return E_NOTIMPL;
2516 }
2517
2518 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryString(IDebugSymbols3 *iface,
2519         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
2520 {
2521     FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
2522
2523     return E_NOTIMPL;
2524 }
2525
2526 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryStringWide(IDebugSymbols3 *iface,
2527         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
2528 {
2529     FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
2530
2531     return E_NOTIMPL;
2532 }
2533
2534 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryOffsetRegions(IDebugSymbols3 *iface,
2535         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG count, ULONG *regions_avail)
2536 {
2537     FIXME("%p, %p, %#x, %p, %u, %p stub.\n", iface, entry, flags, regions, count, regions_avail);
2538
2539     return E_NOTIMPL;
2540 }
2541
2542 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryBySourceEntry(IDebugSymbols3 *iface,
2543         DEBUG_SYMBOL_SOURCE_ENTRY *from_entry, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *to_entry)
2544 {
2545     FIXME("%p, %p, %#x, %p stub.\n", iface, from_entry, flags, to_entry);
2546
2547     return E_NOTIMPL;
2548 }
2549
2550 static const IDebugSymbols3Vtbl debugsymbolsvtbl =
2551 {
2552     debugsymbols_QueryInterface,
2553     debugsymbols_AddRef,
2554     debugsymbols_Release,
2555     debugsymbols_GetSymbolOptions,
2556     debugsymbols_AddSymbolOptions,
2557     debugsymbols_RemoveSymbolOptions,
2558     debugsymbols_SetSymbolOptions,
2559     debugsymbols_GetNameByOffset,
2560     debugsymbols_GetOffsetByName,
2561     debugsymbols_GetNearNameByOffset,
2562     debugsymbols_GetLineByOffset,
2563     debugsymbols_GetOffsetByLine,
2564     debugsymbols_GetNumberModules,
2565     debugsymbols_GetModuleByIndex,
2566     debugsymbols_GetModuleByModuleName,
2567     debugsymbols_GetModuleByOffset,
2568     debugsymbols_GetModuleNames,
2569     debugsymbols_GetModuleParameters,
2570     debugsymbols_GetSymbolModule,
2571     debugsymbols_GetTypeName,
2572     debugsymbols_GetTypeId,
2573     debugsymbols_GetTypeSize,
2574     debugsymbols_GetFieldOffset,
2575     debugsymbols_GetSymbolTypeId,
2576     debugsymbols_GetOffsetTypeId,
2577     debugsymbols_ReadTypedDataVirtual,
2578     debugsymbols_WriteTypedDataVirtual,
2579     debugsymbols_OutputTypedDataVirtual,
2580     debugsymbols_ReadTypedDataPhysical,
2581     debugsymbols_WriteTypedDataPhysical,
2582     debugsymbols_OutputTypedDataPhysical,
2583     debugsymbols_GetScope,
2584     debugsymbols_SetScope,
2585     debugsymbols_ResetScope,
2586     debugsymbols_GetScopeSymbolGroup,
2587     debugsymbols_CreateSymbolGroup,
2588     debugsymbols_StartSymbolMatch,
2589     debugsymbols_GetNextSymbolMatch,
2590     debugsymbols_EndSymbolMatch,
2591     debugsymbols_Reload,
2592     debugsymbols_GetSymbolPath,
2593     debugsymbols_SetSymbolPath,
2594     debugsymbols_AppendSymbolPath,
2595     debugsymbols_GetImagePath,
2596     debugsymbols_SetImagePath,
2597     debugsymbols_AppendImagePath,
2598     debugsymbols_GetSourcePath,
2599     debugsymbols_GetSourcePathElement,
2600     debugsymbols_SetSourcePath,
2601     debugsymbols_AppendSourcePath,
2602     debugsymbols_FindSourceFile,
2603     debugsymbols_GetSourceFileLineOffsets,
2604     /* IDebugSymbols2 */
2605     debugsymbols_GetModuleVersionInformation,
2606     debugsymbols_GetModuleNameString,
2607     debugsymbols_GetConstantName,
2608     debugsymbols_GetFieldName,
2609     debugsymbols_GetTypeOptions,
2610     debugsymbols_AddTypeOptions,
2611     debugsymbols_RemoveTypeOptions,
2612     debugsymbols_SetTypeOptions,
2613     /* IDebugSymbols3 */
2614     debugsymbols_GetNameByOffsetWide,
2615     debugsymbols_GetOffsetByNameWide,
2616     debugsymbols_GetNearNameByOffsetWide,
2617     debugsymbols_GetLineByOffsetWide,
2618     debugsymbols_GetOffsetByLineWide,
2619     debugsymbols_GetModuleByModuleNameWide,
2620     debugsymbols_GetSymbolModuleWide,
2621     debugsymbols_GetTypeNameWide,
2622     debugsymbols_GetTypeIdWide,
2623     debugsymbols_GetFieldOffsetWide,
2624     debugsymbols_GetSymbolTypeIdWide,
2625     debugsymbols_GetScopeSymbolGroup2,
2626     debugsymbols_CreateSymbolGroup2,
2627     debugsymbols_StartSymbolMatchWide,
2628     debugsymbols_GetNextSymbolMatchWide,
2629     debugsymbols_ReloadWide,
2630     debugsymbols_GetSymbolPathWide,
2631     debugsymbols_SetSymbolPathWide,
2632     debugsymbols_AppendSymbolPathWide,
2633     debugsymbols_GetImagePathWide,
2634     debugsymbols_SetImagePathWide,
2635     debugsymbols_AppendImagePathWide,
2636     debugsymbols_GetSourcePathWide,
2637     debugsymbols_GetSourcePathElementWide,
2638     debugsymbols_SetSourcePathWide,
2639     debugsymbols_AppendSourcePathWide,
2640     debugsymbols_FindSourceFileWide,
2641     debugsymbols_GetSourceFileLineOffsetsWide,
2642     debugsymbols_GetModuleVersionInformationWide,
2643     debugsymbols_GetModuleNameStringWide,
2644     debugsymbols_GetConstantNameWide,
2645     debugsymbols_GetFieldNameWide,
2646     debugsymbols_IsManagedModule,
2647     debugsymbols_GetModuleByModuleName2,
2648     debugsymbols_GetModuleByModuleName2Wide,
2649     debugsymbols_GetModuleByOffset2,
2650     debugsymbols_AddSyntheticModule,
2651     debugsymbols_AddSyntheticModuleWide,
2652     debugsymbols_RemoveSyntheticModule,
2653     debugsymbols_GetCurrentScopeFrameIndex,
2654     debugsymbols_SetScopeFrameByIndex,
2655     debugsymbols_SetScopeFromJitDebugInfo,
2656     debugsymbols_SetScopeFromStoredEvent,
2657     debugsymbols_OutputSymbolByOffset,
2658     debugsymbols_GetFunctionEntryByOffset,
2659     debugsymbols_GetFieldTypeAndOffset,
2660     debugsymbols_GetFieldTypeAndOffsetWide,
2661     debugsymbols_AddSyntheticSymbol,
2662     debugsymbols_AddSyntheticSymbolWide,
2663     debugsymbols_RemoveSyntheticSymbol,
2664     debugsymbols_GetSymbolEntriesByOffset,
2665     debugsymbols_GetSymbolEntriesByName,
2666     debugsymbols_GetSymbolEntriesByNameWide,
2667     debugsymbols_GetSymbolEntryByToken,
2668     debugsymbols_GetSymbolEntryInformation,
2669     debugsymbols_GetSymbolEntryString,
2670     debugsymbols_GetSymbolEntryStringWide,
2671     debugsymbols_GetSymbolEntryOffsetRegions,
2672     debugsymbols_GetSymbolEntryBySymbolEntry,
2673     debugsymbols_GetSourceEntriesByOffset,
2674     debugsymbols_GetSourceEntriesByLine,
2675     debugsymbols_GetSourceEntriesByLineWide,
2676     debugsymbols_GetSourceEntryString,
2677     debugsymbols_GetSourceEntryStringWide,
2678     debugsymbols_GetSourceEntryOffsetRegions,
2679     debugsymbols_GetSourceEntryBySourceEntry,
2680 };
2681
2682 static HRESULT STDMETHODCALLTYPE debugcontrol_QueryInterface(IDebugControl2 *iface, REFIID riid, void **obj)
2683 {
2684     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
2685     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2686     return IUnknown_QueryInterface(unk, riid, obj);
2687 }
2688
2689 static ULONG STDMETHODCALLTYPE debugcontrol_AddRef(IDebugControl2 *iface)
2690 {
2691     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
2692     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2693     return IUnknown_AddRef(unk);
2694 }
2695
2696 static ULONG STDMETHODCALLTYPE debugcontrol_Release(IDebugControl2 *iface)
2697 {
2698     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
2699     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2700     return IUnknown_Release(unk);
2701 }
2702
2703 static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterrupt(IDebugControl2 *iface)
2704 {
2705     FIXME("%p stub.\n", iface);
2706
2707     return E_NOTIMPL;
2708 }
2709
2710 static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterrupt(IDebugControl2 *iface, ULONG flags)
2711 {
2712     FIXME("%p, %#x stub.\n", iface, flags);
2713
2714     return E_NOTIMPL;
2715 }
2716
2717 static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterruptTimeout(IDebugControl2 *iface, ULONG *timeout)
2718 {
2719     FIXME("%p, %p stub.\n", iface, timeout);
2720
2721     return E_NOTIMPL;
2722 }
2723
2724 static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterruptTimeout(IDebugControl2 *iface, ULONG timeout)
2725 {
2726     FIXME("%p, %u stub.\n", iface, timeout);
2727
2728     return E_NOTIMPL;
2729 }
2730
2731 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
2732         ULONG *file_size, BOOL *append)
2733 {
2734     FIXME("%p, %p, %u, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
2735
2736     return E_NOTIMPL;
2737 }
2738
2739 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile(IDebugControl2 *iface, const char *file, BOOL append)
2740 {
2741     FIXME("%p, %s, %d stub.\n", iface, debugstr_a(file), append);
2742
2743     return E_NOTIMPL;
2744 }
2745 static HRESULT STDMETHODCALLTYPE debugcontrol_CloseLogFile(IDebugControl2 *iface)
2746 {
2747     FIXME("%p stub.\n", iface);
2748
2749     return E_NOTIMPL;
2750 }
2751 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogMask(IDebugControl2 *iface, ULONG *mask)
2752 {
2753     FIXME("%p, %p stub.\n", iface, mask);
2754
2755     return E_NOTIMPL;
2756 }
2757
2758 static HRESULT STDMETHODCALLTYPE debugcontrol_SetLogMask(IDebugControl2 *iface, ULONG mask)
2759 {
2760     FIXME("%p, %#x stub.\n", iface, mask);
2761
2762     return E_NOTIMPL;
2763 }
2764
2765 static HRESULT STDMETHODCALLTYPE debugcontrol_Input(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
2766         ULONG *input_size)
2767 {
2768     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, input_size);
2769
2770     return E_NOTIMPL;
2771 }
2772
2773 static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInput(IDebugControl2 *iface, const char *buffer)
2774 {
2775     FIXME("%p, %s stub.\n", iface, debugstr_a(buffer));
2776
2777     return E_NOTIMPL;
2778 }
2779
2780 static HRESULT STDMETHODVCALLTYPE debugcontrol_Output(IDebugControl2 *iface, ULONG mask, const char *format, ...)
2781 {
2782     FIXME("%p, %#x, %s stub.\n", iface, mask, debugstr_a(format));
2783
2784     return E_NOTIMPL;
2785 }
2786
2787 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl2 *iface, ULONG mask, const char *format,
2788         __ms_va_list args)
2789 {
2790     FIXME("%p, %#x, %s stub.\n", iface, mask, debugstr_a(format));
2791
2792     return E_NOTIMPL;
2793 }
2794
2795 static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl2 *iface, ULONG output_control,
2796         ULONG mask, const char *format, ...)
2797 {
2798     FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, mask, debugstr_a(format));
2799
2800     return E_NOTIMPL;
2801 }
2802
2803 static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugControl2 *iface, ULONG output_control,
2804         ULONG mask, const char *format, __ms_va_list args)
2805 {
2806     FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, mask, debugstr_a(format));
2807
2808     return E_NOTIMPL;
2809 }
2810
2811 static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl2 *iface, ULONG output_control,
2812         const char *format, ...)
2813 {
2814     FIXME("%p, %u, %s stub.\n", iface, output_control, debugstr_a(format));
2815
2816     return E_NOTIMPL;
2817 }
2818
2819 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl2 *iface, ULONG output_control,
2820         const char *format, __ms_va_list args)
2821 {
2822     FIXME("%p, %u, %s stub.\n", iface, output_control, debugstr_a(format));
2823
2824     return E_NOTIMPL;
2825 }
2826
2827 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptText(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
2828         ULONG *text_size)
2829 {
2830     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, text_size);
2831
2832     return E_NOTIMPL;
2833 }
2834
2835 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl2 *iface, ULONG output_control,
2836         ULONG flags)
2837 {
2838     FIXME("%p, %u, %#x stub.\n", iface, output_control, flags);
2839
2840     return E_NOTIMPL;
2841 }
2842
2843 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVersionInformation(IDebugControl2 *iface, ULONG output_control)
2844 {
2845     FIXME("%p, %u stub.\n", iface, output_control);
2846
2847     return E_NOTIMPL;
2848 }
2849
2850 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNotifyEventHandle(IDebugControl2 *iface, ULONG64 *handle)
2851 {
2852     FIXME("%p, %p stub.\n", iface, handle);
2853
2854     return E_NOTIMPL;
2855 }
2856
2857 static HRESULT STDMETHODCALLTYPE debugcontrol_SetNotifyEventHandle(IDebugControl2 *iface, ULONG64 handle)
2858 {
2859     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
2860
2861     return E_NOTIMPL;
2862 }
2863
2864 static HRESULT STDMETHODCALLTYPE debugcontrol_Assemble(IDebugControl2 *iface, ULONG64 offset, const char *code,
2865         ULONG64 *end_offset)
2866 {
2867     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), debugstr_a(code), end_offset);
2868
2869     return E_NOTIMPL;
2870 }
2871
2872 static HRESULT STDMETHODCALLTYPE debugcontrol_Disassemble(IDebugControl2 *iface, ULONG64 offset, ULONG flags,
2873         char *buffer, ULONG buffer_size, ULONG *disassm_size, ULONG64 *end_offset)
2874 {
2875     FIXME("%p, %s, %#x, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
2876             disassm_size, end_offset);
2877
2878     return E_NOTIMPL;
2879 }
2880
2881 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDisassembleEffectiveOffset(IDebugControl2 *iface, ULONG64 *offset)
2882 {
2883     FIXME("%p, %p stub.\n", iface, offset);
2884
2885     return E_NOTIMPL;
2886 }
2887
2888 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl2 *iface, ULONG output_control,
2889         ULONG64 offset, ULONG flags, ULONG64 *end_offset)
2890 {
2891     FIXME("%p, %u, %s, %#x, %p stub.\n", iface, output_control, wine_dbgstr_longlong(offset), flags, end_offset);
2892
2893     return E_NOTIMPL;
2894 }
2895
2896 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugControl2 *iface, ULONG output_control,
2897         ULONG prev_lines, ULONG total_lines, ULONG64 offset, ULONG flags, ULONG *offset_line, ULONG64 *start_offset,
2898         ULONG64 *end_offset, ULONG64 *line_offsets)
2899 {
2900     FIXME("%p, %u, %u, %u, %s, %#x, %p, %p, %p, %p stub.\n", iface, output_control, prev_lines, total_lines,
2901             wine_dbgstr_longlong(offset), flags, offset_line, start_offset, end_offset, line_offsets);
2902
2903     return E_NOTIMPL;
2904 }
2905
2906 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNearInstruction(IDebugControl2 *iface, ULONG64 offset, LONG delta,
2907         ULONG64 *instr_offset)
2908 {
2909     FIXME("%p, %s, %d, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, instr_offset);
2910
2911     return E_NOTIMPL;
2912 }
2913
2914 static HRESULT STDMETHODCALLTYPE debugcontrol_GetStackTrace(IDebugControl2 *iface, ULONG64 frame_offset,
2915         ULONG64 stack_offset, ULONG64 instr_offset, DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG *frames_filled)
2916 {
2917     FIXME("%p, %s, %s, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(frame_offset),
2918             wine_dbgstr_longlong(stack_offset), wine_dbgstr_longlong(instr_offset), frames, frames_size, frames_filled);
2919
2920     return E_NOTIMPL;
2921 }
2922
2923 static HRESULT STDMETHODCALLTYPE debugcontrol_GetReturnOffset(IDebugControl2 *iface, ULONG64 *offset)
2924 {
2925     FIXME("%p, %p stub.\n", iface, offset);
2926
2927     return E_NOTIMPL;
2928 }
2929
2930 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl2 *iface, ULONG output_control,
2931         DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG flags)
2932 {
2933     FIXME("%p, %u, %p, %u, %#x stub.\n", iface, output_control, frames, frames_size, flags);
2934
2935     return E_NOTIMPL;
2936 }
2937
2938 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl2 *iface, ULONG *debug_class,
2939         ULONG *qualifier)
2940 {
2941     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
2942     static struct target_process *target;
2943
2944     FIXME("%p, %p, %p stub.\n", iface, debug_class, qualifier);
2945
2946     *debug_class = DEBUG_CLASS_UNINITIALIZED;
2947     *qualifier = 0;
2948
2949     if (!(target = debug_client_get_target(debug_client)))
2950         return E_UNEXPECTED;
2951
2952     *debug_class = DEBUG_CLASS_USER_WINDOWS;
2953     *qualifier = DEBUG_USER_WINDOWS_PROCESS;
2954
2955     return S_OK;
2956 }
2957
2958 static HRESULT STDMETHODCALLTYPE debugcontrol_GetActualProcessorType(IDebugControl2 *iface, ULONG *type)
2959 {
2960     FIXME("%p, %p stub.\n", iface, type);
2961
2962     return E_NOTIMPL;
2963 }
2964
2965 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutingProcessorType(IDebugControl2 *iface, ULONG *type)
2966 {
2967     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
2968     static struct target_process *target;
2969     HRESULT hr;
2970
2971     TRACE("%p, %p.\n", iface, type);
2972
2973     if (!(target = debug_client_get_target(debug_client)))
2974         return E_UNEXPECTED;
2975
2976     if (FAILED(hr = debug_target_init_modules_info(target)))
2977         return hr;
2978
2979     *type = target->cpu_type;
2980
2981     return S_OK;
2982 }
2983
2984 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberPossibleExecutingProcessorTypes(IDebugControl2 *iface,
2985         ULONG *count)
2986 {
2987     FIXME("%p, %p stub.\n", iface, count);
2988
2989     return E_NOTIMPL;
2990 }
2991
2992 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPossibleExecutingProcessorTypes(IDebugControl2 *iface, ULONG start,
2993         ULONG count, ULONG *types)
2994 {
2995     FIXME("%p, %u, %u, %p stub.\n", iface, start, count, types);
2996
2997     return E_NOTIMPL;
2998 }
2999
3000 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberProcessors(IDebugControl2 *iface, ULONG *count)
3001 {
3002     FIXME("%p, %p stub.\n", iface, count);
3003
3004     return E_NOTIMPL;
3005 }
3006
3007 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersion(IDebugControl2 *iface, ULONG *platform_id, ULONG *major,
3008         ULONG *minor, char *sp_string, ULONG sp_string_size, ULONG *sp_string_used, ULONG *sp_number,
3009         char *build_string, ULONG build_string_size, ULONG *build_string_used)
3010 {
3011     FIXME("%p, %p, %p, %p, %p, %u, %p, %p, %p, %u, %p stub.\n", iface, platform_id, major, minor, sp_string,
3012             sp_string_size, sp_string_used, sp_number, build_string, build_string_size, build_string_used);
3013
3014     return E_NOTIMPL;
3015 }
3016
3017 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPageSize(IDebugControl2 *iface, ULONG *size)
3018 {
3019     FIXME("%p, %p stub.\n", iface, size);
3020
3021     return E_NOTIMPL;
3022 }
3023
3024 static HRESULT STDMETHODCALLTYPE debugcontrol_IsPointer64Bit(IDebugControl2 *iface)
3025 {
3026     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
3027     static struct target_process *target;
3028     HRESULT hr;
3029
3030     TRACE("%p.\n", iface);
3031
3032     if (!(target = debug_client_get_target(debug_client)))
3033         return E_UNEXPECTED;
3034
3035     if (FAILED(hr = debug_target_init_modules_info(target)))
3036         return hr;
3037
3038     switch (target->cpu_type)
3039     {
3040         case IMAGE_FILE_MACHINE_I386:
3041         case IMAGE_FILE_MACHINE_ARM:
3042             hr = S_FALSE;
3043             break;
3044         case IMAGE_FILE_MACHINE_IA64:
3045         case IMAGE_FILE_MACHINE_AMD64:
3046         case IMAGE_FILE_MACHINE_ARM64:
3047             hr = S_OK;
3048             break;
3049         default:
3050             FIXME("Unexpected cpu type %#x.\n", target->cpu_type);
3051             hr = E_UNEXPECTED;
3052     }
3053
3054     return hr;
3055 }
3056
3057 static HRESULT STDMETHODCALLTYPE debugcontrol_ReadBugCheckData(IDebugControl2 *iface, ULONG *code, ULONG64 *arg1,
3058         ULONG64 *arg2, ULONG64 *arg3, ULONG64 *arg4)
3059 {
3060     FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, code, arg1, arg2, arg3, arg4);
3061
3062     return E_NOTIMPL;
3063 }
3064
3065 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberSupportedProcessorTypes(IDebugControl2 *iface, ULONG *count)
3066 {
3067     FIXME("%p, %p stub.\n", iface, count);
3068
3069     return E_NOTIMPL;
3070 }
3071
3072 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSupportedProcessorTypes(IDebugControl2 *iface, ULONG start,
3073         ULONG count, ULONG *types)
3074 {
3075     FIXME("%p, %u, %u, %p stub.\n", iface, start, count, types);
3076
3077     return E_NOTIMPL;
3078 }
3079
3080 static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugControl2 *iface, ULONG type, char *full_name,
3081         ULONG full_name_buffer_size, ULONG *full_name_size, char *abbrev_name, ULONG abbrev_name_buffer_size,
3082         ULONG *abbrev_name_size)
3083 {
3084     FIXME("%p, %u, %p, %u, %p, %p, %u, %p stub.\n", iface, type, full_name, full_name_buffer_size, full_name_size,
3085             abbrev_name, abbrev_name_buffer_size, abbrev_name_size);
3086
3087     return E_NOTIMPL;
3088 }
3089
3090 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEffectiveProcessorType(IDebugControl2 *iface, ULONG *type)
3091 {
3092     FIXME("%p, %p stub.\n", iface, type);
3093
3094     return E_NOTIMPL;
3095 }
3096
3097 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEffectiveProcessorType(IDebugControl2 *iface, ULONG type)
3098 {
3099     FIXME("%p, %u stub.\n", iface, type);
3100
3101     return E_NOTIMPL;
3102 }
3103
3104 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutionStatus(IDebugControl2 *iface, ULONG *status)
3105 {
3106     FIXME("%p, %p stub.\n", iface, status);
3107
3108     return E_NOTIMPL;
3109 }
3110
3111 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExecutionStatus(IDebugControl2 *iface, ULONG status)
3112 {
3113     FIXME("%p, %u stub.\n", iface, status);
3114
3115     return E_NOTIMPL;
3116 }
3117
3118 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCodeLevel(IDebugControl2 *iface, ULONG *level)
3119 {
3120     FIXME("%p, %p stub.\n", iface, level);
3121
3122     return E_NOTIMPL;
3123 }
3124
3125 static HRESULT STDMETHODCALLTYPE debugcontrol_SetCodeLevel(IDebugControl2 *iface, ULONG level)
3126 {
3127     FIXME("%p, %u stub.\n", iface, level);
3128
3129     return E_NOTIMPL;
3130 }
3131
3132 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEngineOptions(IDebugControl2 *iface, ULONG *options)
3133 {
3134     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
3135
3136     TRACE("%p, %p.\n", iface, options);
3137
3138     *options = debug_client->engine_options;
3139
3140     return S_OK;
3141 }
3142
3143 static HRESULT STDMETHODCALLTYPE debugcontrol_AddEngineOptions(IDebugControl2 *iface, ULONG options)
3144 {
3145     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
3146
3147     TRACE("%p, %#x.\n", iface, options);
3148
3149     if (options & ~DEBUG_ENGOPT_ALL)
3150         return E_INVALIDARG;
3151
3152     debug_client->engine_options |= options;
3153
3154     return S_OK;
3155 }
3156
3157 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveEngineOptions(IDebugControl2 *iface, ULONG options)
3158 {
3159     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
3160
3161     TRACE("%p, %#x.\n", iface, options);
3162
3163     debug_client->engine_options &= ~options;
3164
3165     return S_OK;
3166 }
3167
3168 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEngineOptions(IDebugControl2 *iface, ULONG options)
3169 {
3170     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
3171
3172     TRACE("%p, %#x.\n", iface, options);
3173
3174     if (options & ~DEBUG_ENGOPT_ALL)
3175         return E_INVALIDARG;
3176
3177     debug_client->engine_options = options;
3178
3179     return S_OK;
3180 }
3181
3182 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugControl2 *iface, ULONG *output_level,
3183         ULONG *break_level)
3184 {
3185     FIXME("%p, %p, %p stub.\n", iface, output_level, break_level);
3186
3187     return E_NOTIMPL;
3188 }
3189
3190 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugControl2 *iface, ULONG output_level,
3191         ULONG break_level)
3192 {
3193     FIXME("%p, %u, %u stub.\n", iface, output_level, break_level);
3194
3195     return E_NOTIMPL;
3196 }
3197
3198 static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacro(IDebugControl2 *iface, ULONG slot, char *buffer,
3199         ULONG buffer_size, ULONG *macro_size)
3200 {
3201     FIXME("%p, %u, %p, %u, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
3202
3203     return E_NOTIMPL;
3204 }
3205
3206 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacro(IDebugControl2 *iface, ULONG slot, const char *macro)
3207 {
3208     FIXME("%p, %u, %s stub.\n", iface, slot, debugstr_a(macro));
3209
3210     return E_NOTIMPL;
3211 }
3212
3213 static HRESULT STDMETHODCALLTYPE debugcontrol_GetRadix(IDebugControl2 *iface, ULONG *radix)
3214 {
3215     FIXME("%p, %p stub.\n", iface, radix);
3216
3217     return E_NOTIMPL;
3218 }
3219
3220 static HRESULT STDMETHODCALLTYPE debugcontrol_SetRadix(IDebugControl2 *iface, ULONG radix)
3221 {
3222     FIXME("%p, %u stub.\n", iface, radix);
3223
3224     return E_NOTIMPL;
3225 }
3226
3227 static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl2 *iface, const char *expression,
3228         ULONG desired_type, DEBUG_VALUE *value, ULONG *remainder_index)
3229 {
3230     FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_a(expression), desired_type, value, remainder_index);
3231
3232     return E_NOTIMPL;
3233 }
3234
3235 static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValue(IDebugControl2 *iface, DEBUG_VALUE input, ULONG output_type,
3236         DEBUG_VALUE *output)
3237 {
3238     FIXME("%p, %u, %p stub.\n", iface, output_type, output);
3239
3240     return E_NOTIMPL;
3241 }
3242
3243 static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValues(IDebugControl2 *iface, ULONG count, DEBUG_VALUE *input,
3244         ULONG *output_types, DEBUG_VALUE *output)
3245 {
3246     FIXME("%p, %u, %p, %p, %p stub.\n", iface, count, input, output_types, output);
3247
3248     return E_NOTIMPL;
3249 }
3250
3251 static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl2 *iface, ULONG output_control, const char *command,
3252         ULONG flags)
3253 {
3254     FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(command), flags);
3255
3256     return E_NOTIMPL;
3257 }
3258
3259 static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl2 *iface, ULONG output_control,
3260         const char *command_file, ULONG flags)
3261 {
3262     FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(command_file), flags);
3263
3264     return E_NOTIMPL;
3265 }
3266
3267 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberBreakpoints(IDebugControl2 *iface, ULONG *count)
3268 {
3269     FIXME("%p, %p stub.\n", iface, count);
3270
3271     return E_NOTIMPL;
3272 }
3273
3274 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex(IDebugControl2 *iface, ULONG index,
3275         IDebugBreakpoint **bp)
3276 {
3277     FIXME("%p, %u, %p stub.\n", iface, index, bp);
3278
3279     return E_NOTIMPL;
3280 }
3281
3282 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById(IDebugControl2 *iface, ULONG id, IDebugBreakpoint **bp)
3283 {
3284     FIXME("%p, %u, %p stub.\n", iface, id, bp);
3285
3286     return E_NOTIMPL;
3287 }
3288
3289 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointParameters(IDebugControl2 *iface, ULONG count, ULONG *ids,
3290         ULONG start, DEBUG_BREAKPOINT_PARAMETERS *parameters)
3291 {
3292     FIXME("%p, %u, %p, %u, %p stub.\n", iface, count, ids, start, parameters);
3293
3294     return E_NOTIMPL;
3295 }
3296
3297 static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl2 *iface, ULONG type, ULONG desired_id,
3298         IDebugBreakpoint **bp)
3299 {
3300     FIXME("%p, %u, %u, %p stub.\n", iface, type, desired_id, bp);
3301
3302     return E_NOTIMPL;
3303 }
3304
3305 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint(IDebugControl2 *iface, IDebugBreakpoint *bp)
3306 {
3307     FIXME("%p, %p stub.\n", iface, bp);
3308
3309     return E_NOTIMPL;
3310 }
3311
3312 static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtension(IDebugControl2 *iface, const char *path, ULONG flags,
3313         ULONG64 *handle)
3314 {
3315     FIXME("%p, %s, %#x, %p stub.\n", iface, debugstr_a(path), flags, handle);
3316
3317     return E_NOTIMPL;
3318 }
3319
3320 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveExtension(IDebugControl2 *iface, ULONG64 handle)
3321 {
3322     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
3323
3324     return E_NOTIMPL;
3325 }
3326
3327 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPath(IDebugControl2 *iface, const char *path,
3328         ULONG64 *handle)
3329 {
3330     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(path), handle);
3331
3332     return E_NOTIMPL;
3333 }
3334
3335 static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtension(IDebugControl2 *iface, ULONG64 handle,
3336         const char *function, const char *args)
3337 {
3338     FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(function), debugstr_a(args));
3339
3340     return E_NOTIMPL;
3341 }
3342
3343 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunction(IDebugControl2 *iface, ULONG64 handle,
3344         const char *name, void *function)
3345 {
3346     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(name), function);
3347
3348     return E_NOTIMPL;
3349 }
3350
3351 static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis32(IDebugControl2 *iface,
3352         PWINDBG_EXTENSION_APIS32 api)
3353 {
3354     FIXME("%p, %p stub.\n", iface, api);
3355
3356     return E_NOTIMPL;
3357 }
3358
3359 static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis64(IDebugControl2 *iface,
3360         PWINDBG_EXTENSION_APIS64 api)
3361 {
3362     FIXME("%p, %p stub.\n", iface, api);
3363
3364     return E_NOTIMPL;
3365 }
3366
3367 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugControl2 *iface, ULONG *specific_events,
3368         ULONG *specific_exceptions, ULONG *arbitrary_exceptions)
3369 {
3370     FIXME("%p, %p, %p, %p stub.\n", iface, specific_events, specific_exceptions, arbitrary_exceptions);
3371
3372     return E_NOTIMPL;
3373 }
3374
3375 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterText(IDebugControl2 *iface, ULONG index, char *buffer,
3376         ULONG buffer_size, ULONG *text_size)
3377 {
3378     FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, text_size);
3379
3380     return E_NOTIMPL;
3381 }
3382
3383 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommand(IDebugControl2 *iface, ULONG index, char *buffer,
3384         ULONG buffer_size, ULONG *command_size)
3385 {
3386     FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3387
3388     return E_NOTIMPL;
3389 }
3390
3391 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommand(IDebugControl2 *iface, ULONG index,
3392         const char *command)
3393 {
3394     FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(command));
3395
3396     return E_NOTIMPL;
3397 }
3398
3399 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterParameters(IDebugControl2 *iface, ULONG start,
3400         ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
3401 {
3402     FIXME("%p, %u, %u, %p stub.\n", iface, start, count, parameters);
3403
3404     return E_NOTIMPL;
3405 }
3406
3407 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterParameters(IDebugControl2 *iface, ULONG start,
3408         ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
3409 {
3410     FIXME("%p, %u, %u, %p stub.\n", iface, start, count, parameters);
3411
3412     return E_NOTIMPL;
3413 }
3414
3415 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgument(IDebugControl2 *iface, ULONG index,
3416         char *buffer, ULONG buffer_size, ULONG *argument_size)
3417 {
3418     FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
3419
3420     return E_NOTIMPL;
3421 }
3422
3423 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgument(IDebugControl2 *iface, ULONG index,
3424         const char *argument)
3425 {
3426     FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(argument));
3427
3428     return E_NOTIMPL;
3429 }
3430
3431 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterParameters(IDebugControl2 *iface, ULONG count,
3432         ULONG *codes, ULONG start, DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
3433 {
3434     FIXME("%p, %u, %p, %u, %p stub.\n", iface, count, codes, start, parameters);
3435
3436     return E_NOTIMPL;
3437 }
3438
3439 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterParameters(IDebugControl2 *iface, ULONG count,
3440         DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
3441 {
3442     FIXME("%p, %u, %p stub.\n", iface, count, parameters);
3443
3444     return E_NOTIMPL;
3445 }
3446
3447 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterSecondCommand(IDebugControl2 *iface, ULONG index,
3448         char *buffer, ULONG buffer_size, ULONG *command_size)
3449 {
3450     FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3451
3452     return E_NOTIMPL;
3453 }
3454
3455 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterSecondCommand(IDebugControl2 *iface, ULONG index,
3456         const char *command)
3457 {
3458     FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(command));
3459
3460     return E_NOTIMPL;
3461 }
3462
3463 static HRESULT STDMETHODCALLTYPE debugcontrol_WaitForEvent(IDebugControl2 *iface, ULONG flags, ULONG timeout)
3464 {
3465     struct debug_client *debug_client = impl_from_IDebugControl2(iface);
3466     struct target_process *target;
3467
3468     TRACE("%p, %#x, %u.\n", iface, flags, timeout);
3469
3470     /* FIXME: only one target is used currently */
3471
3472     if (!(target = debug_client_get_target(debug_client)))
3473         return E_UNEXPECTED;
3474
3475     if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
3476     {
3477         BOOL suspend = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
3478         DWORD access = PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_LIMITED_INFORMATION;
3479         NTSTATUS status;
3480
3481         if (suspend)
3482             access |= PROCESS_SUSPEND_RESUME;
3483
3484         target->handle = OpenProcess(access, FALSE, target->pid);
3485         if (!target->handle)
3486         {
3487             WARN("Failed to get process handle for pid %#x.\n", target->pid);
3488             return E_UNEXPECTED;
3489         }
3490
3491         if (suspend)
3492         {
3493             status = NtSuspendProcess(target->handle);
3494             if (status)
3495                 WARN("Failed to suspend a process, status %#x.\n", status);
3496         }
3497
3498         return S_OK;
3499     }
3500     else
3501     {
3502         FIXME("Unsupported attach flags %#x.\n", target->attach_flags);
3503     }
3504
3505     return E_NOTIMPL;
3506 }
3507
3508 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformation(IDebugControl2 *iface, ULONG *type, ULONG *pid,
3509         ULONG *tid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, char *description,
3510         ULONG desc_size, ULONG *desc_used)
3511 {
3512     FIXME("%p, %p, %p, %p, %p, %u, %p, %p, %u, %p stub.\n", iface, type, pid, tid, extra_info, extra_info_size,
3513             extra_info_used, description, desc_size, desc_used);
3514
3515     return E_NOTIMPL;
3516 }
3517
3518 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentTimeDate(IDebugControl2 *iface, ULONG timedate)
3519 {
3520     FIXME("%p, %u stub.\n", iface, timedate);
3521
3522     return E_NOTIMPL;
3523 }
3524
3525 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentSystemUpTime(IDebugControl2 *iface, ULONG uptime)
3526 {
3527     FIXME("%p, %u stub.\n", iface, uptime);
3528
3529     return E_NOTIMPL;
3530 }
3531
3532 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDumpFormatFlags(IDebugControl2 *iface, ULONG *flags)
3533 {
3534     FIXME("%p, %p stub.\n", iface, flags);
3535
3536     return E_NOTIMPL;
3537 }
3538
3539 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextPlacements(IDebugControl2 *iface, ULONG *count)
3540 {
3541     FIXME("%p, %p stub.\n", iface, count);
3542
3543     return E_NOTIMPL;
3544 }
3545
3546 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextReplacement(IDebugControl2 *iface, const char *src_text,
3547         ULONG index, char *src_buffer, ULONG src_buffer_size, ULONG *src_size, char *dst_buffer,
3548         ULONG dst_buffer_size, ULONG *dst_size)
3549 {
3550     FIXME("%p, %s, %u, %p, %u, %p, %p, %u, %p stub.\n", iface, debugstr_a(src_text), index, src_buffer,
3551             src_buffer_size, src_size, dst_buffer, dst_buffer_size, dst_size);
3552
3553     return E_NOTIMPL;
3554 }
3555
3556 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacement(IDebugControl2 *iface, const char *src_text,
3557         const char *dst_text)
3558 {
3559     FIXME("%p, %s, %s stub.\n", iface, debugstr_a(src_text), debugstr_a(dst_text));
3560
3561     return E_NOTIMPL;
3562 }
3563
3564 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveTextReplacements(IDebugControl2 *iface)
3565 {
3566     FIXME("%p stub.\n", iface);
3567
3568     return E_NOTIMPL;
3569 }
3570
3571 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputTextReplacements(IDebugControl2 *iface, ULONG output_control,
3572         ULONG flags)
3573 {
3574     FIXME("%p, %u, %#x stub.\n", iface, output_control, flags);
3575
3576     return E_NOTIMPL;
3577 }
3578
3579 static const IDebugControl2Vtbl debugcontrolvtbl =
3580 {
3581     debugcontrol_QueryInterface,
3582     debugcontrol_AddRef,
3583     debugcontrol_Release,
3584     debugcontrol_GetInterrupt,
3585     debugcontrol_SetInterrupt,
3586     debugcontrol_GetInterruptTimeout,
3587     debugcontrol_SetInterruptTimeout,
3588     debugcontrol_GetLogFile,
3589     debugcontrol_OpenLogFile,
3590     debugcontrol_CloseLogFile,
3591     debugcontrol_GetLogMask,
3592     debugcontrol_SetLogMask,
3593     debugcontrol_Input,
3594     debugcontrol_ReturnInput,
3595     debugcontrol_Output,
3596     debugcontrol_OutputVaList,
3597     debugcontrol_ControlledOutput,
3598     debugcontrol_ControlledOutputVaList,
3599     debugcontrol_OutputPrompt,
3600     debugcontrol_OutputPromptVaList,
3601     debugcontrol_GetPromptText,
3602     debugcontrol_OutputCurrentState,
3603     debugcontrol_OutputVersionInformation,
3604     debugcontrol_GetNotifyEventHandle,
3605     debugcontrol_SetNotifyEventHandle,
3606     debugcontrol_Assemble,
3607     debugcontrol_Disassemble,
3608     debugcontrol_GetDisassembleEffectiveOffset,
3609     debugcontrol_OutputDisassembly,
3610     debugcontrol_OutputDisassemblyLines,
3611     debugcontrol_GetNearInstruction,
3612     debugcontrol_GetStackTrace,
3613     debugcontrol_GetReturnOffset,
3614     debugcontrol_OutputStackTrace,
3615     debugcontrol_GetDebuggeeType,
3616     debugcontrol_GetActualProcessorType,
3617     debugcontrol_GetExecutingProcessorType,
3618     debugcontrol_GetNumberPossibleExecutingProcessorTypes,
3619     debugcontrol_GetPossibleExecutingProcessorTypes,
3620     debugcontrol_GetNumberProcessors,
3621     debugcontrol_GetSystemVersion,
3622     debugcontrol_GetPageSize,
3623     debugcontrol_IsPointer64Bit,
3624     debugcontrol_ReadBugCheckData,
3625     debugcontrol_GetNumberSupportedProcessorTypes,
3626     debugcontrol_GetSupportedProcessorTypes,
3627     debugcontrol_GetProcessorTypeNames,
3628     debugcontrol_GetEffectiveProcessorType,
3629     debugcontrol_SetEffectiveProcessorType,
3630     debugcontrol_GetExecutionStatus,
3631     debugcontrol_SetExecutionStatus,
3632     debugcontrol_GetCodeLevel,
3633     debugcontrol_SetCodeLevel,
3634     debugcontrol_GetEngineOptions,
3635     debugcontrol_AddEngineOptions,
3636     debugcontrol_RemoveEngineOptions,
3637     debugcontrol_SetEngineOptions,
3638     debugcontrol_GetSystemErrorControl,
3639     debugcontrol_SetSystemErrorControl,
3640     debugcontrol_GetTextMacro,
3641     debugcontrol_SetTextMacro,
3642     debugcontrol_GetRadix,
3643     debugcontrol_SetRadix,
3644     debugcontrol_Evaluate,
3645     debugcontrol_CoerceValue,
3646     debugcontrol_CoerceValues,
3647     debugcontrol_Execute,
3648     debugcontrol_ExecuteCommandFile,
3649     debugcontrol_GetNumberBreakpoints,
3650     debugcontrol_GetBreakpointByIndex,
3651     debugcontrol_GetBreakpointById,
3652     debugcontrol_GetBreakpointParameters,
3653     debugcontrol_AddBreakpoint,
3654     debugcontrol_RemoveBreakpoint,
3655     debugcontrol_AddExtension,
3656     debugcontrol_RemoveExtension,
3657     debugcontrol_GetExtensionByPath,
3658     debugcontrol_CallExtension,
3659     debugcontrol_GetExtensionFunction,
3660     debugcontrol_GetWindbgExtensionApis32,
3661     debugcontrol_GetWindbgExtensionApis64,
3662     debugcontrol_GetNumberEventFilters,
3663     debugcontrol_GetEventFilterText,
3664     debugcontrol_GetEventFilterCommand,
3665     debugcontrol_SetEventFilterCommand,
3666     debugcontrol_GetSpecificFilterParameters,
3667     debugcontrol_SetSpecificFilterParameters,
3668     debugcontrol_GetSpecificFilterArgument,
3669     debugcontrol_SetSpecificFilterArgument,
3670     debugcontrol_GetExceptionFilterParameters,
3671     debugcontrol_SetExceptionFilterParameters,
3672     debugcontrol_GetExceptionFilterSecondCommand,
3673     debugcontrol_SetExceptionFilterSecondCommand,
3674     debugcontrol_WaitForEvent,
3675     debugcontrol_GetLastEventInformation,
3676     debugcontrol_GetCurrentTimeDate,
3677     debugcontrol_GetCurrentSystemUpTime,
3678     debugcontrol_GetDumpFormatFlags,
3679     debugcontrol_GetNumberTextPlacements,
3680     debugcontrol_GetNumberTextReplacement,
3681     debugcontrol_SetTextReplacement,
3682     debugcontrol_RemoveTextReplacements,
3683     debugcontrol_OutputTextReplacements,
3684 };
3685
3686 static HRESULT STDMETHODCALLTYPE debugadvanced_QueryInterface(IDebugAdvanced *iface, REFIID riid, void **obj)
3687 {
3688     struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
3689     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
3690     return IUnknown_QueryInterface(unk, riid, obj);
3691 }
3692
3693 static ULONG STDMETHODCALLTYPE debugadvanced_AddRef(IDebugAdvanced *iface)
3694 {
3695     struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
3696     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
3697     return IUnknown_AddRef(unk);
3698 }
3699
3700 static ULONG STDMETHODCALLTYPE debugadvanced_Release(IDebugAdvanced *iface)
3701 {
3702     struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
3703     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
3704     return IUnknown_Release(unk);
3705 }
3706
3707 static HRESULT STDMETHODCALLTYPE debugadvanced_GetThreadContext(IDebugAdvanced *iface, void *context,
3708         ULONG context_size)
3709 {
3710     FIXME("%p, %p, %u stub.\n", iface, context, context_size);
3711
3712     return E_NOTIMPL;
3713 }
3714
3715 static HRESULT STDMETHODCALLTYPE debugadvanced_SetThreadContext(IDebugAdvanced *iface, void *context,
3716         ULONG context_size)
3717 {
3718     FIXME("%p, %p, %u stub.\n", iface, context, context_size);
3719
3720     return E_NOTIMPL;
3721 }
3722
3723 static const IDebugAdvancedVtbl debugadvancedvtbl =
3724 {
3725     debugadvanced_QueryInterface,
3726     debugadvanced_AddRef,
3727     debugadvanced_Release,
3728     /* IDebugAdvanced */
3729     debugadvanced_GetThreadContext,
3730     debugadvanced_SetThreadContext,
3731 };
3732
3733
3734 static HRESULT STDMETHODCALLTYPE debugsystemobjects_QueryInterface(IDebugSystemObjects *iface, REFIID riid, void **obj)
3735 {
3736     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
3737     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
3738     return IUnknown_QueryInterface(unk, riid, obj);
3739 }
3740
3741 static ULONG STDMETHODCALLTYPE debugsystemobjects_AddRef(IDebugSystemObjects *iface)
3742 {
3743     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
3744     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
3745     return IUnknown_AddRef(unk);
3746 }
3747
3748 static ULONG STDMETHODCALLTYPE debugsystemobjects_Release(IDebugSystemObjects *iface)
3749 {
3750     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
3751     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
3752     return IUnknown_Release(unk);
3753 }
3754
3755 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventThread(IDebugSystemObjects *iface, ULONG *id)
3756 {
3757     FIXME("%p, %p stub.\n", iface, id);
3758
3759     return E_NOTIMPL;
3760 }
3761
3762 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventProcess(IDebugSystemObjects *iface, ULONG *id)
3763 {
3764     FIXME("%p, %p stub.\n", iface, id);
3765
3766     return E_NOTIMPL;
3767 }
3768
3769 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadId(IDebugSystemObjects *iface, ULONG *id)
3770 {
3771     FIXME("%p, %p stub.\n", iface, id);
3772
3773     return E_NOTIMPL;
3774 }
3775
3776 static HRESULT STDMETHODCALLTYPE debugsystemobjects_SetCurrentThreadId(IDebugSystemObjects *iface, ULONG id)
3777 {
3778     FIXME("%p, %u stub.\n", iface, id);
3779
3780     return E_NOTIMPL;
3781 }
3782
3783 static HRESULT STDMETHODCALLTYPE debugsystemobjects_SetCurrentProcessId(IDebugSystemObjects *iface, ULONG id)
3784 {
3785     FIXME("%p, %u stub.\n", iface, id);
3786
3787     return E_NOTIMPL;
3788 }
3789
3790 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberThreads(IDebugSystemObjects *iface, ULONG *number)
3791 {
3792     FIXME("%p, %p stub.\n", iface, number);
3793
3794     return E_NOTIMPL;
3795 }
3796
3797 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetTotalNumberThreads(IDebugSystemObjects *iface, ULONG *total,
3798         ULONG *largest_process)
3799 {
3800     FIXME("%p, %p, %p stub.\n", iface, total, largest_process);
3801
3802     return E_NOTIMPL;
3803 }
3804
3805 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdsByIndex(IDebugSystemObjects *iface, ULONG start,
3806         ULONG count, ULONG *ids, ULONG *sysids)
3807 {
3808     FIXME("%p, %u, %u, %p, %p stub.\n", iface, start, count, ids, sysids);
3809
3810     return E_NOTIMPL;
3811 }
3812
3813 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByProcessor(IDebugSystemObjects *iface, ULONG processor,
3814         ULONG *id)
3815 {
3816     FIXME("%p, %u, %p stub.\n", iface, processor, id);
3817
3818     return E_NOTIMPL;
3819 }
3820
3821 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadDataOffset(IDebugSystemObjects *iface,
3822         ULONG64 *offset)
3823 {
3824     FIXME("%p, %p stub.\n", iface, offset);
3825
3826     return E_NOTIMPL;
3827 }
3828
3829 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByDataOffset(IDebugSystemObjects *iface, ULONG64 offset,
3830         ULONG *id)
3831 {
3832     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
3833
3834     return E_NOTIMPL;
3835 }
3836
3837 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadTeb(IDebugSystemObjects *iface, ULONG64 *offset)
3838 {
3839     FIXME("%p, %p stub.\n", iface, offset);
3840
3841     return E_NOTIMPL;
3842 }
3843
3844 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByTeb(IDebugSystemObjects *iface, ULONG64 offset,
3845         ULONG *id)
3846 {
3847     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
3848
3849     return E_NOTIMPL;
3850 }
3851
3852 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadSystemId(IDebugSystemObjects *iface, ULONG *sysid)
3853 {
3854     FIXME("%p, %p stub.\n", iface, sysid);
3855
3856     return E_NOTIMPL;
3857 }
3858
3859 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
3860         ULONG *id)
3861 {
3862     FIXME("%p, %u, %p stub.\n", iface, sysid, id);
3863
3864     return E_NOTIMPL;
3865 }
3866
3867 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadHandle(IDebugSystemObjects *iface, ULONG64 *handle)
3868 {
3869     FIXME("%p, %p stub.\n", iface, handle);
3870
3871     return E_NOTIMPL;
3872 }
3873
3874 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
3875         ULONG *id)
3876 {
3877     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
3878
3879     return E_NOTIMPL;
3880 }
3881
3882 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberProcesses(IDebugSystemObjects *iface, ULONG *number)
3883 {
3884     FIXME("%p, %p stub.\n", iface, number);
3885
3886     return E_NOTIMPL;
3887 }
3888
3889 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdsByIndex(IDebugSystemObjects *iface, ULONG start,
3890         ULONG count, ULONG *ids, ULONG *sysids)
3891 {
3892     FIXME("%p, %u, %u, %p, %p stub.\n", iface, start, count, ids, sysids);
3893
3894     return E_NOTIMPL;
3895 }
3896
3897 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessDataOffset(IDebugSystemObjects *iface,
3898         ULONG64 *offset)
3899 {
3900     FIXME("%p, %p stub.\n", iface, offset);
3901
3902     return E_NOTIMPL;
3903 }
3904
3905 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByDataOffset(IDebugSystemObjects *iface,
3906         ULONG64 offset, ULONG *id)
3907 {
3908     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
3909
3910     return E_NOTIMPL;
3911 }
3912
3913 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessPeb(IDebugSystemObjects *iface, ULONG64 *offset)
3914 {
3915     FIXME("%p, %p stub.\n", iface, offset);
3916
3917     return E_NOTIMPL;
3918 }
3919
3920 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByPeb(IDebugSystemObjects *iface, ULONG64 offset,
3921         ULONG *id)
3922 {
3923     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
3924
3925     return E_NOTIMPL;
3926 }
3927
3928 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessSystemId(IDebugSystemObjects *iface, ULONG *sysid)
3929 {
3930     FIXME("%p, %p stub.\n", iface, sysid);
3931
3932     return E_NOTIMPL;
3933 }
3934
3935 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
3936         ULONG *id)
3937 {
3938     FIXME("%p, %u, %p stub.\n", iface, sysid, id);
3939
3940     return E_NOTIMPL;
3941 }
3942
3943 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessHandle(IDebugSystemObjects *iface,
3944         ULONG64 *handle)
3945 {
3946     FIXME("%p, %p stub.\n", iface, handle);
3947
3948     return E_NOTIMPL;
3949 }
3950
3951 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
3952         ULONG *id)
3953 {
3954     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
3955
3956     return E_NOTIMPL;
3957 }
3958
3959 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessExecutableName(IDebugSystemObjects *iface,
3960         char *buffer, ULONG buffer_size, ULONG *exe_size)
3961 {
3962     FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, exe_size);
3963
3964     return E_NOTIMPL;
3965 }
3966
3967 static const IDebugSystemObjectsVtbl debugsystemobjectsvtbl =
3968 {
3969     debugsystemobjects_QueryInterface,
3970     debugsystemobjects_AddRef,
3971     debugsystemobjects_Release,
3972     debugsystemobjects_GetEventThread,
3973     debugsystemobjects_GetEventProcess,
3974     debugsystemobjects_GetCurrentThreadId,
3975     debugsystemobjects_SetCurrentThreadId,
3976     debugsystemobjects_SetCurrentProcessId,
3977     debugsystemobjects_GetNumberThreads,
3978     debugsystemobjects_GetTotalNumberThreads,
3979     debugsystemobjects_GetThreadIdsByIndex,
3980     debugsystemobjects_GetThreadIdByProcessor,
3981     debugsystemobjects_GetCurrentThreadDataOffset,
3982     debugsystemobjects_GetThreadIdByDataOffset,
3983     debugsystemobjects_GetCurrentThreadTeb,
3984     debugsystemobjects_GetThreadIdByTeb,
3985     debugsystemobjects_GetCurrentThreadSystemId,
3986     debugsystemobjects_GetThreadIdBySystemId,
3987     debugsystemobjects_GetCurrentThreadHandle,
3988     debugsystemobjects_GetThreadIdByHandle,
3989     debugsystemobjects_GetNumberProcesses,
3990     debugsystemobjects_GetProcessIdsByIndex,
3991     debugsystemobjects_GetCurrentProcessDataOffset,
3992     debugsystemobjects_GetProcessIdByDataOffset,
3993     debugsystemobjects_GetCurrentProcessPeb,
3994     debugsystemobjects_GetProcessIdByPeb,
3995     debugsystemobjects_GetCurrentProcessSystemId,
3996     debugsystemobjects_GetProcessIdBySystemId,
3997     debugsystemobjects_GetCurrentProcessHandle,
3998     debugsystemobjects_GetProcessIdByHandle,
3999     debugsystemobjects_GetCurrentProcessExecutableName,
4000 };
4001
4002 /************************************************************
4003 *                    DebugExtensionInitialize   (DBGENG.@)
4004 *
4005 * Initializing Debug Engine
4006 *
4007 * PARAMS
4008 *   pVersion  [O] Receiving the version of extension
4009 *   pFlags    [O] Reserved
4010 *
4011 * RETURNS
4012 *   Success: S_OK
4013 *   Failure: Anything other than S_OK
4014 *
4015 * BUGS
4016 *   Unimplemented
4017 */
4018 HRESULT WINAPI DebugExtensionInitialize(ULONG * pVersion, ULONG * pFlags)
4019 {
4020     FIXME("(%p,%p): stub\n", pVersion, pFlags);
4021
4022     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4023
4024     return E_NOTIMPL;
4025 }
4026
4027 /************************************************************
4028 *                    DebugCreate   (dbgeng.@)
4029 */
4030 HRESULT WINAPI DebugCreate(REFIID riid, void **obj)
4031 {
4032     struct debug_client *debug_client;
4033     IUnknown *unk;
4034     HRESULT hr;
4035
4036     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
4037
4038     debug_client = heap_alloc_zero(sizeof(*debug_client));
4039     if (!debug_client)
4040         return E_OUTOFMEMORY;
4041
4042     debug_client->IDebugClient_iface.lpVtbl = &debugclientvtbl;
4043     debug_client->IDebugDataSpaces_iface.lpVtbl = &debugdataspacesvtbl;
4044     debug_client->IDebugSymbols3_iface.lpVtbl = &debugsymbolsvtbl;
4045     debug_client->IDebugControl2_iface.lpVtbl = &debugcontrolvtbl;
4046     debug_client->IDebugAdvanced_iface.lpVtbl = &debugadvancedvtbl;
4047     debug_client->IDebugSystemObjects_iface.lpVtbl = &debugsystemobjectsvtbl;
4048     debug_client->refcount = 1;
4049     list_init(&debug_client->targets);
4050
4051     unk = (IUnknown *)&debug_client->IDebugClient_iface;
4052
4053     hr = IUnknown_QueryInterface(unk, riid, obj);
4054     IUnknown_Release(unk);
4055
4056     return hr;
4057 }
4058
4059 /************************************************************
4060 *                    DebugCreateEx   (DBGENG.@)
4061 */
4062 HRESULT WINAPI DebugCreateEx(REFIID riid, DWORD flags, void **obj)
4063 {
4064     FIXME("(%s, %#x, %p): stub\n", debugstr_guid(riid), flags, obj);
4065
4066     return E_NOTIMPL;
4067 }
4068
4069 /************************************************************
4070 *                    DebugConnect   (DBGENG.@)
4071 *
4072 * Creating Debug Engine client object and connecting it to remote host
4073 *
4074 * PARAMS
4075 *   RemoteOptions [I] Options which define how debugger engine connects to remote host
4076 *   InterfaceId   [I] Interface Id of debugger client
4077 *   pInterface    [O] Pointer to interface as requested via InterfaceId
4078 *
4079 * RETURNS
4080 *   Success: S_OK
4081 *   Failure: Anything other than S_OK
4082 *
4083 * BUGS
4084 *   Unimplemented
4085 */
4086 HRESULT WINAPI DebugConnect(PCSTR RemoteOptions, REFIID InterfaceId, PVOID * pInterface)
4087 {
4088     FIXME("(%p,%p,%p): stub\n", RemoteOptions, InterfaceId, pInterface);
4089
4090     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4091
4092     return E_NOTIMPL;
4093 }