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