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/list.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(dbgeng);
  37
  38 struct module_info
  39 {
  40     DEBUG_MODULE_PARAMETERS params;
  41     char image_name[MAX_PATH];
  42 };
  43
  44 struct target_process
  45 {
  46     struct list entry;
  47     unsigned int pid;
  48     unsigned int attach_flags;
  49     HANDLE handle;
  50     struct
  51     {
  52         struct module_info *info;
  53         unsigned int loaded;
  54         unsigned int unloaded;
  55         BOOL initialized;
  56     } modules;
  57     ULONG cpu_type;
  58 };
  59
  60 struct debug_client
  61 {
  62     IDebugClient7 IDebugClient_iface;
  63     IDebugDataSpaces IDebugDataSpaces_iface;
  64     IDebugSymbols3 IDebugSymbols3_iface;
  65     IDebugControl4 IDebugControl4_iface;
  66     IDebugAdvanced3 IDebugAdvanced3_iface;
  67     IDebugSystemObjects IDebugSystemObjects_iface;
  68     LONG refcount;
  69     ULONG engine_options;
  70     struct list targets;
  71     IDebugEventCallbacks *event_callbacks;
  72 };
  73
  74 static struct target_process *debug_client_get_target(struct debug_client *debug_client)
  75 {
  76     if (list_empty(&debug_client->targets))
  77         return NULL;
  78
  79     return LIST_ENTRY(list_head(&debug_client->targets), struct target_process, entry);
  80 }
  81
  82 static HRESULT debug_target_return_string(const char *str, char *buffer, unsigned int buffer_size,
  83                                           ULONG *size)
  84 {
  85     unsigned int len = strlen(str), dst_len;
  86
  87     if (size)
  88         *size = len + 1;
  89
  90     if (buffer && buffer_size)
  91     {
  92         dst_len = min(len, buffer_size - 1);
  93         if (dst_len)
  94             memcpy(buffer, str, dst_len);
  95         buffer[dst_len] = 0;
  96     }
  97
  98     return len < buffer_size ? S_OK : S_FALSE;
  99 }
 100
 101 static WORD debug_target_get_module_machine(struct target_process *target, HMODULE module)
 102 {
 103     IMAGE_DOS_HEADER dos = { 0 };
 104     WORD machine = 0;
 105
 106     ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
 107     if (dos.e_magic == IMAGE_DOS_SIGNATURE)
 108     {
 109         ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /* PE signature */, &machine,
 110                 sizeof(machine), NULL);
 111     }
 112
 113     return machine;
 114 }
 115
 116 static DWORD debug_target_get_module_timestamp(struct target_process *target, HMODULE module)
 117 {
 118     IMAGE_DOS_HEADER dos = { 0 };
 119     DWORD timestamp = 0;
 120
 121     ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
 122     if (dos.e_magic == IMAGE_DOS_SIGNATURE)
 123     {
 124         ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /* PE signature */ +
 125                 FIELD_OFFSET(IMAGE_FILE_HEADER, TimeDateStamp), &timestamp, sizeof(timestamp), NULL);
 126     }
 127
 128     return timestamp;
 129 }
 130
 131 static HRESULT debug_target_init_modules_info(struct target_process *target)
 132 {
 133     unsigned int i, count;
 134     HMODULE *modules;
 135     MODULEINFO info;
 136     DWORD needed;
 137
 138     if (target->modules.initialized)
 139         return S_OK;
 140
 141     if (!target->handle)
 142         return E_UNEXPECTED;
 143
 144     needed = 0;
 145     EnumProcessModules(target->handle, NULL, 0, &needed);
 146     if (!needed)
 147         return E_FAIL;
 148
 149     count = needed / sizeof(HMODULE);
 150
 151     if (!(modules = calloc(count, sizeof(*modules))))
 152         return E_OUTOFMEMORY;
 153
 154     if (!(target->modules.info = calloc(count, sizeof(*target->modules.info))))
 155     {
 156         free(modules);
 157         return E_OUTOFMEMORY;
 158     }
 159
 160     if (EnumProcessModules(target->handle, modules, count * sizeof(*modules), &needed))
 161     {
 162         for (i = 0; i < count; ++i)
 163         {
 164             if (!GetModuleInformation(target->handle, modules[i], &info, sizeof(info)))
 165             {
 166                 WARN("Failed to get module information, error %ld.\n", GetLastError());
 167                 continue;
 168             }
 169
 170             target->modules.info[i].params.Base = (ULONG_PTR)info.lpBaseOfDll;
 171             target->modules.info[i].params.Size = info.SizeOfImage;
 172             target->modules.info[i].params.TimeDateStamp = debug_target_get_module_timestamp(target, modules[i]);
 173
 174             GetModuleFileNameExA(target->handle, modules[i], target->modules.info[i].image_name,
 175                     ARRAY_SIZE(target->modules.info[i].image_name));
 176         }
 177     }
 178
 179     target->cpu_type = debug_target_get_module_machine(target, modules[0]);
 180
 181     free(modules);
 182
 183     target->modules.loaded = count;
 184     target->modules.unloaded = 0; /* FIXME */
 185
 186     target->modules.initialized = TRUE;
 187
 188     return S_OK;
 189 }
 190
 191 static const struct module_info *debug_target_get_module_info(struct target_process *target, unsigned int i)
 192 {
 193     if (FAILED(debug_target_init_modules_info(target)))
 194         return NULL;
 195
 196     if (i >= target->modules.loaded)
 197         return NULL;
 198
 199     return &target->modules.info[i];
 200 }
 201
 202 static const struct module_info *debug_target_get_module_info_by_base(struct target_process *target, ULONG64 base)
 203 {
 204     unsigned int i;
 205
 206     if (FAILED(debug_target_init_modules_info(target)))
 207         return NULL;
 208
 209     for (i = 0; i < target->modules.loaded; ++i)
 210     {
 211         if (target->modules.info[i].params.Base == base)
 212             return &target->modules.info[i];
 213     }
 214
 215     return NULL;
 216 }
 217
 218 static void debug_client_detach_target(struct target_process *target)
 219 {
 220     NTSTATUS status;
 221
 222     if (!target->handle)
 223         return;
 224
 225     if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
 226     {
 227         BOOL resume = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
 228
 229         if (resume)
 230         {
 231             if ((status = NtResumeProcess(target->handle)))
 232                 WARN("Failed to resume process, status %#lx.\n", status);
 233         }
 234     }
 235
 236     CloseHandle(target->handle);
 237     target->handle = NULL;
 238 }
 239
 240 static struct debug_client *impl_from_IDebugClient(IDebugClient7 *iface)
 241 {
 242     return CONTAINING_RECORD(iface, struct debug_client, IDebugClient_iface);
 243 }
 244
 245 static struct debug_client *impl_from_IDebugDataSpaces(IDebugDataSpaces *iface)
 246 {
 247     return CONTAINING_RECORD(iface, struct debug_client, IDebugDataSpaces_iface);
 248 }
 249
 250 static struct debug_client *impl_from_IDebugSymbols3(IDebugSymbols3 *iface)
 251 {
 252     return CONTAINING_RECORD(iface, struct debug_client, IDebugSymbols3_iface);
 253 }
 254
 255 static struct debug_client *impl_from_IDebugControl4(IDebugControl4 *iface)
 256 {
 257     return CONTAINING_RECORD(iface, struct debug_client, IDebugControl4_iface);
 258 }
 259
 260 static struct debug_client *impl_from_IDebugAdvanced3(IDebugAdvanced3 *iface)
 261 {
 262     return CONTAINING_RECORD(iface, struct debug_client, IDebugAdvanced3_iface);
 263 }
 264
 265 static struct debug_client *impl_from_IDebugSystemObjects(IDebugSystemObjects *iface)
 266 {
 267     return CONTAINING_RECORD(iface, struct debug_client, IDebugSystemObjects_iface);
 268 }
 269
 270 static HRESULT STDMETHODCALLTYPE debugclient_QueryInterface(IDebugClient7 *iface, REFIID riid, void **obj)
 271 {
 272     struct debug_client *debug_client = impl_from_IDebugClient(iface);
 273
 274     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 275
 276     if (IsEqualIID(riid, &IID_IDebugClient) ||
 277         IsEqualIID(riid, &IID_IDebugClient2) ||
 278         IsEqualIID(riid, &IID_IDebugClient3) ||
 279         IsEqualIID(riid, &IID_IDebugClient4) ||
 280         IsEqualIID(riid, &IID_IDebugClient5) ||
 281         IsEqualIID(riid, &IID_IDebugClient6) ||
 282         IsEqualIID(riid, &IID_IDebugClient7) ||
 283         IsEqualIID(riid, &IID_IUnknown))
 284     {
 285         *obj = iface;
 286     }
 287     else if (IsEqualIID(riid, &IID_IDebugDataSpaces))
 288     {
 289         *obj = &debug_client->IDebugDataSpaces_iface;
 290     }
 291     else if (IsEqualIID(riid, &IID_IDebugSymbols)
 292              || IsEqualIID(riid, &IID_IDebugSymbols2)
 293              || IsEqualIID(riid, &IID_IDebugSymbols3))
 294     {
 295         *obj = &debug_client->IDebugSymbols3_iface;
 296     }
 297     else if (IsEqualIID(riid, &IID_IDebugControl4)
 298             || IsEqualIID(riid, &IID_IDebugControl3)
 299             || IsEqualIID(riid, &IID_IDebugControl2)
 300             || IsEqualIID(riid, &IID_IDebugControl))
 301     {
 302         *obj = &debug_client->IDebugControl4_iface;
 303     }
 304     else if (IsEqualIID(riid, &IID_IDebugAdvanced3)
 305             || IsEqualIID(riid, &IID_IDebugAdvanced2)
 306             || IsEqualIID(riid, &IID_IDebugAdvanced))
 307     {
 308         *obj = &debug_client->IDebugAdvanced3_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, refcount %lu.\n", iface, refcount);
 331
 332     return refcount;
 333 }
 334
 335 static void debug_target_free(struct target_process *target)
 336 {
 337     free(target->modules.info);
 338     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, refcount %lu.\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         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, %#lx, %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, %lu, %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, %#lx, %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, %lu, %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, %#lx, %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, %lu, %#lx, %p, %lu, %p, %p, %lu, %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, %lu, %#lx.\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 = calloc(1, 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, %#lx 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, %#lx, %lu, %#lx 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, %#lx 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, %#lx 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, %#lx 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, %lu 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, %#lx, %lu 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, %lu, %s, %#lx 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, %#lx 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, %lu 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, %#lx 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, %#lx 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, %lu 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, %lu, %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, %lu, %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, %lu, %#lx, %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, %lu, %#lx, %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, %lu.\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, %lu.\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, %#lx, %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, %lu, %#lx, %s, %lu, %p, %s, %lu, %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, %#lx.\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, %#lx, %lu, %#lx.\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, %lu, %#lx, %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, %lu.\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, %lu, %p, %lu, %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, %lu, %p, %lu, %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, %#lx, %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, %lu, %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, %#lx, %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, %lu, %s, %#lx.\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, %lu, %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, %lu, %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, %ld, %#lx, %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, %ld, %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, %ld, %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, %ld, %s, %s, %ld, %#lx.\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, %ld, %s, %s, %ld, %#lx.\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, %#lx, %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, %ld, %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, %ld, %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, %ld.\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, %lu, %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 %#lx.\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, %lu, %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, %lu, %lu, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %s, %p, %lu, %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, %lu, %s, %p, %lu, %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, %lu, %lu, %lu, %s, %p, %lu, %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, %lu, %lu, %lu, %s, %p, %lu, %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, %lu, %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, %lu, %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, %lu, %lu, %lu, %lu, %p, %lu, %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, %lu, %lu, %lu, %lu, %p, %lu, %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, %lu, %p, %lu, %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, %lu, %lu, %p, %lu, %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, %#lx 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, %#lx 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, %#lx 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, %lu, %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, %ld, %p, %lu, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %s, %p, %lu, %p, %p, %lu, %p, %p, %lu, %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, %lu, %p, %lu, %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, %lu, %p, %lu, %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, %lu, %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, %lu, %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, %lu, %p, %lu, %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, %lu, %p, %lu, %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, %#lx, %s, %s, %lu, %#lx 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, %lu, %p, %lu, %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, %lu, %p, %lu, %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, %#lx, %s, %s, %lu, %#lx 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, %lu 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, %lu 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, %#lx, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %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, %lu, %p, %lu, %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, %lu, %s, %#lx, %p, %p, %lu, %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, %lu, %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;
1884     UINT size;
1885
1886     TRACE("%p, %lu, %s, %s, %p, %lu, %p.\n", iface, index, wine_dbgstr_longlong(base), debugstr_a(item), buffer,
1887             buffer_size, info_size);
1888
1889     if (!(target = debug_client_get_target(debug_client)))
1890         return E_UNEXPECTED;
1891
1892     if (index == DEBUG_ANY_ID)
1893         info = debug_target_get_module_info_by_base(target, base);
1894     else
1895         info = debug_target_get_module_info(target, index);
1896
1897     if (!info)
1898     {
1899         WARN("Was unable to locate module.\n");
1900         return E_INVALIDARG;
1901     }
1902
1903     if (!(size = GetFileVersionInfoSizeA(info->image_name, &handle)))
1904         return E_FAIL;
1905
1906     if (!(version_info = malloc(size)))
1907         return E_OUTOFMEMORY;
1908
1909     if (GetFileVersionInfoA(info->image_name, handle, size, version_info))
1910     {
1911         if (VerQueryValueA(version_info, item, &ptr, &size))
1912         {
1913             if (info_size)
1914                 *info_size = size;
1915
1916             if (buffer && buffer_size)
1917             {
1918                 unsigned int dst_len = min(size, buffer_size);
1919                 if (dst_len)
1920                     memcpy(buffer, ptr, dst_len);
1921             }
1922
1923             hr = buffer && buffer_size < size ? S_FALSE : S_OK;
1924         }
1925     }
1926
1927     free(version_info);
1928
1929     return hr;
1930 }
1931
1932 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameString(IDebugSymbols3 *iface, ULONG which, ULONG index,
1933         ULONG64 base, char *buffer, ULONG buffer_size, ULONG *name_size)
1934 {
1935     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1936     const struct module_info *info;
1937     struct target_process *target;
1938     HRESULT hr;
1939
1940     TRACE("%p, %lu, %lu, %s, %p, %lu, %p.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
1941             name_size);
1942
1943     if (!(target = debug_client_get_target(debug_client)))
1944         return E_UNEXPECTED;
1945
1946     if (index == DEBUG_ANY_ID)
1947         info = debug_target_get_module_info_by_base(target, base);
1948     else
1949         info = debug_target_get_module_info(target, index);
1950
1951     if (!info)
1952     {
1953         WARN("Was unable to locate module.\n");
1954         return E_INVALIDARG;
1955     }
1956
1957     switch (which)
1958     {
1959         case DEBUG_MODNAME_IMAGE:
1960             hr = debug_target_return_string(info->image_name, buffer, buffer_size, name_size);
1961             break;
1962         case DEBUG_MODNAME_MODULE:
1963         case DEBUG_MODNAME_LOADED_IMAGE:
1964         case DEBUG_MODNAME_SYMBOL_FILE:
1965         case DEBUG_MODNAME_MAPPED_IMAGE:
1966             FIXME("Unsupported name info %ld.\n", which);
1967             return E_NOTIMPL;
1968         default:
1969             WARN("Unknown name info %ld.\n", which);
1970             return E_INVALIDARG;
1971     }
1972
1973     return hr;
1974 }
1975
1976 static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantName(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
1977         ULONG64 value, char *buffer, ULONG buffer_size, ULONG *name_size)
1978 {
1979     FIXME("%p, %s, %lu, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
1980             wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
1981
1982     return E_NOTIMPL;
1983 }
1984
1985 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldName(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
1986         ULONG field_index, char *buffer, ULONG buffer_size, ULONG *name_size)
1987 {
1988     FIXME("%p, %s, %lu, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
1989             buffer_size, name_size);
1990
1991     return E_NOTIMPL;
1992 }
1993
1994 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeOptions(IDebugSymbols3 *iface, ULONG *options)
1995 {
1996     FIXME("%p, %p stub.\n", iface, options);
1997
1998     return E_NOTIMPL;
1999 }
2000
2001 static HRESULT STDMETHODCALLTYPE debugsymbols_AddTypeOptions(IDebugSymbols3 *iface, ULONG options)
2002 {
2003     FIXME("%p, %#lx stub.\n", iface, options);
2004
2005     return E_NOTIMPL;
2006 }
2007
2008 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveTypeOptions(IDebugSymbols3 *iface, ULONG options)
2009 {
2010     FIXME("%p, %#lx stub.\n", iface, options);
2011
2012     return E_NOTIMPL;
2013 }
2014
2015 static HRESULT STDMETHODCALLTYPE debugsymbols_SetTypeOptions(IDebugSymbols3 *iface, ULONG options)
2016 {
2017     FIXME("%p, %#lx stub.\n", iface, options);
2018
2019     return E_NOTIMPL;
2020 }
2021
2022 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset, WCHAR *buffer,
2023         ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
2024 {
2025     FIXME("%p, %s, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, name_size,
2026             displacement);
2027
2028     return E_NOTIMPL;
2029 }
2030
2031 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2032         ULONG64 *offset)
2033 {
2034     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), offset);
2035
2036     return E_NOTIMPL;
2037 }
2038
2039 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset,
2040         LONG delta, WCHAR *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
2041 {
2042     FIXME("%p, %s, %ld, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
2043             name_size, displacement);
2044
2045     return E_NOTIMPL;
2046 }
2047
2048 static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset, ULONG *line,
2049         WCHAR *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
2050 {
2051     FIXME("%p, %s, %p, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
2052             file_size, displacement);
2053
2054     return E_NOTIMPL;
2055 }
2056
2057 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLineWide(IDebugSymbols3 *iface, ULONG line, const WCHAR *file,
2058         ULONG64 *offset)
2059 {
2060     FIXME("%p, %lu, %s, %p stub.\n", iface, line, debugstr_w(file), offset);
2061
2062     return E_NOTIMPL;
2063 }
2064
2065 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleNameWide(IDebugSymbols3 *iface, const WCHAR *name,
2066         ULONG start_index, ULONG *index, ULONG64 *base)
2067 {
2068     FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_w(name), start_index, index, base);
2069
2070     return E_NOTIMPL;
2071 }
2072
2073 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModuleWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2074         ULONG64 *base)
2075 {
2076     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), base);
2077
2078     return E_NOTIMPL;
2079 }
2080
2081 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2082         WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2083 {
2084     FIXME("%p, %s, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, buffer, buffer_size,
2085             name_size);
2086
2087     return E_NOTIMPL;
2088 }
2089
2090 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeIdWide(IDebugSymbols3 *iface, ULONG64 module, const WCHAR *name,
2091         ULONG *type_id)
2092 {
2093     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), debugstr_w(name), type_id);
2094
2095     return E_NOTIMPL;
2096 }
2097
2098 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffsetWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2099         const WCHAR *field, ULONG *offset)
2100 {
2101     FIXME("%p, %s, %lu, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, debugstr_w(field), offset);
2102
2103     return E_NOTIMPL;
2104 }
2105
2106 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeIdWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2107         ULONG *type_id, ULONG64 *module)
2108 {
2109     FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_w(symbol), type_id, module);
2110
2111     return E_NOTIMPL;
2112 }
2113
2114 static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup2(IDebugSymbols3 *iface, ULONG flags,
2115         PDEBUG_SYMBOL_GROUP2 update, PDEBUG_SYMBOL_GROUP2 *symbols)
2116 {
2117     FIXME("%p, %#lx, %p, %p stub.\n", iface, flags, update, symbols);
2118
2119     return E_NOTIMPL;
2120 }
2121
2122 static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup2(IDebugSymbols3 *iface, PDEBUG_SYMBOL_GROUP2 *group)
2123 {
2124     FIXME("%p, %p stub.\n", iface, group);
2125
2126     return E_NOTIMPL;
2127 }
2128
2129 static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatchWide(IDebugSymbols3 *iface, const WCHAR *pattern,
2130         ULONG64 *handle)
2131 {
2132     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(pattern), handle);
2133
2134     return E_NOTIMPL;
2135 }
2136
2137 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatchWide(IDebugSymbols3 *iface, ULONG64 handle,
2138         WCHAR *buffer, ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
2139 {
2140     FIXME("%p, %s, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
2141
2142     return E_NOTIMPL;
2143 }
2144
2145 static HRESULT STDMETHODCALLTYPE debugsymbols_ReloadWide(IDebugSymbols3 *iface, const WCHAR *module)
2146 {
2147     FIXME("%p, %s stub.\n", iface, debugstr_w(module));
2148
2149     return E_NOTIMPL;
2150 }
2151
2152 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2153         ULONG *path_size)
2154 {
2155     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
2156
2157     return E_NOTIMPL;
2158 }
2159
2160 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *path)
2161 {
2162     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2163
2164     return E_NOTIMPL;
2165 }
2166
2167 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2168 {
2169     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2170
2171     return E_NOTIMPL;
2172 }
2173
2174 static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2175         ULONG *path_size)
2176 {
2177     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
2178
2179     return E_NOTIMPL;
2180 }
2181
2182 static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePathWide(IDebugSymbols3 *iface, const WCHAR *path)
2183 {
2184     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2185
2186     return E_NOTIMPL;
2187 }
2188
2189 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2190 {
2191     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2192
2193     return E_NOTIMPL;
2194 }
2195
2196 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2197         ULONG *path_size)
2198 {
2199     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
2200
2201     return E_NOTIMPL;
2202 }
2203
2204 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElementWide(IDebugSymbols3 *iface, ULONG index,
2205         WCHAR *buffer, ULONG buffer_size, ULONG *element_size)
2206 {
2207     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, element_size);
2208
2209     return E_NOTIMPL;
2210 }
2211
2212 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePathWide(IDebugSymbols3 *iface, const WCHAR *path)
2213 {
2214     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2215
2216     return E_NOTIMPL;
2217 }
2218
2219 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2220 {
2221     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2222
2223     return E_NOTIMPL;
2224 }
2225
2226 static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFileWide(IDebugSymbols3 *iface, ULONG start_element,
2227         const WCHAR *file, ULONG flags, ULONG *found_element, WCHAR *buffer, ULONG buffer_size, ULONG *found_size)
2228 {
2229     FIXME("%p, %lu, %s, %#lx, %p, %p, %lu, %p stub.\n", iface, start_element, debugstr_w(file), flags, found_element,
2230             buffer, buffer_size, found_size);
2231
2232     return E_NOTIMPL;
2233 }
2234
2235 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsetsWide(IDebugSymbols3 *iface, const WCHAR *file,
2236         ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
2237 {
2238     FIXME("%p, %s, %p, %lu, %p stub.\n", iface, debugstr_w(file), buffer, buffer_lines, file_lines);
2239
2240     return E_NOTIMPL;
2241 }
2242
2243 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleVersionInformationWide(IDebugSymbols3 *iface, ULONG index,
2244         ULONG64 base, const WCHAR *item, void *buffer, ULONG buffer_size, ULONG *version_info_size)
2245 {
2246     FIXME("%p, %lu, %s, %s, %p, %lu, %p stub.\n", iface, index, wine_dbgstr_longlong(base), debugstr_w(item), buffer,
2247             buffer_size, version_info_size);
2248
2249     return E_NOTIMPL;
2250 }
2251
2252 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameStringWide(IDebugSymbols3 *iface, ULONG which, ULONG index,
2253         ULONG64 base, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2254 {
2255     FIXME("%p, %lu, %lu, %s, %p, %lu, %p stub.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
2256             name_size);
2257
2258     return E_NOTIMPL;
2259 }
2260
2261 static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2262         ULONG64 value, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2263 {
2264     FIXME("%p, %s, %lu, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
2265             wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
2266
2267     return E_NOTIMPL;
2268 }
2269
2270 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2271         ULONG field_index, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2272 {
2273     FIXME("%p, %s, %lu, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
2274             buffer_size, name_size);
2275
2276     return E_NOTIMPL;
2277 }
2278
2279 static HRESULT STDMETHODCALLTYPE debugsymbols_IsManagedModule(IDebugSymbols3 *iface, ULONG index, ULONG64 base)
2280 {
2281     FIXME("%p, %lu, %s stub.\n", iface, index, wine_dbgstr_longlong(base));
2282
2283     return E_NOTIMPL;
2284 }
2285
2286 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2(IDebugSymbols3 *iface, const char *name,
2287         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2288 {
2289     FIXME("%p, %s, %lu, %#lx, %p, %p stub.\n", iface, debugstr_a(name), start_index, flags, index, base);
2290
2291     return E_NOTIMPL;
2292 }
2293
2294 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2Wide(IDebugSymbols3 *iface, const WCHAR *name,
2295         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2296 {
2297     FIXME("%p, %s, %lu, %#lx, %p, %p stub.\n", iface, debugstr_w(name), start_index, flags, index, base);
2298
2299     return E_NOTIMPL;
2300 }
2301
2302 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset2(IDebugSymbols3 *iface, ULONG64 offset,
2303         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2304 {
2305     FIXME("%p, %s, %lu, %#lx, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), start_index, flags, index, base);
2306
2307     return E_NOTIMPL;
2308 }
2309
2310 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModule(IDebugSymbols3 *iface, ULONG64 base, ULONG size,
2311         const char *image_path, const char *module_name, ULONG flags)
2312 {
2313     FIXME("%p, %s, %lu, %s, %s, %#lx stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_a(image_path),
2314             debugstr_a(module_name), flags);
2315
2316     return E_NOTIMPL;
2317 }
2318
2319 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModuleWide(IDebugSymbols3 *iface, ULONG64 base, ULONG size,
2320         const WCHAR *image_path, const WCHAR *module_name, ULONG flags)
2321 {
2322     FIXME("%p, %s, %lu, %s, %s, %#lx stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_w(image_path),
2323             debugstr_w(module_name), flags);
2324
2325     return E_NOTIMPL;
2326 }
2327
2328 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticModule(IDebugSymbols3 *iface, ULONG64 base)
2329 {
2330     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(base));
2331
2332     return E_NOTIMPL;
2333 }
2334
2335 static HRESULT STDMETHODCALLTYPE debugsymbols_GetCurrentScopeFrameIndex(IDebugSymbols3 *iface, ULONG *index)
2336 {
2337     FIXME("%p, %p stub.\n", iface, index);
2338
2339     return E_NOTIMPL;
2340 }
2341
2342 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFrameByIndex(IDebugSymbols3 *iface, ULONG index)
2343 {
2344     FIXME("%p, %lu stub.\n", iface, index);
2345
2346     return E_NOTIMPL;
2347 }
2348
2349 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromJitDebugInfo(IDebugSymbols3 *iface, ULONG output_control,
2350         ULONG64 info_offset)
2351 {
2352     FIXME("%p, %lu, %s stub.\n", iface, output_control, wine_dbgstr_longlong(info_offset));
2353
2354     return E_NOTIMPL;
2355 }
2356
2357 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromStoredEvent(IDebugSymbols3 *iface)
2358 {
2359     FIXME("%p stub.\n", iface);
2360
2361     return E_NOTIMPL;
2362 }
2363
2364 static HRESULT STDMETHODCALLTYPE debugsymbols_OutputSymbolByOffset(IDebugSymbols3 *iface, ULONG output_control,
2365         ULONG flags, ULONG64 offset)
2366 {
2367     FIXME("%p, %lu, %#lx, %s stub.\n", iface, output_control, flags, wine_dbgstr_longlong(offset));
2368
2369     return E_NOTIMPL;
2370 }
2371
2372 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFunctionEntryByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2373         ULONG flags, void *buffer, ULONG buffer_size, ULONG *needed_size)
2374 {
2375     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
2376             needed_size);
2377
2378     return E_NOTIMPL;
2379 }
2380
2381 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffset(IDebugSymbols3 *iface, ULONG64 module,
2382         ULONG container_type_id, const char *field, ULONG *field_type_id, ULONG *offset)
2383 {
2384     FIXME("%p, %s, %lu, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_a(field),
2385             field_type_id, offset);
2386
2387     return E_NOTIMPL;
2388 }
2389
2390 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffsetWide(IDebugSymbols3 *iface, ULONG64 module,
2391         ULONG container_type_id, const WCHAR *field, ULONG *field_type_id, ULONG *offset)
2392 {
2393     FIXME("%p, %s, %lu, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_w(field),
2394             field_type_id, offset);
2395
2396     return E_NOTIMPL;
2397 }
2398
2399 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbol(IDebugSymbols3 *iface, ULONG64 offset, ULONG size,
2400         const char *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
2401 {
2402     FIXME("%p, %s, %lu, %s, %#lx, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_a(name), flags, id);
2403
2404     return E_NOTIMPL;
2405 }
2406
2407 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbolWide(IDebugSymbols3 *iface, ULONG64 offset, ULONG size,
2408         const WCHAR *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
2409 {
2410     FIXME("%p, %s, %lu, %s, %#lx, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_w(name), flags, id);
2411
2412     return E_NOTIMPL;
2413 }
2414
2415 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticSymbol(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id)
2416 {
2417     FIXME("%p, %p stub.\n", iface, id);
2418
2419     return E_NOTIMPL;
2420 }
2421
2422 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2423         ULONG flags, DEBUG_MODULE_AND_ID *ids, LONG64 *displacements, ULONG count, ULONG *entries)
2424 {
2425     FIXME("%p, %s, %#lx, %p, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, ids, displacements, count,
2426             entries);
2427
2428     return E_NOTIMPL;
2429 }
2430
2431 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByName(IDebugSymbols3 *iface, const char *symbol,
2432         ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
2433 {
2434     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, debugstr_a(symbol), flags, ids, count, entries);
2435
2436     return E_NOTIMPL;
2437 }
2438
2439 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2440         ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
2441 {
2442     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, debugstr_w(symbol), flags, ids, count, entries);
2443
2444     return E_NOTIMPL;
2445 }
2446
2447 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryByToken(IDebugSymbols3 *iface, ULONG64 base, ULONG token,
2448         DEBUG_MODULE_AND_ID *id)
2449 {
2450     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), id);
2451
2452     return E_NOTIMPL;
2453 }
2454
2455 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryInformation(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2456         DEBUG_SYMBOL_ENTRY *info)
2457 {
2458     FIXME("%p, %p, %p stub.\n", iface, id, info);
2459
2460     return E_NOTIMPL;
2461 }
2462
2463 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryString(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2464         ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
2465 {
2466     FIXME("%p, %p, %lu, %p, %lu, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
2467
2468     return E_NOTIMPL;
2469 }
2470
2471 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryStringWide(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2472         ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
2473 {
2474     FIXME("%p, %p, %lu, %p, %lu, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
2475
2476     return E_NOTIMPL;
2477 }
2478
2479 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryOffsetRegions(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2480         ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG regions_count, ULONG *regions_avail)
2481 {
2482     FIXME("%p, %p, %#lx, %p, %lu, %p stub.\n", iface, id, flags, regions, regions_count, regions_avail);
2483
2484     return E_NOTIMPL;
2485 }
2486
2487 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryBySymbolEntry(IDebugSymbols3 *iface,
2488         DEBUG_MODULE_AND_ID *from_id, ULONG flags, DEBUG_MODULE_AND_ID *to_id)
2489 {
2490     FIXME("%p, %p, %#lx, %p stub.\n", iface, from_id, flags, to_id);
2491
2492     return E_NOTIMPL;
2493 }
2494
2495 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2496         ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2497 {
2498     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, entries, count, entries_avail);
2499
2500     return E_NOTIMPL;
2501 }
2502
2503 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLine(IDebugSymbols3 *iface, ULONG line,
2504         const char *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2505 {
2506     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, debugstr_a(file), flags, entries, count, entries_avail);
2507
2508     return E_NOTIMPL;
2509 }
2510
2511 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLineWide(IDebugSymbols3 *iface, ULONG line,
2512         const WCHAR *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2513 {
2514     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, debugstr_w(file), flags, entries, count, entries_avail);
2515
2516     return E_NOTIMPL;
2517 }
2518
2519 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryString(IDebugSymbols3 *iface,
2520         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
2521 {
2522     FIXME("%p, %p, %lu, %p, %lu, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
2523
2524     return E_NOTIMPL;
2525 }
2526
2527 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryStringWide(IDebugSymbols3 *iface,
2528         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
2529 {
2530     FIXME("%p, %p, %lu, %p, %lu, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
2531
2532     return E_NOTIMPL;
2533 }
2534
2535 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryOffsetRegions(IDebugSymbols3 *iface,
2536         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG count, ULONG *regions_avail)
2537 {
2538     FIXME("%p, %p, %#lx, %p, %lu, %p stub.\n", iface, entry, flags, regions, count, regions_avail);
2539
2540     return E_NOTIMPL;
2541 }
2542
2543 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryBySourceEntry(IDebugSymbols3 *iface,
2544         DEBUG_SYMBOL_SOURCE_ENTRY *from_entry, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *to_entry)
2545 {
2546     FIXME("%p, %p, %#lx, %p stub.\n", iface, from_entry, flags, to_entry);
2547
2548     return E_NOTIMPL;
2549 }
2550
2551 static const IDebugSymbols3Vtbl debugsymbolsvtbl =
2552 {
2553     debugsymbols_QueryInterface,
2554     debugsymbols_AddRef,
2555     debugsymbols_Release,
2556     debugsymbols_GetSymbolOptions,
2557     debugsymbols_AddSymbolOptions,
2558     debugsymbols_RemoveSymbolOptions,
2559     debugsymbols_SetSymbolOptions,
2560     debugsymbols_GetNameByOffset,
2561     debugsymbols_GetOffsetByName,
2562     debugsymbols_GetNearNameByOffset,
2563     debugsymbols_GetLineByOffset,
2564     debugsymbols_GetOffsetByLine,
2565     debugsymbols_GetNumberModules,
2566     debugsymbols_GetModuleByIndex,
2567     debugsymbols_GetModuleByModuleName,
2568     debugsymbols_GetModuleByOffset,
2569     debugsymbols_GetModuleNames,
2570     debugsymbols_GetModuleParameters,
2571     debugsymbols_GetSymbolModule,
2572     debugsymbols_GetTypeName,
2573     debugsymbols_GetTypeId,
2574     debugsymbols_GetTypeSize,
2575     debugsymbols_GetFieldOffset,
2576     debugsymbols_GetSymbolTypeId,
2577     debugsymbols_GetOffsetTypeId,
2578     debugsymbols_ReadTypedDataVirtual,
2579     debugsymbols_WriteTypedDataVirtual,
2580     debugsymbols_OutputTypedDataVirtual,
2581     debugsymbols_ReadTypedDataPhysical,
2582     debugsymbols_WriteTypedDataPhysical,
2583     debugsymbols_OutputTypedDataPhysical,
2584     debugsymbols_GetScope,
2585     debugsymbols_SetScope,
2586     debugsymbols_ResetScope,
2587     debugsymbols_GetScopeSymbolGroup,
2588     debugsymbols_CreateSymbolGroup,
2589     debugsymbols_StartSymbolMatch,
2590     debugsymbols_GetNextSymbolMatch,
2591     debugsymbols_EndSymbolMatch,
2592     debugsymbols_Reload,
2593     debugsymbols_GetSymbolPath,
2594     debugsymbols_SetSymbolPath,
2595     debugsymbols_AppendSymbolPath,
2596     debugsymbols_GetImagePath,
2597     debugsymbols_SetImagePath,
2598     debugsymbols_AppendImagePath,
2599     debugsymbols_GetSourcePath,
2600     debugsymbols_GetSourcePathElement,
2601     debugsymbols_SetSourcePath,
2602     debugsymbols_AppendSourcePath,
2603     debugsymbols_FindSourceFile,
2604     debugsymbols_GetSourceFileLineOffsets,
2605     /* IDebugSymbols2 */
2606     debugsymbols_GetModuleVersionInformation,
2607     debugsymbols_GetModuleNameString,
2608     debugsymbols_GetConstantName,
2609     debugsymbols_GetFieldName,
2610     debugsymbols_GetTypeOptions,
2611     debugsymbols_AddTypeOptions,
2612     debugsymbols_RemoveTypeOptions,
2613     debugsymbols_SetTypeOptions,
2614     /* IDebugSymbols3 */
2615     debugsymbols_GetNameByOffsetWide,
2616     debugsymbols_GetOffsetByNameWide,
2617     debugsymbols_GetNearNameByOffsetWide,
2618     debugsymbols_GetLineByOffsetWide,
2619     debugsymbols_GetOffsetByLineWide,
2620     debugsymbols_GetModuleByModuleNameWide,
2621     debugsymbols_GetSymbolModuleWide,
2622     debugsymbols_GetTypeNameWide,
2623     debugsymbols_GetTypeIdWide,
2624     debugsymbols_GetFieldOffsetWide,
2625     debugsymbols_GetSymbolTypeIdWide,
2626     debugsymbols_GetScopeSymbolGroup2,
2627     debugsymbols_CreateSymbolGroup2,
2628     debugsymbols_StartSymbolMatchWide,
2629     debugsymbols_GetNextSymbolMatchWide,
2630     debugsymbols_ReloadWide,
2631     debugsymbols_GetSymbolPathWide,
2632     debugsymbols_SetSymbolPathWide,
2633     debugsymbols_AppendSymbolPathWide,
2634     debugsymbols_GetImagePathWide,
2635     debugsymbols_SetImagePathWide,
2636     debugsymbols_AppendImagePathWide,
2637     debugsymbols_GetSourcePathWide,
2638     debugsymbols_GetSourcePathElementWide,
2639     debugsymbols_SetSourcePathWide,
2640     debugsymbols_AppendSourcePathWide,
2641     debugsymbols_FindSourceFileWide,
2642     debugsymbols_GetSourceFileLineOffsetsWide,
2643     debugsymbols_GetModuleVersionInformationWide,
2644     debugsymbols_GetModuleNameStringWide,
2645     debugsymbols_GetConstantNameWide,
2646     debugsymbols_GetFieldNameWide,
2647     debugsymbols_IsManagedModule,
2648     debugsymbols_GetModuleByModuleName2,
2649     debugsymbols_GetModuleByModuleName2Wide,
2650     debugsymbols_GetModuleByOffset2,
2651     debugsymbols_AddSyntheticModule,
2652     debugsymbols_AddSyntheticModuleWide,
2653     debugsymbols_RemoveSyntheticModule,
2654     debugsymbols_GetCurrentScopeFrameIndex,
2655     debugsymbols_SetScopeFrameByIndex,
2656     debugsymbols_SetScopeFromJitDebugInfo,
2657     debugsymbols_SetScopeFromStoredEvent,
2658     debugsymbols_OutputSymbolByOffset,
2659     debugsymbols_GetFunctionEntryByOffset,
2660     debugsymbols_GetFieldTypeAndOffset,
2661     debugsymbols_GetFieldTypeAndOffsetWide,
2662     debugsymbols_AddSyntheticSymbol,
2663     debugsymbols_AddSyntheticSymbolWide,
2664     debugsymbols_RemoveSyntheticSymbol,
2665     debugsymbols_GetSymbolEntriesByOffset,
2666     debugsymbols_GetSymbolEntriesByName,
2667     debugsymbols_GetSymbolEntriesByNameWide,
2668     debugsymbols_GetSymbolEntryByToken,
2669     debugsymbols_GetSymbolEntryInformation,
2670     debugsymbols_GetSymbolEntryString,
2671     debugsymbols_GetSymbolEntryStringWide,
2672     debugsymbols_GetSymbolEntryOffsetRegions,
2673     debugsymbols_GetSymbolEntryBySymbolEntry,
2674     debugsymbols_GetSourceEntriesByOffset,
2675     debugsymbols_GetSourceEntriesByLine,
2676     debugsymbols_GetSourceEntriesByLineWide,
2677     debugsymbols_GetSourceEntryString,
2678     debugsymbols_GetSourceEntryStringWide,
2679     debugsymbols_GetSourceEntryOffsetRegions,
2680     debugsymbols_GetSourceEntryBySourceEntry,
2681 };
2682
2683 static HRESULT STDMETHODCALLTYPE debugcontrol_QueryInterface(IDebugControl4 *iface, REFIID riid, void **obj)
2684 {
2685     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2686     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2687     return IUnknown_QueryInterface(unk, riid, obj);
2688 }
2689
2690 static ULONG STDMETHODCALLTYPE debugcontrol_AddRef(IDebugControl4 *iface)
2691 {
2692     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2693     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2694     return IUnknown_AddRef(unk);
2695 }
2696
2697 static ULONG STDMETHODCALLTYPE debugcontrol_Release(IDebugControl4 *iface)
2698 {
2699     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2700     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2701     return IUnknown_Release(unk);
2702 }
2703
2704 static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterrupt(IDebugControl4 *iface)
2705 {
2706     FIXME("%p stub.\n", iface);
2707
2708     return E_NOTIMPL;
2709 }
2710
2711 static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterrupt(IDebugControl4 *iface, ULONG flags)
2712 {
2713     FIXME("%p, %#lx stub.\n", iface, flags);
2714
2715     return E_NOTIMPL;
2716 }
2717
2718 static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterruptTimeout(IDebugControl4 *iface, ULONG *timeout)
2719 {
2720     FIXME("%p, %p stub.\n", iface, timeout);
2721
2722     return E_NOTIMPL;
2723 }
2724
2725 static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterruptTimeout(IDebugControl4 *iface, ULONG timeout)
2726 {
2727     FIXME("%p, %lu stub.\n", iface, timeout);
2728
2729     return E_NOTIMPL;
2730 }
2731
2732 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
2733         ULONG *file_size, BOOL *append)
2734 {
2735     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
2736
2737     return E_NOTIMPL;
2738 }
2739
2740 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile(IDebugControl4 *iface, const char *file, BOOL append)
2741 {
2742     FIXME("%p, %s, %d stub.\n", iface, debugstr_a(file), append);
2743
2744     return E_NOTIMPL;
2745 }
2746 static HRESULT STDMETHODCALLTYPE debugcontrol_CloseLogFile(IDebugControl4 *iface)
2747 {
2748     FIXME("%p stub.\n", iface);
2749
2750     return E_NOTIMPL;
2751 }
2752 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogMask(IDebugControl4 *iface, ULONG *mask)
2753 {
2754     FIXME("%p, %p stub.\n", iface, mask);
2755
2756     return E_NOTIMPL;
2757 }
2758
2759 static HRESULT STDMETHODCALLTYPE debugcontrol_SetLogMask(IDebugControl4 *iface, ULONG mask)
2760 {
2761     FIXME("%p, %#lx stub.\n", iface, mask);
2762
2763     return E_NOTIMPL;
2764 }
2765
2766 static HRESULT STDMETHODCALLTYPE debugcontrol_Input(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
2767         ULONG *input_size)
2768 {
2769     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, input_size);
2770
2771     return E_NOTIMPL;
2772 }
2773
2774 static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInput(IDebugControl4 *iface, const char *buffer)
2775 {
2776     FIXME("%p, %s stub.\n", iface, debugstr_a(buffer));
2777
2778     return E_NOTIMPL;
2779 }
2780
2781 static HRESULT STDMETHODVCALLTYPE debugcontrol_Output(IDebugControl4 *iface, ULONG mask, const char *format, ...)
2782 {
2783     FIXME("%p, %#lx, %s stub.\n", iface, mask, debugstr_a(format));
2784
2785     return E_NOTIMPL;
2786 }
2787
2788 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl4 *iface, ULONG mask, const char *format,
2789         va_list args)
2790 {
2791     FIXME("%p, %#lx, %s stub.\n", iface, mask, debugstr_a(format));
2792
2793     return E_NOTIMPL;
2794 }
2795
2796 static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl4 *iface, ULONG output_control,
2797         ULONG mask, const char *format, ...)
2798 {
2799     FIXME("%p, %lu, %#lx, %s stub.\n", iface, output_control, mask, debugstr_a(format));
2800
2801     return E_NOTIMPL;
2802 }
2803
2804 static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugControl4 *iface, ULONG output_control,
2805         ULONG mask, const char *format, va_list args)
2806 {
2807     FIXME("%p, %lu, %#lx, %s stub.\n", iface, output_control, mask, debugstr_a(format));
2808
2809     return E_NOTIMPL;
2810 }
2811
2812 static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl4 *iface, ULONG output_control,
2813         const char *format, ...)
2814 {
2815     FIXME("%p, %lu, %s stub.\n", iface, output_control, debugstr_a(format));
2816
2817     return E_NOTIMPL;
2818 }
2819
2820 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl4 *iface, ULONG output_control,
2821         const char *format, va_list args)
2822 {
2823     FIXME("%p, %lu, %s stub.\n", iface, output_control, debugstr_a(format));
2824
2825     return E_NOTIMPL;
2826 }
2827
2828 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptText(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
2829         ULONG *text_size)
2830 {
2831     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, text_size);
2832
2833     return E_NOTIMPL;
2834 }
2835
2836 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl4 *iface, ULONG output_control,
2837         ULONG flags)
2838 {
2839     FIXME("%p, %lu, %#lx stub.\n", iface, output_control, flags);
2840
2841     return E_NOTIMPL;
2842 }
2843
2844 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVersionInformation(IDebugControl4 *iface, ULONG output_control)
2845 {
2846     FIXME("%p, %lu stub.\n", iface, output_control);
2847
2848     return E_NOTIMPL;
2849 }
2850
2851 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNotifyEventHandle(IDebugControl4 *iface, ULONG64 *handle)
2852 {
2853     FIXME("%p, %p stub.\n", iface, handle);
2854
2855     return E_NOTIMPL;
2856 }
2857
2858 static HRESULT STDMETHODCALLTYPE debugcontrol_SetNotifyEventHandle(IDebugControl4 *iface, ULONG64 handle)
2859 {
2860     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
2861
2862     return E_NOTIMPL;
2863 }
2864
2865 static HRESULT STDMETHODCALLTYPE debugcontrol_Assemble(IDebugControl4 *iface, ULONG64 offset, const char *code,
2866         ULONG64 *end_offset)
2867 {
2868     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), debugstr_a(code), end_offset);
2869
2870     return E_NOTIMPL;
2871 }
2872
2873 static HRESULT STDMETHODCALLTYPE debugcontrol_Disassemble(IDebugControl4 *iface, ULONG64 offset, ULONG flags,
2874         char *buffer, ULONG buffer_size, ULONG *disassm_size, ULONG64 *end_offset)
2875 {
2876     FIXME("%p, %s, %#lx, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
2877             disassm_size, end_offset);
2878
2879     return E_NOTIMPL;
2880 }
2881
2882 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDisassembleEffectiveOffset(IDebugControl4 *iface, ULONG64 *offset)
2883 {
2884     FIXME("%p, %p stub.\n", iface, offset);
2885
2886     return E_NOTIMPL;
2887 }
2888
2889 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl4 *iface, ULONG output_control,
2890         ULONG64 offset, ULONG flags, ULONG64 *end_offset)
2891 {
2892     FIXME("%p, %lu, %s, %#lx, %p stub.\n", iface, output_control, wine_dbgstr_longlong(offset), flags, end_offset);
2893
2894     return E_NOTIMPL;
2895 }
2896
2897 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugControl4 *iface, ULONG output_control,
2898         ULONG prev_lines, ULONG total_lines, ULONG64 offset, ULONG flags, ULONG *offset_line, ULONG64 *start_offset,
2899         ULONG64 *end_offset, ULONG64 *line_offsets)
2900 {
2901     FIXME("%p, %lu, %lu, %lu, %s, %#lx, %p, %p, %p, %p stub.\n", iface, output_control, prev_lines, total_lines,
2902             wine_dbgstr_longlong(offset), flags, offset_line, start_offset, end_offset, line_offsets);
2903
2904     return E_NOTIMPL;
2905 }
2906
2907 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNearInstruction(IDebugControl4 *iface, ULONG64 offset, LONG delta,
2908         ULONG64 *instr_offset)
2909 {
2910     FIXME("%p, %s, %ld, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, instr_offset);
2911
2912     return E_NOTIMPL;
2913 }
2914
2915 static HRESULT STDMETHODCALLTYPE debugcontrol_GetStackTrace(IDebugControl4 *iface, ULONG64 frame_offset,
2916         ULONG64 stack_offset, ULONG64 instr_offset, DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG *frames_filled)
2917 {
2918     FIXME("%p, %s, %s, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(frame_offset),
2919             wine_dbgstr_longlong(stack_offset), wine_dbgstr_longlong(instr_offset), frames, frames_size, frames_filled);
2920
2921     return E_NOTIMPL;
2922 }
2923
2924 static HRESULT STDMETHODCALLTYPE debugcontrol_GetReturnOffset(IDebugControl4 *iface, ULONG64 *offset)
2925 {
2926     FIXME("%p, %p stub.\n", iface, offset);
2927
2928     return E_NOTIMPL;
2929 }
2930
2931 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl4 *iface, ULONG output_control,
2932         DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG flags)
2933 {
2934     FIXME("%p, %lu, %p, %lu, %#lx stub.\n", iface, output_control, frames, frames_size, flags);
2935
2936     return E_NOTIMPL;
2937 }
2938
2939 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl4 *iface, ULONG *debug_class,
2940         ULONG *qualifier)
2941 {
2942     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2943     static struct target_process *target;
2944
2945     FIXME("%p, %p, %p stub.\n", iface, debug_class, qualifier);
2946
2947     *debug_class = DEBUG_CLASS_UNINITIALIZED;
2948     *qualifier = 0;
2949
2950     if (!(target = debug_client_get_target(debug_client)))
2951         return E_UNEXPECTED;
2952
2953     *debug_class = DEBUG_CLASS_USER_WINDOWS;
2954     *qualifier = DEBUG_USER_WINDOWS_PROCESS;
2955
2956     return S_OK;
2957 }
2958
2959 static HRESULT STDMETHODCALLTYPE debugcontrol_GetActualProcessorType(IDebugControl4 *iface, ULONG *type)
2960 {
2961     FIXME("%p, %p stub.\n", iface, type);
2962
2963     return E_NOTIMPL;
2964 }
2965
2966 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutingProcessorType(IDebugControl4 *iface, ULONG *type)
2967 {
2968     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2969     static struct target_process *target;
2970     HRESULT hr;
2971
2972     TRACE("%p, %p.\n", iface, type);
2973
2974     if (!(target = debug_client_get_target(debug_client)))
2975         return E_UNEXPECTED;
2976
2977     if (FAILED(hr = debug_target_init_modules_info(target)))
2978         return hr;
2979
2980     *type = target->cpu_type;
2981
2982     return S_OK;
2983 }
2984
2985 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberPossibleExecutingProcessorTypes(IDebugControl4 *iface,
2986         ULONG *count)
2987 {
2988     FIXME("%p, %p stub.\n", iface, count);
2989
2990     return E_NOTIMPL;
2991 }
2992
2993 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPossibleExecutingProcessorTypes(IDebugControl4 *iface, ULONG start,
2994         ULONG count, ULONG *types)
2995 {
2996     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, types);
2997
2998     return E_NOTIMPL;
2999 }
3000
3001 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberProcessors(IDebugControl4 *iface, ULONG *count)
3002 {
3003     FIXME("%p, %p stub.\n", iface, count);
3004
3005     return E_NOTIMPL;
3006 }
3007
3008 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersion(IDebugControl4 *iface, ULONG *platform_id, ULONG *major,
3009         ULONG *minor, char *sp_string, ULONG sp_string_size, ULONG *sp_string_used, ULONG *sp_number,
3010         char *build_string, ULONG build_string_size, ULONG *build_string_used)
3011 {
3012     FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %p, %lu, %p stub.\n", iface, platform_id, major, minor, sp_string,
3013             sp_string_size, sp_string_used, sp_number, build_string, build_string_size, build_string_used);
3014
3015     return E_NOTIMPL;
3016 }
3017
3018 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPageSize(IDebugControl4 *iface, ULONG *size)
3019 {
3020     FIXME("%p, %p stub.\n", iface, size);
3021
3022     return E_NOTIMPL;
3023 }
3024
3025 static HRESULT STDMETHODCALLTYPE debugcontrol_IsPointer64Bit(IDebugControl4 *iface)
3026 {
3027     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3028     static struct target_process *target;
3029     HRESULT hr;
3030
3031     TRACE("%p.\n", iface);
3032
3033     if (!(target = debug_client_get_target(debug_client)))
3034         return E_UNEXPECTED;
3035
3036     if (FAILED(hr = debug_target_init_modules_info(target)))
3037         return hr;
3038
3039     switch (target->cpu_type)
3040     {
3041         case IMAGE_FILE_MACHINE_I386:
3042         case IMAGE_FILE_MACHINE_ARMNT:
3043             hr = S_FALSE;
3044             break;
3045         case IMAGE_FILE_MACHINE_IA64:
3046         case IMAGE_FILE_MACHINE_AMD64:
3047         case IMAGE_FILE_MACHINE_ARM64:
3048             hr = S_OK;
3049             break;
3050         default:
3051             FIXME("Unexpected cpu type %#lx.\n", target->cpu_type);
3052             hr = E_UNEXPECTED;
3053     }
3054
3055     return hr;
3056 }
3057
3058 static HRESULT STDMETHODCALLTYPE debugcontrol_ReadBugCheckData(IDebugControl4 *iface, ULONG *code, ULONG64 *arg1,
3059         ULONG64 *arg2, ULONG64 *arg3, ULONG64 *arg4)
3060 {
3061     FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, code, arg1, arg2, arg3, arg4);
3062
3063     return E_NOTIMPL;
3064 }
3065
3066 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberSupportedProcessorTypes(IDebugControl4 *iface, ULONG *count)
3067 {
3068     FIXME("%p, %p stub.\n", iface, count);
3069
3070     return E_NOTIMPL;
3071 }
3072
3073 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSupportedProcessorTypes(IDebugControl4 *iface, ULONG start,
3074         ULONG count, ULONG *types)
3075 {
3076     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, types);
3077
3078     return E_NOTIMPL;
3079 }
3080
3081 static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugControl4 *iface, ULONG type, char *full_name,
3082         ULONG full_name_buffer_size, ULONG *full_name_size, char *abbrev_name, ULONG abbrev_name_buffer_size,
3083         ULONG *abbrev_name_size)
3084 {
3085     FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, full_name, full_name_buffer_size, full_name_size,
3086             abbrev_name, abbrev_name_buffer_size, abbrev_name_size);
3087
3088     return E_NOTIMPL;
3089 }
3090
3091 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEffectiveProcessorType(IDebugControl4 *iface, ULONG *type)
3092 {
3093     FIXME("%p, %p stub.\n", iface, type);
3094
3095     return E_NOTIMPL;
3096 }
3097
3098 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEffectiveProcessorType(IDebugControl4 *iface, ULONG type)
3099 {
3100     FIXME("%p, %lu stub.\n", iface, type);
3101
3102     return E_NOTIMPL;
3103 }
3104
3105 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutionStatus(IDebugControl4 *iface, ULONG *status)
3106 {
3107     FIXME("%p, %p stub.\n", iface, status);
3108
3109     return E_NOTIMPL;
3110 }
3111
3112 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExecutionStatus(IDebugControl4 *iface, ULONG status)
3113 {
3114     FIXME("%p, %lu stub.\n", iface, status);
3115
3116     return E_NOTIMPL;
3117 }
3118
3119 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCodeLevel(IDebugControl4 *iface, ULONG *level)
3120 {
3121     FIXME("%p, %p stub.\n", iface, level);
3122
3123     return E_NOTIMPL;
3124 }
3125
3126 static HRESULT STDMETHODCALLTYPE debugcontrol_SetCodeLevel(IDebugControl4 *iface, ULONG level)
3127 {
3128     FIXME("%p, %lu stub.\n", iface, level);
3129
3130     return E_NOTIMPL;
3131 }
3132
3133 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEngineOptions(IDebugControl4 *iface, ULONG *options)
3134 {
3135     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3136
3137     TRACE("%p, %p.\n", iface, options);
3138
3139     *options = debug_client->engine_options;
3140
3141     return S_OK;
3142 }
3143
3144 static HRESULT STDMETHODCALLTYPE debugcontrol_AddEngineOptions(IDebugControl4 *iface, ULONG options)
3145 {
3146     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3147
3148     TRACE("%p, %#lx.\n", iface, options);
3149
3150     if (options & ~DEBUG_ENGOPT_ALL)
3151         return E_INVALIDARG;
3152
3153     debug_client->engine_options |= options;
3154
3155     return S_OK;
3156 }
3157
3158 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveEngineOptions(IDebugControl4 *iface, ULONG options)
3159 {
3160     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3161
3162     TRACE("%p, %#lx.\n", iface, options);
3163
3164     debug_client->engine_options &= ~options;
3165
3166     return S_OK;
3167 }
3168
3169 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEngineOptions(IDebugControl4 *iface, ULONG options)
3170 {
3171     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3172
3173     TRACE("%p, %#lx.\n", iface, options);
3174
3175     if (options & ~DEBUG_ENGOPT_ALL)
3176         return E_INVALIDARG;
3177
3178     debug_client->engine_options = options;
3179
3180     return S_OK;
3181 }
3182
3183 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugControl4 *iface, ULONG *output_level,
3184         ULONG *break_level)
3185 {
3186     FIXME("%p, %p, %p stub.\n", iface, output_level, break_level);
3187
3188     return E_NOTIMPL;
3189 }
3190
3191 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugControl4 *iface, ULONG output_level,
3192         ULONG break_level)
3193 {
3194     FIXME("%p, %lu, %lu stub.\n", iface, output_level, break_level);
3195
3196     return E_NOTIMPL;
3197 }
3198
3199 static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacro(IDebugControl4 *iface, ULONG slot, char *buffer,
3200         ULONG buffer_size, ULONG *macro_size)
3201 {
3202     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
3203
3204     return E_NOTIMPL;
3205 }
3206
3207 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacro(IDebugControl4 *iface, ULONG slot, const char *macro)
3208 {
3209     FIXME("%p, %lu, %s stub.\n", iface, slot, debugstr_a(macro));
3210
3211     return E_NOTIMPL;
3212 }
3213
3214 static HRESULT STDMETHODCALLTYPE debugcontrol_GetRadix(IDebugControl4 *iface, ULONG *radix)
3215 {
3216     FIXME("%p, %p stub.\n", iface, radix);
3217
3218     return E_NOTIMPL;
3219 }
3220
3221 static HRESULT STDMETHODCALLTYPE debugcontrol_SetRadix(IDebugControl4 *iface, ULONG radix)
3222 {
3223     FIXME("%p, %lu stub.\n", iface, radix);
3224
3225     return E_NOTIMPL;
3226 }
3227
3228 static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl4 *iface, const char *expression,
3229         ULONG desired_type, DEBUG_VALUE *value, ULONG *remainder_index)
3230 {
3231     FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_a(expression), desired_type, value, remainder_index);
3232
3233     return E_NOTIMPL;
3234 }
3235
3236 static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValue(IDebugControl4 *iface, DEBUG_VALUE input, ULONG output_type,
3237         DEBUG_VALUE *output)
3238 {
3239     FIXME("%p, %lu, %p stub.\n", iface, output_type, output);
3240
3241     return E_NOTIMPL;
3242 }
3243
3244 static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValues(IDebugControl4 *iface, ULONG count, DEBUG_VALUE *input,
3245         ULONG *output_types, DEBUG_VALUE *output)
3246 {
3247     FIXME("%p, %lu, %p, %p, %p stub.\n", iface, count, input, output_types, output);
3248
3249     return E_NOTIMPL;
3250 }
3251
3252 static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl4 *iface, ULONG output_control, const char *command,
3253         ULONG flags)
3254 {
3255     FIXME("%p, %lu, %s, %#lx stub.\n", iface, output_control, debugstr_a(command), flags);
3256
3257     return E_NOTIMPL;
3258 }
3259
3260 static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl4 *iface, ULONG output_control,
3261         const char *command_file, ULONG flags)
3262 {
3263     FIXME("%p, %lu, %s, %#lx stub.\n", iface, output_control, debugstr_a(command_file), flags);
3264
3265     return E_NOTIMPL;
3266 }
3267
3268 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberBreakpoints(IDebugControl4 *iface, ULONG *count)
3269 {
3270     FIXME("%p, %p stub.\n", iface, count);
3271
3272     return E_NOTIMPL;
3273 }
3274
3275 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex(IDebugControl4 *iface, ULONG index,
3276         IDebugBreakpoint **bp)
3277 {
3278     FIXME("%p, %lu, %p stub.\n", iface, index, bp);
3279
3280     return E_NOTIMPL;
3281 }
3282
3283 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById(IDebugControl4 *iface, ULONG id, IDebugBreakpoint **bp)
3284 {
3285     FIXME("%p, %lu, %p stub.\n", iface, id, bp);
3286
3287     return E_NOTIMPL;
3288 }
3289
3290 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointParameters(IDebugControl4 *iface, ULONG count, ULONG *ids,
3291         ULONG start, DEBUG_BREAKPOINT_PARAMETERS *parameters)
3292 {
3293     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, count, ids, start, parameters);
3294
3295     return E_NOTIMPL;
3296 }
3297
3298 static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl4 *iface, ULONG type, ULONG desired_id,
3299         IDebugBreakpoint **bp)
3300 {
3301     FIXME("%p, %lu, %lu, %p stub.\n", iface, type, desired_id, bp);
3302
3303     return E_NOTIMPL;
3304 }
3305
3306 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint(IDebugControl4 *iface, IDebugBreakpoint *bp)
3307 {
3308     FIXME("%p, %p stub.\n", iface, bp);
3309
3310     return E_NOTIMPL;
3311 }
3312
3313 static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtension(IDebugControl4 *iface, const char *path, ULONG flags,
3314         ULONG64 *handle)
3315 {
3316     FIXME("%p, %s, %#lx, %p stub.\n", iface, debugstr_a(path), flags, handle);
3317
3318     return E_NOTIMPL;
3319 }
3320
3321 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveExtension(IDebugControl4 *iface, ULONG64 handle)
3322 {
3323     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
3324
3325     return E_NOTIMPL;
3326 }
3327
3328 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPath(IDebugControl4 *iface, const char *path,
3329         ULONG64 *handle)
3330 {
3331     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(path), handle);
3332
3333     return E_NOTIMPL;
3334 }
3335
3336 static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtension(IDebugControl4 *iface, ULONG64 handle,
3337         const char *function, const char *args)
3338 {
3339     FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(function), debugstr_a(args));
3340
3341     return E_NOTIMPL;
3342 }
3343
3344 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunction(IDebugControl4 *iface, ULONG64 handle,
3345         const char *name, void *function)
3346 {
3347     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(name), function);
3348
3349     return E_NOTIMPL;
3350 }
3351
3352 static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis32(IDebugControl4 *iface,
3353         PWINDBG_EXTENSION_APIS32 api)
3354 {
3355     FIXME("%p, %p stub.\n", iface, api);
3356
3357     return E_NOTIMPL;
3358 }
3359
3360 static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis64(IDebugControl4 *iface,
3361         PWINDBG_EXTENSION_APIS64 api)
3362 {
3363     FIXME("%p, %p stub.\n", iface, api);
3364
3365     return E_NOTIMPL;
3366 }
3367
3368 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugControl4 *iface, ULONG *specific_events,
3369         ULONG *specific_exceptions, ULONG *arbitrary_exceptions)
3370 {
3371     FIXME("%p, %p, %p, %p stub.\n", iface, specific_events, specific_exceptions, arbitrary_exceptions);
3372
3373     return E_NOTIMPL;
3374 }
3375
3376 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterText(IDebugControl4 *iface, ULONG index, char *buffer,
3377         ULONG buffer_size, ULONG *text_size)
3378 {
3379     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, text_size);
3380
3381     return E_NOTIMPL;
3382 }
3383
3384 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommand(IDebugControl4 *iface, ULONG index, char *buffer,
3385         ULONG buffer_size, ULONG *command_size)
3386 {
3387     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3388
3389     return E_NOTIMPL;
3390 }
3391
3392 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommand(IDebugControl4 *iface, ULONG index,
3393         const char *command)
3394 {
3395     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(command));
3396
3397     return E_NOTIMPL;
3398 }
3399
3400 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterParameters(IDebugControl4 *iface, ULONG start,
3401         ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
3402 {
3403     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, parameters);
3404
3405     return E_NOTIMPL;
3406 }
3407
3408 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterParameters(IDebugControl4 *iface, ULONG start,
3409         ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
3410 {
3411     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, parameters);
3412
3413     return E_NOTIMPL;
3414 }
3415
3416 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgument(IDebugControl4 *iface, ULONG index,
3417         char *buffer, ULONG buffer_size, ULONG *argument_size)
3418 {
3419     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
3420
3421     return E_NOTIMPL;
3422 }
3423
3424 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgument(IDebugControl4 *iface, ULONG index,
3425         const char *argument)
3426 {
3427     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(argument));
3428
3429     return E_NOTIMPL;
3430 }
3431
3432 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterParameters(IDebugControl4 *iface, ULONG count,
3433         ULONG *codes, ULONG start, DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
3434 {
3435     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, count, codes, start, parameters);
3436
3437     return E_NOTIMPL;
3438 }
3439
3440 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterParameters(IDebugControl4 *iface, ULONG count,
3441         DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
3442 {
3443     FIXME("%p, %lu, %p stub.\n", iface, count, parameters);
3444
3445     return E_NOTIMPL;
3446 }
3447
3448 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterSecondCommand(IDebugControl4 *iface, ULONG index,
3449         char *buffer, ULONG buffer_size, ULONG *command_size)
3450 {
3451     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3452
3453     return E_NOTIMPL;
3454 }
3455
3456 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterSecondCommand(IDebugControl4 *iface, ULONG index,
3457         const char *command)
3458 {
3459     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(command));
3460
3461     return E_NOTIMPL;
3462 }
3463
3464 static HRESULT STDMETHODCALLTYPE debugcontrol_WaitForEvent(IDebugControl4 *iface, ULONG flags, ULONG timeout)
3465 {
3466     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3467     struct target_process *target;
3468
3469     TRACE("%p, %#lx, %lu.\n", iface, flags, timeout);
3470
3471     /* FIXME: only one target is used currently */
3472
3473     if (!(target = debug_client_get_target(debug_client)))
3474         return E_UNEXPECTED;
3475
3476     if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
3477     {
3478         BOOL suspend = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
3479         DWORD access = PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_LIMITED_INFORMATION;
3480         NTSTATUS status;
3481
3482         if (suspend)
3483             access |= PROCESS_SUSPEND_RESUME;
3484
3485         target->handle = OpenProcess(access, FALSE, target->pid);
3486         if (!target->handle)
3487         {
3488             WARN("Failed to get process handle for pid %#x.\n", target->pid);
3489             return E_UNEXPECTED;
3490         }
3491
3492         if (suspend)
3493         {
3494             status = NtSuspendProcess(target->handle);
3495             if (status)
3496                 WARN("Failed to suspend a process, status %#lx.\n", status);
3497         }
3498
3499         return S_OK;
3500     }
3501     else
3502     {
3503         FIXME("Unsupported attach flags %#x.\n", target->attach_flags);
3504     }
3505
3506     return E_NOTIMPL;
3507 }
3508
3509 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformation(IDebugControl4 *iface, ULONG *type, ULONG *pid,
3510         ULONG *tid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, char *description,
3511         ULONG desc_size, ULONG *desc_used)
3512 {
3513     FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, pid, tid, extra_info, extra_info_size,
3514             extra_info_used, description, desc_size, desc_used);
3515
3516     return E_NOTIMPL;
3517 }
3518
3519 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentTimeDate(IDebugControl4 *iface, ULONG timedate)
3520 {
3521     FIXME("%p, %lu stub.\n", iface, timedate);
3522
3523     return E_NOTIMPL;
3524 }
3525
3526 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentSystemUpTime(IDebugControl4 *iface, ULONG uptime)
3527 {
3528     FIXME("%p, %lu stub.\n", iface, uptime);
3529
3530     return E_NOTIMPL;
3531 }
3532
3533 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDumpFormatFlags(IDebugControl4 *iface, ULONG *flags)
3534 {
3535     FIXME("%p, %p stub.\n", iface, flags);
3536
3537     return E_NOTIMPL;
3538 }
3539
3540 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextPlacements(IDebugControl4 *iface, ULONG *count)
3541 {
3542     FIXME("%p, %p stub.\n", iface, count);
3543
3544     return E_NOTIMPL;
3545 }
3546
3547 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextReplacement(IDebugControl4 *iface, const char *src_text,
3548         ULONG index, char *src_buffer, ULONG src_buffer_size, ULONG *src_size, char *dst_buffer,
3549         ULONG dst_buffer_size, ULONG *dst_size)
3550 {
3551     FIXME("%p, %s, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, debugstr_a(src_text), index, src_buffer,
3552             src_buffer_size, src_size, dst_buffer, dst_buffer_size, dst_size);
3553
3554     return E_NOTIMPL;
3555 }
3556
3557 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacement(IDebugControl4 *iface, const char *src_text,
3558         const char *dst_text)
3559 {
3560     FIXME("%p, %s, %s stub.\n", iface, debugstr_a(src_text), debugstr_a(dst_text));
3561
3562     return E_NOTIMPL;
3563 }
3564
3565 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveTextReplacements(IDebugControl4 *iface)
3566 {
3567     FIXME("%p stub.\n", iface);
3568
3569     return E_NOTIMPL;
3570 }
3571
3572 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputTextReplacements(IDebugControl4 *iface, ULONG output_control,
3573         ULONG flags)
3574 {
3575     FIXME("%p, %lu, %#lx stub.\n", iface, output_control, flags);
3576
3577     return E_NOTIMPL;
3578 }
3579
3580 static HRESULT STDMETHODCALLTYPE debugcontrol_GetAssemblyOptions(IDebugControl4 *iface, ULONG *options)
3581 {
3582     FIXME("%p, %p stub.\n", iface, options);
3583
3584     return E_NOTIMPL;
3585 }
3586
3587 static HRESULT STDMETHODCALLTYPE debugcontrol_AddAssemblyOptions(IDebugControl4 *iface, ULONG options)
3588 {
3589     FIXME("%p, %#lx stub.\n", iface, options);
3590
3591     return E_NOTIMPL;
3592 }
3593
3594 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveAssemblyOptions(IDebugControl4 *iface, ULONG options)
3595 {
3596     FIXME("%p, %#lx stub.\n", iface, options);
3597
3598     return E_NOTIMPL;
3599 }
3600
3601 static HRESULT STDMETHODCALLTYPE debugcontrol_SetAssemblyOptions(IDebugControl4 *iface, ULONG options)
3602 {
3603     FIXME("%p, %#lx stub.\n", iface, options);
3604
3605     return E_NOTIMPL;
3606 }
3607
3608 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntax(IDebugControl4 *iface, ULONG *flags)
3609 {
3610     FIXME("%p, %p stub.\n", iface, flags);
3611
3612     return E_NOTIMPL;
3613 }
3614
3615 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntax(IDebugControl4 *iface, ULONG flags)
3616 {
3617     FIXME("%p, %#lx stub.\n", iface, flags);
3618
3619     return E_NOTIMPL;
3620 }
3621
3622 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntaxByName(IDebugControl4 *iface, const char *name)
3623 {
3624     FIXME("%p, %s stub.\n", iface, debugstr_a(name));
3625
3626     return E_NOTIMPL;
3627 }
3628
3629 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberExpressionSyntaxes(IDebugControl4 *iface, ULONG *number)
3630 {
3631     FIXME("%p, %p stub.\n", iface, number);
3632
3633     return E_NOTIMPL;
3634 }
3635
3636 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntaxNames(IDebugControl4 *iface, ULONG index, char *fullname,
3637         ULONG fullname_buffer_size, ULONG *fullname_size, char *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size)
3638 {
3639     FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, index, fullname, fullname_buffer_size, fullname_size, abbrevname,
3640             abbrevname_buffer_size, abbrevname_size);
3641
3642     return E_NOTIMPL;
3643 }
3644
3645 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEvents(IDebugControl4 *iface, ULONG *events)
3646 {
3647     FIXME("%p, %p stub.\n", iface, events);
3648
3649     return E_NOTIMPL;
3650 }
3651
3652 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventIndexDescription(IDebugControl4 *iface, ULONG index, ULONG which,
3653         char *buffer, ULONG buffer_size, ULONG *desc_size)
3654 {
3655     FIXME("%p, %lu, %lu, %p, %lu, %p stub.\n", iface, index, which, buffer, buffer_size, desc_size);
3656
3657     return E_NOTIMPL;
3658 }
3659
3660 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentEventIndex(IDebugControl4 *iface, ULONG *index)
3661 {
3662     FIXME("%p, %p stub.\n", iface, index);
3663
3664     return E_NOTIMPL;
3665 }
3666
3667 static HRESULT STDMETHODCALLTYPE debugcontrol_SetNextEventIndex(IDebugControl4 *iface, ULONG relation, ULONG value,
3668         ULONG *next_index)
3669 {
3670     FIXME("%p, %lu, %lu, %p stub.\n", iface, relation, value, next_index);
3671
3672     return E_NOTIMPL;
3673 }
3674
3675 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFileWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
3676         ULONG *file_size, BOOL *append)
3677 {
3678     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
3679
3680     return E_NOTIMPL;
3681 }
3682
3683 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFileWide(IDebugControl4 *iface, const WCHAR *filename, BOOL append)
3684 {
3685     FIXME("%p, %s, %d stub.\n", iface, debugstr_w(filename), append);
3686
3687     return E_NOTIMPL;
3688 }
3689
3690 static HRESULT STDMETHODCALLTYPE debugcontrol_InputWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
3691        ULONG *input_size)
3692 {
3693     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, input_size);
3694
3695     return E_NOTIMPL;
3696 }
3697
3698 static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInputWide(IDebugControl4 *iface, const WCHAR *buffer)
3699 {
3700     FIXME("%p, %p stub.\n", iface, buffer);
3701
3702     return E_NOTIMPL;
3703 }
3704
3705 static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputWide(IDebugControl4 *iface, ULONG mask, const WCHAR *format, ...)
3706 {
3707     FIXME("%p, %lx, %s stub.\n", iface, mask, debugstr_w(format));
3708
3709     return E_NOTIMPL;
3710 }
3711
3712 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaListWide(IDebugControl4 *iface, ULONG mask, const WCHAR *format,
3713         va_list args)
3714 {
3715     FIXME("%p, %lx, %s stub.\n", iface, mask, debugstr_w(format));
3716
3717     return E_NOTIMPL;
3718 }
3719
3720 static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutputWide(IDebugControl4 *iface, ULONG output_control, ULONG mask,
3721         const WCHAR *format, ...)
3722 {
3723     FIXME("%p, %lx, %lx, %s stub.\n", iface, output_control, mask, debugstr_w(format));
3724
3725     return E_NOTIMPL;
3726 }
3727
3728 static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaListWide(IDebugControl4 *iface, ULONG output_control,
3729         ULONG mask, const WCHAR *format, va_list args)
3730 {
3731     FIXME("%p, %lx, %lx, %s stub.\n", iface, output_control, mask, debugstr_w(format));
3732
3733     return E_NOTIMPL;
3734 }
3735
3736 static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPromptWide(IDebugControl4 *iface, ULONG output_control,
3737         const WCHAR *format, ...)
3738 {
3739     FIXME("%p, %lx, %s stub.\n", iface, output_control, debugstr_w(format));
3740
3741     return E_NOTIMPL;
3742 }
3743
3744 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaListWide(IDebugControl4 *iface, ULONG output_control,
3745         const WCHAR *format, va_list args)
3746 {
3747     FIXME("%p, %lx, %s stub.\n", iface, output_control, debugstr_w(format));
3748
3749     return E_NOTIMPL;
3750 }
3751
3752 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptTextWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
3753         ULONG *text_size)
3754 {
3755     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, text_size);
3756
3757     return E_NOTIMPL;
3758 }
3759
3760 static HRESULT STDMETHODCALLTYPE debugcontrol_AssembleWide(IDebugControl4 *iface, ULONG64 offset, const WCHAR *instr,
3761         ULONG64 *end_offset)
3762 {
3763     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), debugstr_w(instr), end_offset);
3764
3765     return E_NOTIMPL;
3766 }
3767
3768 static HRESULT STDMETHODCALLTYPE debugcontrol_DisassembleWide(IDebugControl4 *iface, ULONG64 offset, ULONG flags, WCHAR *buffer,
3769         ULONG buffer_size, ULONG *size, ULONG64 *end_offset)
3770 {
3771     FIXME("%p, %s, %#lx, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size, size, end_offset);
3772
3773     return E_NOTIMPL;
3774 }
3775
3776 static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNamesWide(IDebugControl4 *iface, ULONG type, WCHAR *fullname,
3777         ULONG fullname_buffer_size, ULONG *fullname_size, WCHAR *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size)
3778 {
3779     FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, fullname, fullname_buffer_size, fullname_size, abbrevname,
3780             abbrevname_buffer_size, abbrevname_size);
3781
3782     return E_NOTIMPL;
3783 }
3784
3785 static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacroWide(IDebugControl4 *iface, ULONG slot, WCHAR *buffer,
3786         ULONG buffer_size, ULONG *macro_size)
3787 {
3788     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
3789
3790     return E_NOTIMPL;
3791 }
3792
3793 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacroWide(IDebugControl4 *iface, ULONG slot, const WCHAR *macro)
3794 {
3795     FIXME("%p, %lu, %s stub.\n", iface, slot, debugstr_w(macro));
3796
3797     return E_NOTIMPL;
3798 }
3799
3800 static HRESULT STDMETHODCALLTYPE debugcontrol_EvaluateWide(IDebugControl4 *iface, const WCHAR *expression, ULONG desired_type,
3801         DEBUG_VALUE *value, ULONG *remainder_index)
3802 {
3803     FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_w(expression), desired_type, value, remainder_index);
3804
3805     return E_NOTIMPL;
3806 }
3807
3808 static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteWide(IDebugControl4 *iface, ULONG output_control, const WCHAR *command,
3809         ULONG flags)
3810 {
3811     FIXME("%p, %lx, %s, %lx stub.\n", iface, output_control, debugstr_w(command), flags);
3812
3813     return E_NOTIMPL;
3814 }
3815
3816 static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFileWide(IDebugControl4 *iface, ULONG output_control,
3817         const WCHAR *commandfile, ULONG flags)
3818 {
3819     FIXME("%p, %lx, %s, %lx stub.\n", iface, output_control, debugstr_w(commandfile), flags);
3820
3821     return E_NOTIMPL;
3822 }
3823
3824 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex2(IDebugControl4 *iface, ULONG index, PDEBUG_BREAKPOINT2 *bp)
3825 {
3826     FIXME("%p, %lu, %p stub.\n", iface, index, bp);
3827
3828     return E_NOTIMPL;
3829 }
3830
3831 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById2(IDebugControl4 *iface, ULONG id, PDEBUG_BREAKPOINT2 *bp)
3832 {
3833     FIXME("%p, %lu, %p stub.\n", iface, id, bp);
3834
3835     return E_NOTIMPL;
3836 }
3837
3838 static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint2(IDebugControl4 *iface, ULONG type, ULONG desired_id,
3839         PDEBUG_BREAKPOINT2 *bp)
3840 {
3841     FIXME("%p, %lu, %lu, %p stub.\n", iface, type, desired_id, bp);
3842
3843     return E_NOTIMPL;
3844 }
3845
3846 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint2(IDebugControl4 *iface, PDEBUG_BREAKPOINT2 bp)
3847 {
3848     FIXME("%p, %p stub.\n", iface, bp);
3849
3850     return E_NOTIMPL;
3851 }
3852
3853 static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtensionWide(IDebugControl4 *iface, const WCHAR *path, ULONG flags,
3854         ULONG64 *handle)
3855 {
3856     FIXME("%p, %s, %#lx, %p stub.\n", iface, debugstr_w(path), flags, handle);
3857
3858     return E_NOTIMPL;
3859 }
3860
3861 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPathWide(IDebugControl4 *iface, const WCHAR *path, ULONG64 *handle)
3862 {
3863     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(path), handle);
3864
3865     return E_NOTIMPL;
3866 }
3867
3868 static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtensionWide(IDebugControl4 *iface, ULONG64 handle, const WCHAR *function,
3869         const WCHAR *arguments)
3870 {
3871     FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_w(function), debugstr_w(arguments));
3872
3873     return E_NOTIMPL;
3874 }
3875
3876 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunctionWide(IDebugControl4 *iface, ULONG64 handle,
3877         const WCHAR *function, FARPROC *func)
3878 {
3879     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_w(function), func);
3880
3881     return E_NOTIMPL;
3882 }
3883
3884 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterTextWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
3885         ULONG buffer_size, ULONG *text_size)
3886 {
3887     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, text_size);
3888
3889     return E_NOTIMPL;
3890 }
3891
3892 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommandWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
3893         ULONG buffer_size, ULONG *command_size)
3894 {
3895     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3896
3897     return E_NOTIMPL;
3898 }
3899
3900 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommandWide(IDebugControl4 *iface, ULONG index, const WCHAR *command)
3901 {
3902     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(command));
3903
3904     return E_NOTIMPL;
3905 }
3906
3907 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgumentWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
3908         ULONG buffer_size, ULONG *argument_size)
3909 {
3910     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
3911
3912     return E_NOTIMPL;
3913 }
3914
3915 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgumentWide(IDebugControl4 *iface, ULONG index,
3916         const WCHAR *argument)
3917 {
3918     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(argument));
3919
3920     return E_NOTIMPL;
3921 }
3922
3923 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterSecondCommandWide(IDebugControl4 *iface, ULONG index,
3924         WCHAR *buffer, ULONG buffer_size, ULONG *command_size)
3925 {
3926     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3927
3928     return E_NOTIMPL;
3929 }
3930
3931 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterSecondCommandWide(IDebugControl4 *iface, ULONG index,
3932         const WCHAR *command)
3933 {
3934     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(command));
3935
3936     return E_NOTIMPL;
3937 }
3938
3939 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformationWide(IDebugControl4 *iface, ULONG *type, ULONG *processid,
3940         ULONG *threadid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, WCHAR *desc, ULONG desc_size,
3941         ULONG *desc_used)
3942 {
3943     FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, processid, threadid, extra_info, extra_info_size,
3944             extra_info_used, desc, desc_size, desc_used);
3945
3946     return E_NOTIMPL;
3947 }
3948
3949 static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextReplacementWide(IDebugControl4 *iface, const WCHAR *src_text, ULONG index,
3950         WCHAR *src_buffer, ULONG src_buffer_size, ULONG *src_size, WCHAR *dst_buffer, ULONG dest_buffer_size, ULONG *dst_size)
3951 {
3952     FIXME("%p, %s, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, debugstr_w(src_text), index, src_buffer, src_buffer_size,
3953             src_size, dst_buffer, dest_buffer_size, dst_size);
3954
3955     return E_NOTIMPL;
3956 }
3957
3958 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacementWide(IDebugControl4 *iface, const WCHAR *src_text,
3959         const WCHAR *dst_text)
3960 {
3961     FIXME("%p, %s, %s stub.\n", iface, debugstr_w(src_text), debugstr_w(dst_text));
3962
3963     return E_NOTIMPL;
3964 }
3965
3966 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntaxByNameWide(IDebugControl4 *iface, const WCHAR *abbrevname)
3967 {
3968     FIXME("%p, %s stub.\n", iface, debugstr_w(abbrevname));
3969
3970     return E_NOTIMPL;
3971 }
3972
3973 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntaxNamesWide(IDebugControl4 *iface, ULONG index,
3974         WCHAR *fullname_buffer, ULONG fullname_buffer_size, ULONG *fullname_size, WCHAR *abbrevname_buffer,
3975         ULONG abbrevname_buffer_size, ULONG *abbrev_size)
3976 {
3977     FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, index, fullname_buffer, fullname_buffer_size, fullname_size,
3978             abbrevname_buffer, abbrevname_buffer_size, abbrev_size);
3979
3980     return E_NOTIMPL;
3981 }
3982
3983 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventIndexDescriptionWide(IDebugControl4 *iface, ULONG index, ULONG which,
3984         WCHAR *buffer, ULONG buffer_size, ULONG *desc_size)
3985 {
3986     FIXME("%p, %lu, %lu, %p, %lu, %p stub.\n", iface, index, which, buffer, buffer_size, desc_size);
3987
3988     return E_NOTIMPL;
3989 }
3990
3991 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile2(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
3992         ULONG *file_size, ULONG *flags)
3993 {
3994     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, flags);
3995
3996     return E_NOTIMPL;
3997 }
3998
3999 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile2(IDebugControl4 *iface, const char *filename, ULONG flags)
4000 {
4001     FIXME("%p, %s, %#lx stub.\n", iface, debugstr_a(filename), flags);
4002
4003     return E_NOTIMPL;
4004 }
4005
4006 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile2Wide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
4007         ULONG *file_size, ULONG *flags)
4008 {
4009     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, flags);
4010
4011     return E_NOTIMPL;
4012 }
4013
4014 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile2Wide(IDebugControl4 *iface, const WCHAR *filename, ULONG flags)
4015 {
4016     FIXME("%p, %s, %#lx stub.\n", iface, debugstr_w(filename), flags);
4017
4018     return E_NOTIMPL;
4019 }
4020
4021 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionValues(IDebugControl4 *iface, ULONG *platformid,
4022         ULONG *win32major, ULONG *win32minor, ULONG *kdmajor, ULONG *kdminor)
4023 {
4024     FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, platformid, win32major, win32minor, kdmajor, kdminor);
4025
4026     return E_NOTIMPL;
4027 }
4028
4029 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionString(IDebugControl4 *iface, ULONG which, char *buffer,
4030         ULONG buffer_size, ULONG *string_size)
4031 {
4032     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, which, buffer, buffer_size, string_size);
4033
4034     return E_NOTIMPL;
4035 }
4036
4037 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionStringWide(IDebugControl4 *iface, ULONG which, WCHAR *buffer,
4038         ULONG buffer_size, ULONG *string_size)
4039 {
4040     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, which, buffer, buffer_size, string_size);
4041
4042     return E_NOTIMPL;
4043 }
4044
4045 static HRESULT STDMETHODCALLTYPE debugcontrol_GetContextStackTrace(IDebugControl4 *iface, void *start_context,
4046         ULONG start_context_size, PDEBUG_STACK_FRAME frames, ULONG frames_size, void *frame_contexts, ULONG frame_contexts_size,
4047         ULONG frame_contexts_entry_size, ULONG *frames_filled)
4048 {
4049     FIXME("%p, %p, %lu, %p, %lu, %p, %lu, %lu, %p stub.\n", iface, start_context, start_context_size, frames, frames_size,
4050             frame_contexts, frame_contexts_size, frame_contexts_entry_size, frames_filled);
4051
4052     return E_NOTIMPL;
4053 }
4054
4055 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputContextStackTrace(IDebugControl4 *iface, ULONG output_control,
4056         PDEBUG_STACK_FRAME frames, ULONG frames_size, void *frame_contexts, ULONG frame_contexts_size,
4057         ULONG frame_contexts_entry_size, ULONG flags)
4058 {
4059     FIXME("%p, %#lx, %p, %lu, %p, %lu, %lu, %#lx stub.\n", iface, output_control, frames, frames_size, frame_contexts,
4060             frame_contexts_size, frame_contexts_entry_size, flags);
4061
4062     return E_NOTIMPL;
4063 }
4064
4065 static HRESULT STDMETHODCALLTYPE debugcontrol_GetStoredEventInformation(IDebugControl4 *iface, ULONG *type, ULONG *processid,
4066         ULONG *threadid, void *context, ULONG context_size, ULONG *context_used, void *extra_info, ULONG extra_info_size,
4067         ULONG *extra_info_used)
4068 {
4069     FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, processid, threadid, context, context_size,
4070             context_used, extra_info, extra_info_size, extra_info_used);
4071
4072     return E_NOTIMPL;
4073 }
4074
4075 static HRESULT STDMETHODCALLTYPE debugcontrol_GetManagedStatus(IDebugControl4 *iface, ULONG *flags, ULONG which_string,
4076         char *string, ULONG string_size, ULONG string_needed)
4077 {
4078     FIXME("%p, %p, %lu, %p, %lu, %lu stub.\n", iface, flags, which_string, string, string_size, string_needed);
4079
4080     return E_NOTIMPL;
4081 }
4082
4083 static HRESULT STDMETHODCALLTYPE debugcontrol_GetManagedStatusWide(IDebugControl4 *iface, ULONG *flags, ULONG which_string,
4084         WCHAR *string, ULONG string_size, ULONG string_needed)
4085 {
4086     FIXME("%p, %p, %lu, %p, %lu, %lu stub.\n", iface, flags, which_string, string, string_size, string_needed);
4087
4088     return E_NOTIMPL;
4089 }
4090
4091 static HRESULT STDMETHODCALLTYPE debugcontrol_ResetManagedStatus(IDebugControl4 *iface, ULONG flags)
4092 {
4093     FIXME("%p, %#lx stub.\n", iface, flags);
4094
4095     return E_NOTIMPL;
4096 }
4097
4098 static const IDebugControl4Vtbl debugcontrolvtbl =
4099 {
4100     debugcontrol_QueryInterface,
4101     debugcontrol_AddRef,
4102     debugcontrol_Release,
4103     debugcontrol_GetInterrupt,
4104     debugcontrol_SetInterrupt,
4105     debugcontrol_GetInterruptTimeout,
4106     debugcontrol_SetInterruptTimeout,
4107     debugcontrol_GetLogFile,
4108     debugcontrol_OpenLogFile,
4109     debugcontrol_CloseLogFile,
4110     debugcontrol_GetLogMask,
4111     debugcontrol_SetLogMask,
4112     debugcontrol_Input,
4113     debugcontrol_ReturnInput,
4114     debugcontrol_Output,
4115     debugcontrol_OutputVaList,
4116     debugcontrol_ControlledOutput,
4117     debugcontrol_ControlledOutputVaList,
4118     debugcontrol_OutputPrompt,
4119     debugcontrol_OutputPromptVaList,
4120     debugcontrol_GetPromptText,
4121     debugcontrol_OutputCurrentState,
4122     debugcontrol_OutputVersionInformation,
4123     debugcontrol_GetNotifyEventHandle,
4124     debugcontrol_SetNotifyEventHandle,
4125     debugcontrol_Assemble,
4126     debugcontrol_Disassemble,
4127     debugcontrol_GetDisassembleEffectiveOffset,
4128     debugcontrol_OutputDisassembly,
4129     debugcontrol_OutputDisassemblyLines,
4130     debugcontrol_GetNearInstruction,
4131     debugcontrol_GetStackTrace,
4132     debugcontrol_GetReturnOffset,
4133     debugcontrol_OutputStackTrace,
4134     debugcontrol_GetDebuggeeType,
4135     debugcontrol_GetActualProcessorType,
4136     debugcontrol_GetExecutingProcessorType,
4137     debugcontrol_GetNumberPossibleExecutingProcessorTypes,
4138     debugcontrol_GetPossibleExecutingProcessorTypes,
4139     debugcontrol_GetNumberProcessors,
4140     debugcontrol_GetSystemVersion,
4141     debugcontrol_GetPageSize,
4142     debugcontrol_IsPointer64Bit,
4143     debugcontrol_ReadBugCheckData,
4144     debugcontrol_GetNumberSupportedProcessorTypes,
4145     debugcontrol_GetSupportedProcessorTypes,
4146     debugcontrol_GetProcessorTypeNames,
4147     debugcontrol_GetEffectiveProcessorType,
4148     debugcontrol_SetEffectiveProcessorType,
4149     debugcontrol_GetExecutionStatus,
4150     debugcontrol_SetExecutionStatus,
4151     debugcontrol_GetCodeLevel,
4152     debugcontrol_SetCodeLevel,
4153     debugcontrol_GetEngineOptions,
4154     debugcontrol_AddEngineOptions,
4155     debugcontrol_RemoveEngineOptions,
4156     debugcontrol_SetEngineOptions,
4157     debugcontrol_GetSystemErrorControl,
4158     debugcontrol_SetSystemErrorControl,
4159     debugcontrol_GetTextMacro,
4160     debugcontrol_SetTextMacro,
4161     debugcontrol_GetRadix,
4162     debugcontrol_SetRadix,
4163     debugcontrol_Evaluate,
4164     debugcontrol_CoerceValue,
4165     debugcontrol_CoerceValues,
4166     debugcontrol_Execute,
4167     debugcontrol_ExecuteCommandFile,
4168     debugcontrol_GetNumberBreakpoints,
4169     debugcontrol_GetBreakpointByIndex,
4170     debugcontrol_GetBreakpointById,
4171     debugcontrol_GetBreakpointParameters,
4172     debugcontrol_AddBreakpoint,
4173     debugcontrol_RemoveBreakpoint,
4174     debugcontrol_AddExtension,
4175     debugcontrol_RemoveExtension,
4176     debugcontrol_GetExtensionByPath,
4177     debugcontrol_CallExtension,
4178     debugcontrol_GetExtensionFunction,
4179     debugcontrol_GetWindbgExtensionApis32,
4180     debugcontrol_GetWindbgExtensionApis64,
4181     debugcontrol_GetNumberEventFilters,
4182     debugcontrol_GetEventFilterText,
4183     debugcontrol_GetEventFilterCommand,
4184     debugcontrol_SetEventFilterCommand,
4185     debugcontrol_GetSpecificFilterParameters,
4186     debugcontrol_SetSpecificFilterParameters,
4187     debugcontrol_GetSpecificFilterArgument,
4188     debugcontrol_SetSpecificFilterArgument,
4189     debugcontrol_GetExceptionFilterParameters,
4190     debugcontrol_SetExceptionFilterParameters,
4191     debugcontrol_GetExceptionFilterSecondCommand,
4192     debugcontrol_SetExceptionFilterSecondCommand,
4193     debugcontrol_WaitForEvent,
4194     debugcontrol_GetLastEventInformation,
4195     debugcontrol_GetCurrentTimeDate,
4196     debugcontrol_GetCurrentSystemUpTime,
4197     debugcontrol_GetDumpFormatFlags,
4198     debugcontrol_GetNumberTextPlacements,
4199     debugcontrol_GetNumberTextReplacement,
4200     debugcontrol_SetTextReplacement,
4201     debugcontrol_RemoveTextReplacements,
4202     debugcontrol_OutputTextReplacements,
4203     debugcontrol_GetAssemblyOptions,
4204     debugcontrol_AddAssemblyOptions,
4205     debugcontrol_RemoveAssemblyOptions,
4206     debugcontrol_SetAssemblyOptions,
4207     debugcontrol_GetExpressionSyntax,
4208     debugcontrol_SetExpressionSyntax,
4209     debugcontrol_SetExpressionSyntaxByName,
4210     debugcontrol_GetNumberExpressionSyntaxes,
4211     debugcontrol_GetExpressionSyntaxNames,
4212     debugcontrol_GetNumberEvents,
4213     debugcontrol_GetEventIndexDescription,
4214     debugcontrol_GetCurrentEventIndex,
4215     debugcontrol_SetNextEventIndex,
4216     debugcontrol_GetLogFileWide,
4217     debugcontrol_OpenLogFileWide,
4218     debugcontrol_InputWide,
4219     debugcontrol_ReturnInputWide,
4220     debugcontrol_OutputWide,
4221     debugcontrol_OutputVaListWide,
4222     debugcontrol_ControlledOutputWide,
4223     debugcontrol_ControlledOutputVaListWide,
4224     debugcontrol_OutputPromptWide,
4225     debugcontrol_OutputPromptVaListWide,
4226     debugcontrol_GetPromptTextWide,
4227     debugcontrol_AssembleWide,
4228     debugcontrol_DisassembleWide,
4229     debugcontrol_GetProcessorTypeNamesWide,
4230     debugcontrol_GetTextMacroWide,
4231     debugcontrol_SetTextMacroWide,
4232     debugcontrol_EvaluateWide,
4233     debugcontrol_ExecuteWide,
4234     debugcontrol_ExecuteCommandFileWide,
4235     debugcontrol_GetBreakpointByIndex2,
4236     debugcontrol_GetBreakpointById2,
4237     debugcontrol_AddBreakpoint2,
4238     debugcontrol_RemoveBreakpoint2,
4239     debugcontrol_AddExtensionWide,
4240     debugcontrol_GetExtensionByPathWide,
4241     debugcontrol_CallExtensionWide,
4242     debugcontrol_GetExtensionFunctionWide,
4243     debugcontrol_GetEventFilterTextWide,
4244     debugcontrol_GetEventFilterCommandWide,
4245     debugcontrol_SetEventFilterCommandWide,
4246     debugcontrol_GetSpecificFilterArgumentWide,
4247     debugcontrol_SetSpecificFilterArgumentWide,
4248     debugcontrol_GetSpecificFilterSecondCommandWide,
4249     debugcontrol_SetSpecificFilterSecondCommandWide,
4250     debugcontrol_GetLastEventInformationWide,
4251     debugcontrol_GetTextReplacementWide,
4252     debugcontrol_SetTextReplacementWide,
4253     debugcontrol_SetExpressionSyntaxByNameWide,
4254     debugcontrol_GetExpressionSyntaxNamesWide,
4255     debugcontrol_GetEventIndexDescriptionWide,
4256     debugcontrol_GetLogFile2,
4257     debugcontrol_OpenLogFile2,
4258     debugcontrol_GetLogFile2Wide,
4259     debugcontrol_OpenLogFile2Wide,
4260     debugcontrol_GetSystemVersionValues,
4261     debugcontrol_GetSystemVersionString,
4262     debugcontrol_GetSystemVersionStringWide,
4263     debugcontrol_GetContextStackTrace,
4264     debugcontrol_OutputContextStackTrace,
4265     debugcontrol_GetStoredEventInformation,
4266     debugcontrol_GetManagedStatus,
4267     debugcontrol_GetManagedStatusWide,
4268     debugcontrol_ResetManagedStatus,
4269 };
4270
4271 static HRESULT STDMETHODCALLTYPE debugadvanced_QueryInterface(IDebugAdvanced3 *iface, REFIID riid, void **obj)
4272 {
4273     struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
4274     return IUnknown_QueryInterface((IUnknown *)&debug_client->IDebugClient_iface, riid, obj);
4275 }
4276
4277 static ULONG STDMETHODCALLTYPE debugadvanced_AddRef(IDebugAdvanced3 *iface)
4278 {
4279     struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
4280     return IUnknown_AddRef((IUnknown *)&debug_client->IDebugClient_iface);
4281 }
4282
4283 static ULONG STDMETHODCALLTYPE debugadvanced_Release(IDebugAdvanced3 *iface)
4284 {
4285     struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
4286     return IUnknown_Release((IUnknown *)&debug_client->IDebugClient_iface);
4287 }
4288
4289 static HRESULT STDMETHODCALLTYPE debugadvanced_GetThreadContext(IDebugAdvanced3 *iface, void *context,
4290         ULONG context_size)
4291 {
4292     FIXME("%p, %p, %lu stub.\n", iface, context, context_size);
4293
4294     return E_NOTIMPL;
4295 }
4296
4297 static HRESULT STDMETHODCALLTYPE debugadvanced_SetThreadContext(IDebugAdvanced3 *iface, void *context,
4298         ULONG context_size)
4299 {
4300     FIXME("%p, %p, %lu stub.\n", iface, context, context_size);
4301
4302     return E_NOTIMPL;
4303 }
4304
4305 static HRESULT STDMETHODCALLTYPE debugadvanced_Request(IDebugAdvanced3 *iface, ULONG request, void *inbuffer,
4306         ULONG inbuffer_size, void *outbuffer, ULONG outbuffer_size, ULONG *outsize)
4307 {
4308     FIXME("%p, %lu, %p, %lu, %p, %lu, %p stub.\n", iface, request, inbuffer, inbuffer_size, outbuffer, outbuffer_size, outsize);
4309
4310     return E_NOTIMPL;
4311 }
4312
4313 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSourceFileInformation(IDebugAdvanced3 *iface, ULONG which, char *sourcefile,
4314         ULONG64 arg64, ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
4315 {
4316     FIXME("%p, %lu, %p, %s, %#lx, %p, %lu, %p stub.\n", iface, which, sourcefile, wine_dbgstr_longlong(arg64),
4317             arg32, buffer, buffer_size, info_size);
4318
4319     return E_NOTIMPL;
4320 }
4321
4322 static HRESULT STDMETHODCALLTYPE debugadvanced_FindSourceFileAndToken(IDebugAdvanced3 *iface, ULONG start_element,
4323         ULONG64 modaddr, const char *filename, ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element,
4324         char *buffer, ULONG buffer_size, ULONG *found_size)
4325 {
4326     FIXME("%p, %lu, %s, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, start_element, wine_dbgstr_longlong(modaddr),
4327             debugstr_a(filename), flags, filetoken, filetokensize, found_element, buffer, buffer_size, found_size);
4328
4329     return E_NOTIMPL;
4330 }
4331
4332 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSymbolInformation(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
4333         ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size, char *string_buffer, ULONG string_buffer_size,
4334         ULONG *string_size)
4335 {
4336     FIXME("%p, %lu, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64),
4337             arg32, buffer, buffer_size, info_size, string_buffer, string_buffer_size, string_size);
4338
4339     return E_NOTIMPL;
4340 }
4341
4342 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSystemObjectInformation(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
4343         ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
4344 {
4345     FIXME("%p, %lu, %s, %#lx, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64), arg32, buffer,
4346             buffer_size, info_size);
4347
4348     return E_NOTIMPL;
4349 }
4350
4351 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSourceFileInformationWide(IDebugAdvanced3 *iface, ULONG which,
4352         WCHAR *source_file, ULONG64 arg64, ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
4353 {
4354     FIXME("%p, %lu, %p, %s, %#lx, %p, %lu, %p stub.\n", iface, which, source_file, wine_dbgstr_longlong(arg64),
4355             arg32, buffer, buffer_size, info_size);
4356
4357     return E_NOTIMPL;
4358 }
4359
4360 static HRESULT STDMETHODCALLTYPE debugadvanced_FindSourceFileAndTokenWide(IDebugAdvanced3 *iface, ULONG start_element,
4361         ULONG64 modaddr, const WCHAR *filename, ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element,
4362         WCHAR *buffer, ULONG buffer_size, ULONG *found_size)
4363 {
4364     FIXME("%p, %lu, %s, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, start_element, wine_dbgstr_longlong(modaddr),
4365             debugstr_w(filename), flags, filetoken, filetokensize, found_element, buffer, buffer_size, found_size);
4366
4367     return E_NOTIMPL;
4368 }
4369
4370 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSymbolInformationWide(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
4371         ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size, WCHAR *string_buffer, ULONG string_buffer_size,
4372         ULONG *string_size)
4373 {
4374     FIXME("%p, %lu, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64),
4375             arg32, buffer, buffer_size, info_size, string_buffer, string_buffer_size, string_size);
4376
4377     return E_NOTIMPL;
4378 }
4379
4380 static const IDebugAdvanced3Vtbl debugadvancedvtbl =
4381 {
4382     debugadvanced_QueryInterface,
4383     debugadvanced_AddRef,
4384     debugadvanced_Release,
4385     debugadvanced_GetThreadContext,
4386     debugadvanced_SetThreadContext,
4387     debugadvanced_Request,
4388     debugadvanced_GetSourceFileInformation,
4389     debugadvanced_FindSourceFileAndToken,
4390     debugadvanced_GetSymbolInformation,
4391     debugadvanced_GetSystemObjectInformation,
4392     debugadvanced_GetSourceFileInformationWide,
4393     debugadvanced_FindSourceFileAndTokenWide,
4394     debugadvanced_GetSymbolInformationWide,
4395 };
4396
4397 static HRESULT STDMETHODCALLTYPE debugsystemobjects_QueryInterface(IDebugSystemObjects *iface, REFIID riid, void **obj)
4398 {
4399     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
4400     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
4401     return IUnknown_QueryInterface(unk, riid, obj);
4402 }
4403
4404 static ULONG STDMETHODCALLTYPE debugsystemobjects_AddRef(IDebugSystemObjects *iface)
4405 {
4406     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
4407     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
4408     return IUnknown_AddRef(unk);
4409 }
4410
4411 static ULONG STDMETHODCALLTYPE debugsystemobjects_Release(IDebugSystemObjects *iface)
4412 {
4413     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
4414     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
4415     return IUnknown_Release(unk);
4416 }
4417
4418 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventThread(IDebugSystemObjects *iface, ULONG *id)
4419 {
4420     FIXME("%p, %p stub.\n", iface, id);
4421
4422     return E_NOTIMPL;
4423 }
4424
4425 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventProcess(IDebugSystemObjects *iface, ULONG *id)
4426 {
4427     FIXME("%p, %p stub.\n", iface, id);
4428
4429     return E_NOTIMPL;
4430 }
4431
4432 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadId(IDebugSystemObjects *iface, ULONG *id)
4433 {
4434     FIXME("%p, %p stub.\n", iface, id);
4435
4436     return E_NOTIMPL;
4437 }
4438
4439 static HRESULT STDMETHODCALLTYPE debugsystemobjects_SetCurrentThreadId(IDebugSystemObjects *iface, ULONG id)
4440 {
4441     FIXME("%p, %lu stub.\n", iface, id);
4442
4443     return E_NOTIMPL;
4444 }
4445
4446 static HRESULT STDMETHODCALLTYPE debugsystemobjects_SetCurrentProcessId(IDebugSystemObjects *iface, ULONG id)
4447 {
4448     FIXME("%p, %lu stub.\n", iface, id);
4449
4450     return E_NOTIMPL;
4451 }
4452
4453 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberThreads(IDebugSystemObjects *iface, ULONG *number)
4454 {
4455     FIXME("%p, %p stub.\n", iface, number);
4456
4457     return E_NOTIMPL;
4458 }
4459
4460 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetTotalNumberThreads(IDebugSystemObjects *iface, ULONG *total,
4461         ULONG *largest_process)
4462 {
4463     FIXME("%p, %p, %p stub.\n", iface, total, largest_process);
4464
4465     return E_NOTIMPL;
4466 }
4467
4468 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdsByIndex(IDebugSystemObjects *iface, ULONG start,
4469         ULONG count, ULONG *ids, ULONG *sysids)
4470 {
4471     FIXME("%p, %lu, %lu, %p, %p stub.\n", iface, start, count, ids, sysids);
4472
4473     return E_NOTIMPL;
4474 }
4475
4476 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByProcessor(IDebugSystemObjects *iface, ULONG processor,
4477         ULONG *id)
4478 {
4479     FIXME("%p, %lu, %p stub.\n", iface, processor, id);
4480
4481     return E_NOTIMPL;
4482 }
4483
4484 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadDataOffset(IDebugSystemObjects *iface,
4485         ULONG64 *offset)
4486 {
4487     FIXME("%p, %p stub.\n", iface, offset);
4488
4489     return E_NOTIMPL;
4490 }
4491
4492 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByDataOffset(IDebugSystemObjects *iface, ULONG64 offset,
4493         ULONG *id)
4494 {
4495     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
4496
4497     return E_NOTIMPL;
4498 }
4499
4500 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadTeb(IDebugSystemObjects *iface, ULONG64 *offset)
4501 {
4502     FIXME("%p, %p stub.\n", iface, offset);
4503
4504     return E_NOTIMPL;
4505 }
4506
4507 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByTeb(IDebugSystemObjects *iface, ULONG64 offset,
4508         ULONG *id)
4509 {
4510     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
4511
4512     return E_NOTIMPL;
4513 }
4514
4515 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadSystemId(IDebugSystemObjects *iface, ULONG *sysid)
4516 {
4517     FIXME("%p, %p stub.\n", iface, sysid);
4518
4519     return E_NOTIMPL;
4520 }
4521
4522 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
4523         ULONG *id)
4524 {
4525     FIXME("%p, %lu, %p stub.\n", iface, sysid, id);
4526
4527     return E_NOTIMPL;
4528 }
4529
4530 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadHandle(IDebugSystemObjects *iface, ULONG64 *handle)
4531 {
4532     FIXME("%p, %p stub.\n", iface, handle);
4533
4534     return E_NOTIMPL;
4535 }
4536
4537 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
4538         ULONG *id)
4539 {
4540     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
4541
4542     return E_NOTIMPL;
4543 }
4544
4545 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberProcesses(IDebugSystemObjects *iface, ULONG *number)
4546 {
4547     FIXME("%p, %p stub.\n", iface, number);
4548
4549     return E_NOTIMPL;
4550 }
4551
4552 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdsByIndex(IDebugSystemObjects *iface, ULONG start,
4553         ULONG count, ULONG *ids, ULONG *sysids)
4554 {
4555     FIXME("%p, %lu, %lu, %p, %p stub.\n", iface, start, count, ids, sysids);
4556
4557     return E_NOTIMPL;
4558 }
4559
4560 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessDataOffset(IDebugSystemObjects *iface,
4561         ULONG64 *offset)
4562 {
4563     FIXME("%p, %p stub.\n", iface, offset);
4564
4565     return E_NOTIMPL;
4566 }
4567
4568 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByDataOffset(IDebugSystemObjects *iface,
4569         ULONG64 offset, ULONG *id)
4570 {
4571     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
4572
4573     return E_NOTIMPL;
4574 }
4575
4576 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessPeb(IDebugSystemObjects *iface, ULONG64 *offset)
4577 {
4578     FIXME("%p, %p stub.\n", iface, offset);
4579
4580     return E_NOTIMPL;
4581 }
4582
4583 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByPeb(IDebugSystemObjects *iface, ULONG64 offset,
4584         ULONG *id)
4585 {
4586     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
4587
4588     return E_NOTIMPL;
4589 }
4590
4591 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessSystemId(IDebugSystemObjects *iface, ULONG *sysid)
4592 {
4593     FIXME("%p, %p stub.\n", iface, sysid);
4594
4595     return E_NOTIMPL;
4596 }
4597
4598 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
4599         ULONG *id)
4600 {
4601     FIXME("%p, %lu, %p stub.\n", iface, sysid, id);
4602
4603     return E_NOTIMPL;
4604 }
4605
4606 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessHandle(IDebugSystemObjects *iface,
4607         ULONG64 *handle)
4608 {
4609     FIXME("%p, %p stub.\n", iface, handle);
4610
4611     return E_NOTIMPL;
4612 }
4613
4614 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
4615         ULONG *id)
4616 {
4617     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
4618
4619     return E_NOTIMPL;
4620 }
4621
4622 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessExecutableName(IDebugSystemObjects *iface,
4623         char *buffer, ULONG buffer_size, ULONG *exe_size)
4624 {
4625     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, exe_size);
4626
4627     return E_NOTIMPL;
4628 }
4629
4630 static const IDebugSystemObjectsVtbl debugsystemobjectsvtbl =
4631 {
4632     debugsystemobjects_QueryInterface,
4633     debugsystemobjects_AddRef,
4634     debugsystemobjects_Release,
4635     debugsystemobjects_GetEventThread,
4636     debugsystemobjects_GetEventProcess,
4637     debugsystemobjects_GetCurrentThreadId,
4638     debugsystemobjects_SetCurrentThreadId,
4639     debugsystemobjects_SetCurrentProcessId,
4640     debugsystemobjects_GetNumberThreads,
4641     debugsystemobjects_GetTotalNumberThreads,
4642     debugsystemobjects_GetThreadIdsByIndex,
4643     debugsystemobjects_GetThreadIdByProcessor,
4644     debugsystemobjects_GetCurrentThreadDataOffset,
4645     debugsystemobjects_GetThreadIdByDataOffset,
4646     debugsystemobjects_GetCurrentThreadTeb,
4647     debugsystemobjects_GetThreadIdByTeb,
4648     debugsystemobjects_GetCurrentThreadSystemId,
4649     debugsystemobjects_GetThreadIdBySystemId,
4650     debugsystemobjects_GetCurrentThreadHandle,
4651     debugsystemobjects_GetThreadIdByHandle,
4652     debugsystemobjects_GetNumberProcesses,
4653     debugsystemobjects_GetProcessIdsByIndex,
4654     debugsystemobjects_GetCurrentProcessDataOffset,
4655     debugsystemobjects_GetProcessIdByDataOffset,
4656     debugsystemobjects_GetCurrentProcessPeb,
4657     debugsystemobjects_GetProcessIdByPeb,
4658     debugsystemobjects_GetCurrentProcessSystemId,
4659     debugsystemobjects_GetProcessIdBySystemId,
4660     debugsystemobjects_GetCurrentProcessHandle,
4661     debugsystemobjects_GetProcessIdByHandle,
4662     debugsystemobjects_GetCurrentProcessExecutableName,
4663 };
4664
4665 /************************************************************
4666 *                    DebugExtensionInitialize   (DBGENG.@)
4667 *
4668 * Initializing Debug Engine
4669 *
4670 * PARAMS
4671 *   pVersion  [O] Receiving the version of extension
4672 *   pFlags    [O] Reserved
4673 *
4674 * RETURNS
4675 *   Success: S_OK
4676 *   Failure: Anything other than S_OK
4677 *
4678 * BUGS
4679 *   Unimplemented
4680 */
4681 HRESULT WINAPI DebugExtensionInitialize(ULONG * pVersion, ULONG * pFlags)
4682 {
4683     FIXME("(%p,%p): stub\n", pVersion, pFlags);
4684
4685     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4686
4687     return E_NOTIMPL;
4688 }
4689
4690 /************************************************************
4691 *                    DebugCreate   (dbgeng.@)
4692 */
4693 HRESULT WINAPI DebugCreate(REFIID riid, void **obj)
4694 {
4695     struct debug_client *debug_client;
4696     IUnknown *unk;
4697     HRESULT hr;
4698
4699     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
4700
4701     if (!(debug_client = calloc(1, sizeof(*debug_client))))
4702         return E_OUTOFMEMORY;
4703
4704     debug_client->IDebugClient_iface.lpVtbl = &debugclientvtbl;
4705     debug_client->IDebugDataSpaces_iface.lpVtbl = &debugdataspacesvtbl;
4706     debug_client->IDebugSymbols3_iface.lpVtbl = &debugsymbolsvtbl;
4707     debug_client->IDebugControl4_iface.lpVtbl = &debugcontrolvtbl;
4708     debug_client->IDebugAdvanced3_iface.lpVtbl = &debugadvancedvtbl;
4709     debug_client->IDebugSystemObjects_iface.lpVtbl = &debugsystemobjectsvtbl;
4710     debug_client->refcount = 1;
4711     list_init(&debug_client->targets);
4712
4713     unk = (IUnknown *)&debug_client->IDebugClient_iface;
4714
4715     hr = IUnknown_QueryInterface(unk, riid, obj);
4716     IUnknown_Release(unk);
4717
4718     return hr;
4719 }
4720
4721 /************************************************************
4722 *                    DebugCreateEx   (DBGENG.@)
4723 */
4724 HRESULT WINAPI DebugCreateEx(REFIID riid, DWORD flags, void **obj)
4725 {
4726     FIXME("%s, %#lx, %p: stub\n", debugstr_guid(riid), flags, obj);
4727
4728     return E_NOTIMPL;
4729 }
4730
4731 /************************************************************
4732 *                    DebugConnect   (DBGENG.@)
4733 *
4734 * Creating Debug Engine client object and connecting it to remote host
4735 *
4736 * PARAMS
4737 *   RemoteOptions [I] Options which define how debugger engine connects to remote host
4738 *   InterfaceId   [I] Interface Id of debugger client
4739 *   pInterface    [O] Pointer to interface as requested via InterfaceId
4740 *
4741 * RETURNS
4742 *   Success: S_OK
4743 *   Failure: Anything other than S_OK
4744 *
4745 * BUGS
4746 *   Unimplemented
4747 */
4748 HRESULT WINAPI DebugConnect(PCSTR RemoteOptions, REFIID InterfaceId, PVOID * pInterface)
4749 {
4750     FIXME("(%p,%p,%p): stub\n", RemoteOptions, InterfaceId, pInterface);
4751
4752     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4753
4754     return E_NOTIMPL;
4755 }