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     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1166     return IUnknown_QueryInterface(unk, riid, obj);
1167 }
1168
1169 static ULONG STDMETHODCALLTYPE debugdataspaces_AddRef(IDebugDataSpaces *iface)
1170 {
1171     struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
1172     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1173     return IUnknown_AddRef(unk);
1174 }
1175
1176 static ULONG STDMETHODCALLTYPE debugdataspaces_Release(IDebugDataSpaces *iface)
1177 {
1178     struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
1179     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1180     return IUnknown_Release(unk);
1181 }
1182
1183 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadVirtual(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
1184         ULONG buffer_size, ULONG *read_len)
1185 {
1186     struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
1187     static struct target_process *target;
1188     HRESULT hr = S_OK;
1189     SIZE_T length;
1190
1191     TRACE("%p, %s, %p, %lu, %p.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1192
1193     if (!(target = debug_client_get_target(debug_client)))
1194         return E_UNEXPECTED;
1195
1196     if (ReadProcessMemory(target->handle, (const void *)(ULONG_PTR)offset, buffer, buffer_size, &length))
1197     {
1198         if (read_len)
1199             *read_len = length;
1200     }
1201     else
1202     {
1203         hr = HRESULT_FROM_WIN32(GetLastError());
1204         WARN("Failed to read process memory %#lx.\n", hr);
1205     }
1206
1207     return hr;
1208 }
1209
1210 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteVirtual(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
1211         ULONG buffer_size, ULONG *written)
1212 {
1213     FIXME("%p, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1214
1215     return E_NOTIMPL;
1216 }
1217
1218 static HRESULT STDMETHODCALLTYPE debugdataspaces_SearchVirtual(IDebugDataSpaces *iface, ULONG64 offset, ULONG64 length,
1219         void *pattern, ULONG pattern_size, ULONG pattern_granularity, ULONG64 *ret_offset)
1220 {
1221     FIXME("%p, %s, %s, %p, %lu, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(length),
1222             pattern, pattern_size, pattern_granularity, ret_offset);
1223
1224     return E_NOTIMPL;
1225 }
1226
1227 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadVirtualUncached(IDebugDataSpaces *iface, ULONG64 offset,
1228         void *buffer, ULONG buffer_size, ULONG *read_len)
1229 {
1230     FIXME("%p, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1231
1232     return E_NOTIMPL;
1233 }
1234
1235 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteVirtualUncached(IDebugDataSpaces *iface, ULONG64 offset,
1236         void *buffer, ULONG buffer_size, ULONG *written)
1237 {
1238     FIXME("%p, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1239
1240     return E_NOTIMPL;
1241 }
1242
1243 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadPointersVirtual(IDebugDataSpaces *iface, ULONG count,
1244         ULONG64 offset, ULONG64 *pointers)
1245 {
1246     FIXME("%p, %lu, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset), pointers);
1247
1248     return E_NOTIMPL;
1249 }
1250
1251 static HRESULT STDMETHODCALLTYPE debugdataspaces_WritePointersVirtual(IDebugDataSpaces *iface, ULONG count,
1252         ULONG64 offset, ULONG64 *pointers)
1253 {
1254     FIXME("%p, %lu, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset), pointers);
1255
1256     return E_NOTIMPL;
1257 }
1258
1259 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadPhysical(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
1260         ULONG buffer_size, ULONG *read_len)
1261 {
1262     FIXME("%p, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1263
1264     return E_NOTIMPL;
1265 }
1266
1267 static HRESULT STDMETHODCALLTYPE debugdataspaces_WritePhysical(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
1268         ULONG buffer_size, ULONG *written)
1269 {
1270     FIXME("%p, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1271
1272     return E_NOTIMPL;
1273 }
1274
1275 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadControl(IDebugDataSpaces *iface, ULONG processor, ULONG64 offset,
1276         void *buffer, ULONG buffer_size, ULONG *read_len)
1277 {
1278     FIXME("%p, %lu, %s, %p, %lu, %p stub.\n", iface, processor, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1279
1280     return E_NOTIMPL;
1281 }
1282
1283 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteControl(IDebugDataSpaces *iface, ULONG processor, ULONG64 offset,
1284         void *buffer, ULONG buffer_size, ULONG *written)
1285 {
1286     FIXME("%p, %lu, %s, %p, %lu, %p stub.\n", iface, processor, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1287
1288     return E_NOTIMPL;
1289 }
1290
1291 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadIo(IDebugDataSpaces *iface, ULONG type, ULONG bus_number,
1292         ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG *read_len)
1293 {
1294     FIXME("%p, %lu, %lu, %lu, %s, %p, %lu, %p stub.\n", iface, type, bus_number, address_space, wine_dbgstr_longlong(offset),
1295             buffer, buffer_size, read_len);
1296
1297     return E_NOTIMPL;
1298 }
1299
1300 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteIo(IDebugDataSpaces *iface, ULONG type, ULONG bus_number,
1301         ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG *written)
1302 {
1303     FIXME("%p, %lu, %lu, %lu, %s, %p, %lu, %p stub.\n", iface, type, bus_number, address_space, wine_dbgstr_longlong(offset),
1304             buffer, buffer_size, written);
1305
1306     return E_NOTIMPL;
1307 }
1308
1309 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadMsr(IDebugDataSpaces *iface, ULONG msr, ULONG64 *value)
1310 {
1311     FIXME("%p, %lu, %p stub.\n", iface, msr, value);
1312
1313     return E_NOTIMPL;
1314 }
1315
1316 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteMsr(IDebugDataSpaces *iface, ULONG msr, ULONG64 value)
1317 {
1318     FIXME("%p, %lu, %s stub.\n", iface, msr, wine_dbgstr_longlong(value));
1319
1320     return E_NOTIMPL;
1321 }
1322
1323 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadBusData(IDebugDataSpaces *iface, ULONG data_type,
1324         ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG buffer_size, ULONG *read_len)
1325 {
1326     FIXME("%p, %lu, %lu, %lu, %lu, %p, %lu, %p stub.\n", iface, data_type, bus_number, slot_number, offset, buffer,
1327             buffer_size, read_len);
1328
1329     return E_NOTIMPL;
1330 }
1331
1332 static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteBusData(IDebugDataSpaces *iface, ULONG data_type,
1333         ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG buffer_size, ULONG *written)
1334 {
1335     FIXME("%p, %lu, %lu, %lu, %lu, %p, %lu, %p stub.\n", iface, data_type, bus_number, slot_number, offset, buffer,
1336             buffer_size, written);
1337
1338     return E_NOTIMPL;
1339 }
1340
1341 static HRESULT STDMETHODCALLTYPE debugdataspaces_CheckLowMemory(IDebugDataSpaces *iface)
1342 {
1343     FIXME("%p stub.\n", iface);
1344
1345     return E_NOTIMPL;
1346 }
1347
1348 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadDebuggerData(IDebugDataSpaces *iface, ULONG index, void *buffer,
1349         ULONG buffer_size, ULONG *data_size)
1350 {
1351     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, data_size);
1352
1353     return E_NOTIMPL;
1354 }
1355
1356 static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadProcessorSystemData(IDebugDataSpaces *iface, ULONG processor,
1357         ULONG index, void *buffer, ULONG buffer_size, ULONG *data_size)
1358 {
1359     FIXME("%p, %lu, %lu, %p, %lu, %p stub.\n", iface, processor, index, buffer, buffer_size, data_size);
1360
1361     return E_NOTIMPL;
1362 }
1363
1364 static const IDebugDataSpacesVtbl debugdataspacesvtbl =
1365 {
1366     debugdataspaces_QueryInterface,
1367     debugdataspaces_AddRef,
1368     debugdataspaces_Release,
1369     debugdataspaces_ReadVirtual,
1370     debugdataspaces_WriteVirtual,
1371     debugdataspaces_SearchVirtual,
1372     debugdataspaces_ReadVirtualUncached,
1373     debugdataspaces_WriteVirtualUncached,
1374     debugdataspaces_ReadPointersVirtual,
1375     debugdataspaces_WritePointersVirtual,
1376     debugdataspaces_ReadPhysical,
1377     debugdataspaces_WritePhysical,
1378     debugdataspaces_ReadControl,
1379     debugdataspaces_WriteControl,
1380     debugdataspaces_ReadIo,
1381     debugdataspaces_WriteIo,
1382     debugdataspaces_ReadMsr,
1383     debugdataspaces_WriteMsr,
1384     debugdataspaces_ReadBusData,
1385     debugdataspaces_WriteBusData,
1386     debugdataspaces_CheckLowMemory,
1387     debugdataspaces_ReadDebuggerData,
1388     debugdataspaces_ReadProcessorSystemData,
1389 };
1390
1391 static HRESULT STDMETHODCALLTYPE debugsymbols_QueryInterface(IDebugSymbols3 *iface, REFIID riid, void **obj)
1392 {
1393     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1394     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1395     return IUnknown_QueryInterface(unk, riid, obj);
1396 }
1397
1398 static ULONG STDMETHODCALLTYPE debugsymbols_AddRef(IDebugSymbols3 *iface)
1399 {
1400     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1401     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1402     return IUnknown_AddRef(unk);
1403 }
1404
1405 static ULONG STDMETHODCALLTYPE debugsymbols_Release(IDebugSymbols3 *iface)
1406 {
1407     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1408     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
1409     return IUnknown_Release(unk);
1410 }
1411
1412 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolOptions(IDebugSymbols3 *iface, ULONG *options)
1413 {
1414     FIXME("%p, %p stub.\n", iface, options);
1415
1416     return E_NOTIMPL;
1417 }
1418
1419 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSymbolOptions(IDebugSymbols3 *iface, ULONG options)
1420 {
1421     FIXME("%p, %#lx stub.\n", iface, options);
1422
1423     return E_NOTIMPL;
1424 }
1425
1426 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSymbolOptions(IDebugSymbols3 *iface, ULONG options)
1427 {
1428     FIXME("%p, %#lx stub.\n", iface, options);
1429
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolOptions(IDebugSymbols3 *iface, ULONG options)
1434 {
1435     FIXME("%p, %#lx stub.\n", iface, options);
1436
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffset(IDebugSymbols3 *iface, ULONG64 offset, char *buffer,
1441         ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
1442 {
1443     FIXME("%p, %s, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size,
1444             name_size, displacement);
1445
1446     return E_NOTIMPL;
1447 }
1448
1449 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByName(IDebugSymbols3 *iface, const char *symbol,
1450         ULONG64 *offset)
1451 {
1452     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), offset);
1453
1454     return E_NOTIMPL;
1455 }
1456
1457 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffset(IDebugSymbols3 *iface, ULONG64 offset, LONG delta,
1458         char *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
1459 {
1460     FIXME("%p, %s, %ld, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
1461             name_size, displacement);
1462
1463     return E_NOTIMPL;
1464 }
1465
1466 static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffset(IDebugSymbols3 *iface, ULONG64 offset, ULONG *line,
1467         char *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
1468 {
1469     FIXME("%p, %s, %p, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
1470             file_size, displacement);
1471
1472     return E_NOTIMPL;
1473 }
1474
1475 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLine(IDebugSymbols3 *iface, ULONG line, const char *file,
1476         ULONG64 *offset)
1477 {
1478     FIXME("%p, %lu, %s, %p stub.\n", iface, line, debugstr_a(file), offset);
1479
1480     return E_NOTIMPL;
1481 }
1482
1483 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNumberModules(IDebugSymbols3 *iface, ULONG *loaded, ULONG *unloaded)
1484 {
1485     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1486     static struct target_process *target;
1487     HRESULT hr;
1488
1489     TRACE("%p, %p, %p.\n", iface, loaded, unloaded);
1490
1491     if (!(target = debug_client_get_target(debug_client)))
1492         return E_UNEXPECTED;
1493
1494     if (FAILED(hr = debug_target_init_modules_info(target)))
1495         return hr;
1496
1497     *loaded = target->modules.loaded;
1498     *unloaded = target->modules.unloaded;
1499
1500     return S_OK;
1501 }
1502
1503 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByIndex(IDebugSymbols3 *iface, ULONG index, ULONG64 *base)
1504 {
1505     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1506     const struct module_info *info;
1507     struct target_process *target;
1508
1509     TRACE("%p, %lu, %p.\n", iface, index, base);
1510
1511     if (!(target = debug_client_get_target(debug_client)))
1512         return E_UNEXPECTED;
1513
1514     if (!(info = debug_target_get_module_info(target, index)))
1515         return E_INVALIDARG;
1516
1517     *base = info->params.Base;
1518
1519     return S_OK;
1520 }
1521
1522 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName(IDebugSymbols3 *iface, const char *name,
1523         ULONG start_index, ULONG *index, ULONG64 *base)
1524 {
1525     FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_a(name), start_index, index, base);
1526
1527     return E_NOTIMPL;
1528 }
1529
1530 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset(IDebugSymbols3 *iface, ULONG64 offset,
1531         ULONG start_index, ULONG *index, ULONG64 *base)
1532 {
1533     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1534     static struct target_process *target;
1535     const struct module_info *info;
1536
1537     TRACE("%p, %s, %lu, %p, %p.\n", iface, wine_dbgstr_longlong(offset), start_index, index, base);
1538
1539     if (!(target = debug_client_get_target(debug_client)))
1540         return E_UNEXPECTED;
1541
1542     while ((info = debug_target_get_module_info(target, start_index)))
1543     {
1544         if (offset >= info->params.Base && offset < info->params.Base + info->params.Size)
1545         {
1546             if (index)
1547                 *index = start_index;
1548             if (base)
1549                 *base = info->params.Base;
1550             return S_OK;
1551         }
1552
1553         start_index++;
1554     }
1555
1556     return E_INVALIDARG;
1557 }
1558
1559 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNames(IDebugSymbols3 *iface, ULONG index, ULONG64 base,
1560         char *image_name, ULONG image_name_buffer_size, ULONG *image_name_size, char *module_name,
1561         ULONG module_name_buffer_size, ULONG *module_name_size, char *loaded_image_name,
1562         ULONG loaded_image_name_buffer_size, ULONG *loaded_image_size)
1563 {
1564     FIXME("%p, %lu, %s, %p, %lu, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, index, wine_dbgstr_longlong(base),
1565             image_name, image_name_buffer_size, image_name_size, module_name, module_name_buffer_size,
1566             module_name_size, loaded_image_name, loaded_image_name_buffer_size, loaded_image_size);
1567
1568     return E_NOTIMPL;
1569 }
1570
1571 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleParameters(IDebugSymbols3 *iface, ULONG count, ULONG64 *bases,
1572         ULONG start, DEBUG_MODULE_PARAMETERS *params)
1573 {
1574     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1575     const struct module_info *info;
1576     struct target_process *target;
1577     unsigned int i;
1578
1579     TRACE("%p, %lu, %p, %lu, %p.\n", iface, count, bases, start, params);
1580
1581     if (!(target = debug_client_get_target(debug_client)))
1582         return E_UNEXPECTED;
1583
1584     if (bases)
1585     {
1586         for (i = 0; i < count; ++i)
1587         {
1588             if ((info = debug_target_get_module_info_by_base(target, bases[i])))
1589             {
1590                 params[i] = info->params;
1591             }
1592             else
1593             {
1594                 memset(&params[i], 0, sizeof(*params));
1595                 params[i].Base = DEBUG_INVALID_OFFSET;
1596             }
1597         }
1598     }
1599     else
1600     {
1601         for (i = start; i < start + count; ++i)
1602         {
1603             if (!(info = debug_target_get_module_info(target, i)))
1604                 return E_INVALIDARG;
1605             params[i] = info->params;
1606         }
1607     }
1608
1609     return S_OK;
1610 }
1611
1612 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModule(IDebugSymbols3 *iface, const char *symbol, ULONG64 *base)
1613 {
1614     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), base);
1615
1616     return E_NOTIMPL;
1617 }
1618
1619 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeName(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
1620         char *buffer, ULONG buffer_size, ULONG *name_size)
1621 {
1622     FIXME("%p, %s, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, buffer,
1623             buffer_size, name_size);
1624
1625     return E_NOTIMPL;
1626 }
1627
1628 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeId(IDebugSymbols3 *iface, ULONG64 base, const char *name,
1629         ULONG *type_id)
1630 {
1631     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), debugstr_a(name), type_id);
1632
1633     return E_NOTIMPL;
1634 }
1635
1636 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeSize(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
1637         ULONG *size)
1638 {
1639     FIXME("%p, %s, %lu, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, size);
1640
1641     return E_NOTIMPL;
1642 }
1643
1644 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffset(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
1645         const char *field, ULONG *offset)
1646 {
1647     FIXME("%p, %s, %lu, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, debugstr_a(field), offset);
1648
1649     return E_NOTIMPL;
1650 }
1651
1652 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeId(IDebugSymbols3 *iface, const char *symbol, ULONG *type_id,
1653         ULONG64 *base)
1654 {
1655     FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_a(symbol), type_id, base);
1656
1657     return E_NOTIMPL;
1658 }
1659
1660 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetTypeId(IDebugSymbols3 *iface, ULONG64 offset, ULONG *type_id,
1661         ULONG64 *base)
1662 {
1663     FIXME("%p, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), type_id, base);
1664
1665     return E_NOTIMPL;
1666 }
1667
1668 static HRESULT STDMETHODCALLTYPE debugsymbols_ReadTypedDataVirtual(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
1669         ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
1670 {
1671     FIXME("%p, %s, %s, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1672             type_id, buffer, buffer_size, read_len);
1673
1674     return E_NOTIMPL;
1675 }
1676
1677 static HRESULT STDMETHODCALLTYPE debugsymbols_WriteTypedDataVirtual(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
1678         ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
1679 {
1680     FIXME("%p, %s, %s, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1681             type_id, buffer, buffer_size, written);
1682
1683     return E_NOTIMPL;
1684 }
1685
1686 static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataVirtual(IDebugSymbols3 *iface, ULONG output_control,
1687         ULONG64 offset, ULONG64 base, ULONG type_id, ULONG flags)
1688 {
1689     FIXME("%p, %#lx, %s, %s, %lu, %#lx stub.\n", iface, output_control, wine_dbgstr_longlong(offset),
1690             wine_dbgstr_longlong(base), type_id, flags);
1691
1692     return E_NOTIMPL;
1693 }
1694
1695 static HRESULT STDMETHODCALLTYPE debugsymbols_ReadTypedDataPhysical(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
1696         ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
1697 {
1698     FIXME("%p, %s, %s, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1699             type_id, buffer, buffer_size, read_len);
1700
1701     return E_NOTIMPL;
1702 }
1703
1704 static HRESULT STDMETHODCALLTYPE debugsymbols_WriteTypedDataPhysical(IDebugSymbols3 *iface, ULONG64 offset,
1705         ULONG64 base, ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
1706 {
1707     FIXME("%p, %s, %s, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1708             type_id, buffer, buffer_size, written);
1709
1710     return E_NOTIMPL;
1711 }
1712
1713 static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataPhysical(IDebugSymbols3 *iface, ULONG output_control,
1714         ULONG64 offset, ULONG64 base, ULONG type_id, ULONG flags)
1715 {
1716     FIXME("%p, %#lx, %s, %s, %lu, %#lx stub.\n", iface, output_control, wine_dbgstr_longlong(offset),
1717             wine_dbgstr_longlong(base), type_id, flags);
1718
1719     return E_NOTIMPL;
1720 }
1721
1722 static HRESULT STDMETHODCALLTYPE debugsymbols_GetScope(IDebugSymbols3 *iface, ULONG64 *instr_offset,
1723         DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
1724 {
1725     FIXME("%p, %p, %p, %p, %lu stub.\n", iface, instr_offset, frame, scope_context, scope_context_size);
1726
1727     return E_NOTIMPL;
1728 }
1729
1730 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScope(IDebugSymbols3 *iface, ULONG64 instr_offset,
1731         DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
1732 {
1733     FIXME("%p, %s, %p, %p, %lu stub.\n", iface, wine_dbgstr_longlong(instr_offset), frame, scope_context,
1734             scope_context_size);
1735
1736     return E_NOTIMPL;
1737 }
1738
1739 static HRESULT STDMETHODCALLTYPE debugsymbols_ResetScope(IDebugSymbols3 *iface)
1740 {
1741     FIXME("%p stub.\n", iface);
1742
1743     return E_NOTIMPL;
1744 }
1745
1746 static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup(IDebugSymbols3 *iface, ULONG flags,
1747         IDebugSymbolGroup *update, IDebugSymbolGroup **symbols)
1748 {
1749     FIXME("%p, %#lx, %p, %p stub.\n", iface, flags, update, symbols);
1750
1751     return E_NOTIMPL;
1752 }
1753
1754 static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup(IDebugSymbols3 *iface, IDebugSymbolGroup **group)
1755 {
1756     FIXME("%p, %p stub.\n", iface, group);
1757
1758     return E_NOTIMPL;
1759 }
1760
1761 static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatch(IDebugSymbols3 *iface, const char *pattern,
1762         ULONG64 *handle)
1763 {
1764     FIXME("%p, %s, %p stub.\n", iface, pattern, handle);
1765
1766     return E_NOTIMPL;
1767 }
1768
1769 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatch(IDebugSymbols3 *iface, ULONG64 handle, char *buffer,
1770         ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
1771 {
1772     FIXME("%p, %s, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
1773
1774     return E_NOTIMPL;
1775 }
1776
1777 static HRESULT STDMETHODCALLTYPE debugsymbols_EndSymbolMatch(IDebugSymbols3 *iface, ULONG64 handle)
1778 {
1779     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
1780
1781     return E_NOTIMPL;
1782 }
1783
1784 static HRESULT STDMETHODCALLTYPE debugsymbols_Reload(IDebugSymbols3 *iface, const char *path)
1785 {
1786     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1787
1788     return E_NOTIMPL;
1789 }
1790
1791 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
1792         ULONG *path_size)
1793 {
1794     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
1795
1796     return E_NOTIMPL;
1797 }
1798
1799 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPath(IDebugSymbols3 *iface, const char *path)
1800 {
1801     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1802
1803     return E_NOTIMPL;
1804 }
1805
1806 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPath(IDebugSymbols3 *iface, const char *path)
1807 {
1808     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1809
1810     return E_NOTIMPL;
1811 }
1812
1813 static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
1814         ULONG *path_size)
1815 {
1816     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
1817
1818     return E_NOTIMPL;
1819 }
1820
1821 static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePath(IDebugSymbols3 *iface, const char *path)
1822 {
1823     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1824
1825     return E_NOTIMPL;
1826 }
1827
1828 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePath(IDebugSymbols3 *iface, const char *path)
1829 {
1830     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1831
1832     return E_NOTIMPL;
1833 }
1834
1835 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
1836         ULONG *path_size)
1837 {
1838     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
1839
1840     return E_NOTIMPL;
1841 }
1842
1843 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElement(IDebugSymbols3 *iface, ULONG index, char *buffer,
1844         ULONG buffer_size, ULONG *element_size)
1845 {
1846     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, element_size);
1847
1848     return E_NOTIMPL;
1849 }
1850
1851 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePath(IDebugSymbols3 *iface, const char *path)
1852 {
1853     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1854
1855     return E_NOTIMPL;
1856 }
1857
1858 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePath(IDebugSymbols3 *iface, const char *path)
1859 {
1860     FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1861
1862     return E_NOTIMPL;
1863 }
1864
1865 static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFile(IDebugSymbols3 *iface, ULONG start, const char *file,
1866         ULONG flags, ULONG *found_element, char *buffer, ULONG buffer_size, ULONG *found_size)
1867 {
1868     FIXME("%p, %lu, %s, %#lx, %p, %p, %lu, %p stub.\n", iface, start, debugstr_a(file), flags, found_element, buffer,
1869             buffer_size, found_size);
1870
1871     return E_NOTIMPL;
1872 }
1873
1874 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsets(IDebugSymbols3 *iface, const char *file,
1875         ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
1876 {
1877     FIXME("%p, %s, %p, %lu, %p stub.\n", iface, debugstr_a(file), buffer, buffer_lines, file_lines);
1878
1879     return E_NOTIMPL;
1880 }
1881
1882 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleVersionInformation(IDebugSymbols3 *iface, ULONG index,
1883         ULONG64 base, const char *item, void *buffer, ULONG buffer_size, ULONG *info_size)
1884 {
1885     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1886     const struct module_info *info;
1887     struct target_process *target;
1888     void *version_info, *ptr;
1889     HRESULT hr = E_FAIL;
1890     DWORD handle;
1891     UINT size;
1892
1893     TRACE("%p, %lu, %s, %s, %p, %lu, %p.\n", iface, index, wine_dbgstr_longlong(base), debugstr_a(item), buffer,
1894             buffer_size, info_size);
1895
1896     if (!(target = debug_client_get_target(debug_client)))
1897         return E_UNEXPECTED;
1898
1899     if (index == DEBUG_ANY_ID)
1900         info = debug_target_get_module_info_by_base(target, base);
1901     else
1902         info = debug_target_get_module_info(target, index);
1903
1904     if (!info)
1905     {
1906         WARN("Was unable to locate module.\n");
1907         return E_INVALIDARG;
1908     }
1909
1910     if (!(size = GetFileVersionInfoSizeA(info->image_name, &handle)))
1911         return E_FAIL;
1912
1913     if (!(version_info = malloc(size)))
1914         return E_OUTOFMEMORY;
1915
1916     if (GetFileVersionInfoA(info->image_name, handle, size, version_info))
1917     {
1918         if (VerQueryValueA(version_info, item, &ptr, &size))
1919         {
1920             if (info_size)
1921                 *info_size = size;
1922
1923             if (buffer && buffer_size)
1924             {
1925                 unsigned int dst_len = min(size, buffer_size);
1926                 if (dst_len)
1927                     memcpy(buffer, ptr, dst_len);
1928             }
1929
1930             hr = buffer && buffer_size < size ? S_FALSE : S_OK;
1931         }
1932     }
1933
1934     free(version_info);
1935
1936     return hr;
1937 }
1938
1939 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameString(IDebugSymbols3 *iface, ULONG which, ULONG index,
1940         ULONG64 base, char *buffer, ULONG buffer_size, ULONG *name_size)
1941 {
1942     struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
1943     const struct module_info *info;
1944     struct target_process *target;
1945     HRESULT hr;
1946
1947     TRACE("%p, %lu, %lu, %s, %p, %lu, %p.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
1948             name_size);
1949
1950     if (!(target = debug_client_get_target(debug_client)))
1951         return E_UNEXPECTED;
1952
1953     if (index == DEBUG_ANY_ID)
1954         info = debug_target_get_module_info_by_base(target, base);
1955     else
1956         info = debug_target_get_module_info(target, index);
1957
1958     if (!info)
1959     {
1960         WARN("Was unable to locate module.\n");
1961         return E_INVALIDARG;
1962     }
1963
1964     switch (which)
1965     {
1966         case DEBUG_MODNAME_IMAGE:
1967             hr = debug_target_return_string(info->image_name, buffer, buffer_size, name_size);
1968             break;
1969         case DEBUG_MODNAME_MODULE:
1970         case DEBUG_MODNAME_LOADED_IMAGE:
1971         case DEBUG_MODNAME_SYMBOL_FILE:
1972         case DEBUG_MODNAME_MAPPED_IMAGE:
1973             FIXME("Unsupported name info %ld.\n", which);
1974             return E_NOTIMPL;
1975         default:
1976             WARN("Unknown name info %ld.\n", which);
1977             return E_INVALIDARG;
1978     }
1979
1980     return hr;
1981 }
1982
1983 static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantName(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
1984         ULONG64 value, char *buffer, ULONG buffer_size, ULONG *name_size)
1985 {
1986     FIXME("%p, %s, %lu, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
1987             wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
1988
1989     return E_NOTIMPL;
1990 }
1991
1992 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldName(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
1993         ULONG field_index, char *buffer, ULONG buffer_size, ULONG *name_size)
1994 {
1995     FIXME("%p, %s, %lu, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
1996             buffer_size, name_size);
1997
1998     return E_NOTIMPL;
1999 }
2000
2001 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeOptions(IDebugSymbols3 *iface, ULONG *options)
2002 {
2003     FIXME("%p, %p stub.\n", iface, options);
2004
2005     return E_NOTIMPL;
2006 }
2007
2008 static HRESULT STDMETHODCALLTYPE debugsymbols_AddTypeOptions(IDebugSymbols3 *iface, ULONG options)
2009 {
2010     FIXME("%p, %#lx stub.\n", iface, options);
2011
2012     return E_NOTIMPL;
2013 }
2014
2015 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveTypeOptions(IDebugSymbols3 *iface, ULONG options)
2016 {
2017     FIXME("%p, %#lx stub.\n", iface, options);
2018
2019     return E_NOTIMPL;
2020 }
2021
2022 static HRESULT STDMETHODCALLTYPE debugsymbols_SetTypeOptions(IDebugSymbols3 *iface, ULONG options)
2023 {
2024     FIXME("%p, %#lx stub.\n", iface, options);
2025
2026     return E_NOTIMPL;
2027 }
2028
2029 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset, WCHAR *buffer,
2030         ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
2031 {
2032     FIXME("%p, %s, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, name_size,
2033             displacement);
2034
2035     return E_NOTIMPL;
2036 }
2037
2038 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2039         ULONG64 *offset)
2040 {
2041     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), offset);
2042
2043     return E_NOTIMPL;
2044 }
2045
2046 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset,
2047         LONG delta, WCHAR *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
2048 {
2049     FIXME("%p, %s, %ld, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
2050             name_size, displacement);
2051
2052     return E_NOTIMPL;
2053 }
2054
2055 static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset, ULONG *line,
2056         WCHAR *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
2057 {
2058     FIXME("%p, %s, %p, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
2059             file_size, displacement);
2060
2061     return E_NOTIMPL;
2062 }
2063
2064 static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLineWide(IDebugSymbols3 *iface, ULONG line, const WCHAR *file,
2065         ULONG64 *offset)
2066 {
2067     FIXME("%p, %lu, %s, %p stub.\n", iface, line, debugstr_w(file), offset);
2068
2069     return E_NOTIMPL;
2070 }
2071
2072 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleNameWide(IDebugSymbols3 *iface, const WCHAR *name,
2073         ULONG start_index, ULONG *index, ULONG64 *base)
2074 {
2075     FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_w(name), start_index, index, base);
2076
2077     return E_NOTIMPL;
2078 }
2079
2080 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModuleWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2081         ULONG64 *base)
2082 {
2083     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), base);
2084
2085     return E_NOTIMPL;
2086 }
2087
2088 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2089         WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2090 {
2091     FIXME("%p, %s, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, buffer, buffer_size,
2092             name_size);
2093
2094     return E_NOTIMPL;
2095 }
2096
2097 static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeIdWide(IDebugSymbols3 *iface, ULONG64 module, const WCHAR *name,
2098         ULONG *type_id)
2099 {
2100     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), debugstr_w(name), type_id);
2101
2102     return E_NOTIMPL;
2103 }
2104
2105 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffsetWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2106         const WCHAR *field, ULONG *offset)
2107 {
2108     FIXME("%p, %s, %lu, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, debugstr_w(field), offset);
2109
2110     return E_NOTIMPL;
2111 }
2112
2113 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeIdWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2114         ULONG *type_id, ULONG64 *module)
2115 {
2116     FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_w(symbol), type_id, module);
2117
2118     return E_NOTIMPL;
2119 }
2120
2121 static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup2(IDebugSymbols3 *iface, ULONG flags,
2122         PDEBUG_SYMBOL_GROUP2 update, PDEBUG_SYMBOL_GROUP2 *symbols)
2123 {
2124     FIXME("%p, %#lx, %p, %p stub.\n", iface, flags, update, symbols);
2125
2126     return E_NOTIMPL;
2127 }
2128
2129 static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup2(IDebugSymbols3 *iface, PDEBUG_SYMBOL_GROUP2 *group)
2130 {
2131     FIXME("%p, %p stub.\n", iface, group);
2132
2133     return E_NOTIMPL;
2134 }
2135
2136 static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatchWide(IDebugSymbols3 *iface, const WCHAR *pattern,
2137         ULONG64 *handle)
2138 {
2139     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(pattern), handle);
2140
2141     return E_NOTIMPL;
2142 }
2143
2144 static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatchWide(IDebugSymbols3 *iface, ULONG64 handle,
2145         WCHAR *buffer, ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
2146 {
2147     FIXME("%p, %s, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
2148
2149     return E_NOTIMPL;
2150 }
2151
2152 static HRESULT STDMETHODCALLTYPE debugsymbols_ReloadWide(IDebugSymbols3 *iface, const WCHAR *module)
2153 {
2154     FIXME("%p, %s stub.\n", iface, debugstr_w(module));
2155
2156     return E_NOTIMPL;
2157 }
2158
2159 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2160         ULONG *path_size)
2161 {
2162     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
2163
2164     return E_NOTIMPL;
2165 }
2166
2167 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *path)
2168 {
2169     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2170
2171     return E_NOTIMPL;
2172 }
2173
2174 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2175 {
2176     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2177
2178     return E_NOTIMPL;
2179 }
2180
2181 static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2182         ULONG *path_size)
2183 {
2184     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
2185
2186     return E_NOTIMPL;
2187 }
2188
2189 static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePathWide(IDebugSymbols3 *iface, const WCHAR *path)
2190 {
2191     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2192
2193     return E_NOTIMPL;
2194 }
2195
2196 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2197 {
2198     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2199
2200     return E_NOTIMPL;
2201 }
2202
2203 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
2204         ULONG *path_size)
2205 {
2206     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, path_size);
2207
2208     return E_NOTIMPL;
2209 }
2210
2211 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElementWide(IDebugSymbols3 *iface, ULONG index,
2212         WCHAR *buffer, ULONG buffer_size, ULONG *element_size)
2213 {
2214     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, element_size);
2215
2216     return E_NOTIMPL;
2217 }
2218
2219 static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePathWide(IDebugSymbols3 *iface, const WCHAR *path)
2220 {
2221     FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2222
2223     return E_NOTIMPL;
2224 }
2225
2226 static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2227 {
2228     FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2229
2230     return E_NOTIMPL;
2231 }
2232
2233 static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFileWide(IDebugSymbols3 *iface, ULONG start_element,
2234         const WCHAR *file, ULONG flags, ULONG *found_element, WCHAR *buffer, ULONG buffer_size, ULONG *found_size)
2235 {
2236     FIXME("%p, %lu, %s, %#lx, %p, %p, %lu, %p stub.\n", iface, start_element, debugstr_w(file), flags, found_element,
2237             buffer, buffer_size, found_size);
2238
2239     return E_NOTIMPL;
2240 }
2241
2242 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsetsWide(IDebugSymbols3 *iface, const WCHAR *file,
2243         ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
2244 {
2245     FIXME("%p, %s, %p, %lu, %p stub.\n", iface, debugstr_w(file), buffer, buffer_lines, file_lines);
2246
2247     return E_NOTIMPL;
2248 }
2249
2250 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleVersionInformationWide(IDebugSymbols3 *iface, ULONG index,
2251         ULONG64 base, const WCHAR *item, void *buffer, ULONG buffer_size, ULONG *version_info_size)
2252 {
2253     FIXME("%p, %lu, %s, %s, %p, %lu, %p stub.\n", iface, index, wine_dbgstr_longlong(base), debugstr_w(item), buffer,
2254             buffer_size, version_info_size);
2255
2256     return E_NOTIMPL;
2257 }
2258
2259 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameStringWide(IDebugSymbols3 *iface, ULONG which, ULONG index,
2260         ULONG64 base, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2261 {
2262     FIXME("%p, %lu, %lu, %s, %p, %lu, %p stub.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
2263             name_size);
2264
2265     return E_NOTIMPL;
2266 }
2267
2268 static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2269         ULONG64 value, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2270 {
2271     FIXME("%p, %s, %lu, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
2272             wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
2273
2274     return E_NOTIMPL;
2275 }
2276
2277 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
2278         ULONG field_index, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2279 {
2280     FIXME("%p, %s, %lu, %lu, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
2281             buffer_size, name_size);
2282
2283     return E_NOTIMPL;
2284 }
2285
2286 static HRESULT STDMETHODCALLTYPE debugsymbols_IsManagedModule(IDebugSymbols3 *iface, ULONG index, ULONG64 base)
2287 {
2288     FIXME("%p, %lu, %s stub.\n", iface, index, wine_dbgstr_longlong(base));
2289
2290     return E_NOTIMPL;
2291 }
2292
2293 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2(IDebugSymbols3 *iface, const char *name,
2294         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2295 {
2296     FIXME("%p, %s, %lu, %#lx, %p, %p stub.\n", iface, debugstr_a(name), start_index, flags, index, base);
2297
2298     return E_NOTIMPL;
2299 }
2300
2301 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2Wide(IDebugSymbols3 *iface, const WCHAR *name,
2302         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2303 {
2304     FIXME("%p, %s, %lu, %#lx, %p, %p stub.\n", iface, debugstr_w(name), start_index, flags, index, base);
2305
2306     return E_NOTIMPL;
2307 }
2308
2309 static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset2(IDebugSymbols3 *iface, ULONG64 offset,
2310         ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2311 {
2312     FIXME("%p, %s, %lu, %#lx, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), start_index, flags, index, base);
2313
2314     return E_NOTIMPL;
2315 }
2316
2317 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModule(IDebugSymbols3 *iface, ULONG64 base, ULONG size,
2318         const char *image_path, const char *module_name, ULONG flags)
2319 {
2320     FIXME("%p, %s, %lu, %s, %s, %#lx stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_a(image_path),
2321             debugstr_a(module_name), flags);
2322
2323     return E_NOTIMPL;
2324 }
2325
2326 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModuleWide(IDebugSymbols3 *iface, ULONG64 base, ULONG size,
2327         const WCHAR *image_path, const WCHAR *module_name, ULONG flags)
2328 {
2329     FIXME("%p, %s, %lu, %s, %s, %#lx stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_w(image_path),
2330             debugstr_w(module_name), flags);
2331
2332     return E_NOTIMPL;
2333 }
2334
2335 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticModule(IDebugSymbols3 *iface, ULONG64 base)
2336 {
2337     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(base));
2338
2339     return E_NOTIMPL;
2340 }
2341
2342 static HRESULT STDMETHODCALLTYPE debugsymbols_GetCurrentScopeFrameIndex(IDebugSymbols3 *iface, ULONG *index)
2343 {
2344     FIXME("%p, %p stub.\n", iface, index);
2345
2346     return E_NOTIMPL;
2347 }
2348
2349 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFrameByIndex(IDebugSymbols3 *iface, ULONG index)
2350 {
2351     FIXME("%p, %lu stub.\n", iface, index);
2352
2353     return E_NOTIMPL;
2354 }
2355
2356 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromJitDebugInfo(IDebugSymbols3 *iface, ULONG output_control,
2357         ULONG64 info_offset)
2358 {
2359     FIXME("%p, %lu, %s stub.\n", iface, output_control, wine_dbgstr_longlong(info_offset));
2360
2361     return E_NOTIMPL;
2362 }
2363
2364 static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromStoredEvent(IDebugSymbols3 *iface)
2365 {
2366     FIXME("%p stub.\n", iface);
2367
2368     return E_NOTIMPL;
2369 }
2370
2371 static HRESULT STDMETHODCALLTYPE debugsymbols_OutputSymbolByOffset(IDebugSymbols3 *iface, ULONG output_control,
2372         ULONG flags, ULONG64 offset)
2373 {
2374     FIXME("%p, %lu, %#lx, %s stub.\n", iface, output_control, flags, wine_dbgstr_longlong(offset));
2375
2376     return E_NOTIMPL;
2377 }
2378
2379 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFunctionEntryByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2380         ULONG flags, void *buffer, ULONG buffer_size, ULONG *needed_size)
2381 {
2382     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
2383             needed_size);
2384
2385     return E_NOTIMPL;
2386 }
2387
2388 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffset(IDebugSymbols3 *iface, ULONG64 module,
2389         ULONG container_type_id, const char *field, ULONG *field_type_id, ULONG *offset)
2390 {
2391     FIXME("%p, %s, %lu, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_a(field),
2392             field_type_id, offset);
2393
2394     return E_NOTIMPL;
2395 }
2396
2397 static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffsetWide(IDebugSymbols3 *iface, ULONG64 module,
2398         ULONG container_type_id, const WCHAR *field, ULONG *field_type_id, ULONG *offset)
2399 {
2400     FIXME("%p, %s, %lu, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_w(field),
2401             field_type_id, offset);
2402
2403     return E_NOTIMPL;
2404 }
2405
2406 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbol(IDebugSymbols3 *iface, ULONG64 offset, ULONG size,
2407         const char *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
2408 {
2409     FIXME("%p, %s, %lu, %s, %#lx, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_a(name), flags, id);
2410
2411     return E_NOTIMPL;
2412 }
2413
2414 static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbolWide(IDebugSymbols3 *iface, ULONG64 offset, ULONG size,
2415         const WCHAR *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
2416 {
2417     FIXME("%p, %s, %lu, %s, %#lx, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_w(name), flags, id);
2418
2419     return E_NOTIMPL;
2420 }
2421
2422 static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticSymbol(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id)
2423 {
2424     FIXME("%p, %p stub.\n", iface, id);
2425
2426     return E_NOTIMPL;
2427 }
2428
2429 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2430         ULONG flags, DEBUG_MODULE_AND_ID *ids, LONG64 *displacements, ULONG count, ULONG *entries)
2431 {
2432     FIXME("%p, %s, %#lx, %p, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, ids, displacements, count,
2433             entries);
2434
2435     return E_NOTIMPL;
2436 }
2437
2438 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByName(IDebugSymbols3 *iface, const char *symbol,
2439         ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
2440 {
2441     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, debugstr_a(symbol), flags, ids, count, entries);
2442
2443     return E_NOTIMPL;
2444 }
2445
2446 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2447         ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
2448 {
2449     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, debugstr_w(symbol), flags, ids, count, entries);
2450
2451     return E_NOTIMPL;
2452 }
2453
2454 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryByToken(IDebugSymbols3 *iface, ULONG64 base, ULONG token,
2455         DEBUG_MODULE_AND_ID *id)
2456 {
2457     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), id);
2458
2459     return E_NOTIMPL;
2460 }
2461
2462 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryInformation(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2463         DEBUG_SYMBOL_ENTRY *info)
2464 {
2465     FIXME("%p, %p, %p stub.\n", iface, id, info);
2466
2467     return E_NOTIMPL;
2468 }
2469
2470 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryString(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2471         ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
2472 {
2473     FIXME("%p, %p, %lu, %p, %lu, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
2474
2475     return E_NOTIMPL;
2476 }
2477
2478 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryStringWide(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2479         ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
2480 {
2481     FIXME("%p, %p, %lu, %p, %lu, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
2482
2483     return E_NOTIMPL;
2484 }
2485
2486 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryOffsetRegions(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
2487         ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG regions_count, ULONG *regions_avail)
2488 {
2489     FIXME("%p, %p, %#lx, %p, %lu, %p stub.\n", iface, id, flags, regions, regions_count, regions_avail);
2490
2491     return E_NOTIMPL;
2492 }
2493
2494 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryBySymbolEntry(IDebugSymbols3 *iface,
2495         DEBUG_MODULE_AND_ID *from_id, ULONG flags, DEBUG_MODULE_AND_ID *to_id)
2496 {
2497     FIXME("%p, %p, %#lx, %p stub.\n", iface, from_id, flags, to_id);
2498
2499     return E_NOTIMPL;
2500 }
2501
2502 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByOffset(IDebugSymbols3 *iface, ULONG64 offset,
2503         ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2504 {
2505     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, entries, count, entries_avail);
2506
2507     return E_NOTIMPL;
2508 }
2509
2510 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLine(IDebugSymbols3 *iface, ULONG line,
2511         const char *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2512 {
2513     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, debugstr_a(file), flags, entries, count, entries_avail);
2514
2515     return E_NOTIMPL;
2516 }
2517
2518 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLineWide(IDebugSymbols3 *iface, ULONG line,
2519         const WCHAR *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2520 {
2521     FIXME("%p, %s, %#lx, %p, %lu, %p stub.\n", iface, debugstr_w(file), flags, entries, count, entries_avail);
2522
2523     return E_NOTIMPL;
2524 }
2525
2526 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryString(IDebugSymbols3 *iface,
2527         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
2528 {
2529     FIXME("%p, %p, %lu, %p, %lu, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
2530
2531     return E_NOTIMPL;
2532 }
2533
2534 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryStringWide(IDebugSymbols3 *iface,
2535         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
2536 {
2537     FIXME("%p, %p, %lu, %p, %lu, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
2538
2539     return E_NOTIMPL;
2540 }
2541
2542 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryOffsetRegions(IDebugSymbols3 *iface,
2543         DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG count, ULONG *regions_avail)
2544 {
2545     FIXME("%p, %p, %#lx, %p, %lu, %p stub.\n", iface, entry, flags, regions, count, regions_avail);
2546
2547     return E_NOTIMPL;
2548 }
2549
2550 static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryBySourceEntry(IDebugSymbols3 *iface,
2551         DEBUG_SYMBOL_SOURCE_ENTRY *from_entry, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *to_entry)
2552 {
2553     FIXME("%p, %p, %#lx, %p stub.\n", iface, from_entry, flags, to_entry);
2554
2555     return E_NOTIMPL;
2556 }
2557
2558 static const IDebugSymbols3Vtbl debugsymbolsvtbl =
2559 {
2560     debugsymbols_QueryInterface,
2561     debugsymbols_AddRef,
2562     debugsymbols_Release,
2563     debugsymbols_GetSymbolOptions,
2564     debugsymbols_AddSymbolOptions,
2565     debugsymbols_RemoveSymbolOptions,
2566     debugsymbols_SetSymbolOptions,
2567     debugsymbols_GetNameByOffset,
2568     debugsymbols_GetOffsetByName,
2569     debugsymbols_GetNearNameByOffset,
2570     debugsymbols_GetLineByOffset,
2571     debugsymbols_GetOffsetByLine,
2572     debugsymbols_GetNumberModules,
2573     debugsymbols_GetModuleByIndex,
2574     debugsymbols_GetModuleByModuleName,
2575     debugsymbols_GetModuleByOffset,
2576     debugsymbols_GetModuleNames,
2577     debugsymbols_GetModuleParameters,
2578     debugsymbols_GetSymbolModule,
2579     debugsymbols_GetTypeName,
2580     debugsymbols_GetTypeId,
2581     debugsymbols_GetTypeSize,
2582     debugsymbols_GetFieldOffset,
2583     debugsymbols_GetSymbolTypeId,
2584     debugsymbols_GetOffsetTypeId,
2585     debugsymbols_ReadTypedDataVirtual,
2586     debugsymbols_WriteTypedDataVirtual,
2587     debugsymbols_OutputTypedDataVirtual,
2588     debugsymbols_ReadTypedDataPhysical,
2589     debugsymbols_WriteTypedDataPhysical,
2590     debugsymbols_OutputTypedDataPhysical,
2591     debugsymbols_GetScope,
2592     debugsymbols_SetScope,
2593     debugsymbols_ResetScope,
2594     debugsymbols_GetScopeSymbolGroup,
2595     debugsymbols_CreateSymbolGroup,
2596     debugsymbols_StartSymbolMatch,
2597     debugsymbols_GetNextSymbolMatch,
2598     debugsymbols_EndSymbolMatch,
2599     debugsymbols_Reload,
2600     debugsymbols_GetSymbolPath,
2601     debugsymbols_SetSymbolPath,
2602     debugsymbols_AppendSymbolPath,
2603     debugsymbols_GetImagePath,
2604     debugsymbols_SetImagePath,
2605     debugsymbols_AppendImagePath,
2606     debugsymbols_GetSourcePath,
2607     debugsymbols_GetSourcePathElement,
2608     debugsymbols_SetSourcePath,
2609     debugsymbols_AppendSourcePath,
2610     debugsymbols_FindSourceFile,
2611     debugsymbols_GetSourceFileLineOffsets,
2612     /* IDebugSymbols2 */
2613     debugsymbols_GetModuleVersionInformation,
2614     debugsymbols_GetModuleNameString,
2615     debugsymbols_GetConstantName,
2616     debugsymbols_GetFieldName,
2617     debugsymbols_GetTypeOptions,
2618     debugsymbols_AddTypeOptions,
2619     debugsymbols_RemoveTypeOptions,
2620     debugsymbols_SetTypeOptions,
2621     /* IDebugSymbols3 */
2622     debugsymbols_GetNameByOffsetWide,
2623     debugsymbols_GetOffsetByNameWide,
2624     debugsymbols_GetNearNameByOffsetWide,
2625     debugsymbols_GetLineByOffsetWide,
2626     debugsymbols_GetOffsetByLineWide,
2627     debugsymbols_GetModuleByModuleNameWide,
2628     debugsymbols_GetSymbolModuleWide,
2629     debugsymbols_GetTypeNameWide,
2630     debugsymbols_GetTypeIdWide,
2631     debugsymbols_GetFieldOffsetWide,
2632     debugsymbols_GetSymbolTypeIdWide,
2633     debugsymbols_GetScopeSymbolGroup2,
2634     debugsymbols_CreateSymbolGroup2,
2635     debugsymbols_StartSymbolMatchWide,
2636     debugsymbols_GetNextSymbolMatchWide,
2637     debugsymbols_ReloadWide,
2638     debugsymbols_GetSymbolPathWide,
2639     debugsymbols_SetSymbolPathWide,
2640     debugsymbols_AppendSymbolPathWide,
2641     debugsymbols_GetImagePathWide,
2642     debugsymbols_SetImagePathWide,
2643     debugsymbols_AppendImagePathWide,
2644     debugsymbols_GetSourcePathWide,
2645     debugsymbols_GetSourcePathElementWide,
2646     debugsymbols_SetSourcePathWide,
2647     debugsymbols_AppendSourcePathWide,
2648     debugsymbols_FindSourceFileWide,
2649     debugsymbols_GetSourceFileLineOffsetsWide,
2650     debugsymbols_GetModuleVersionInformationWide,
2651     debugsymbols_GetModuleNameStringWide,
2652     debugsymbols_GetConstantNameWide,
2653     debugsymbols_GetFieldNameWide,
2654     debugsymbols_IsManagedModule,
2655     debugsymbols_GetModuleByModuleName2,
2656     debugsymbols_GetModuleByModuleName2Wide,
2657     debugsymbols_GetModuleByOffset2,
2658     debugsymbols_AddSyntheticModule,
2659     debugsymbols_AddSyntheticModuleWide,
2660     debugsymbols_RemoveSyntheticModule,
2661     debugsymbols_GetCurrentScopeFrameIndex,
2662     debugsymbols_SetScopeFrameByIndex,
2663     debugsymbols_SetScopeFromJitDebugInfo,
2664     debugsymbols_SetScopeFromStoredEvent,
2665     debugsymbols_OutputSymbolByOffset,
2666     debugsymbols_GetFunctionEntryByOffset,
2667     debugsymbols_GetFieldTypeAndOffset,
2668     debugsymbols_GetFieldTypeAndOffsetWide,
2669     debugsymbols_AddSyntheticSymbol,
2670     debugsymbols_AddSyntheticSymbolWide,
2671     debugsymbols_RemoveSyntheticSymbol,
2672     debugsymbols_GetSymbolEntriesByOffset,
2673     debugsymbols_GetSymbolEntriesByName,
2674     debugsymbols_GetSymbolEntriesByNameWide,
2675     debugsymbols_GetSymbolEntryByToken,
2676     debugsymbols_GetSymbolEntryInformation,
2677     debugsymbols_GetSymbolEntryString,
2678     debugsymbols_GetSymbolEntryStringWide,
2679     debugsymbols_GetSymbolEntryOffsetRegions,
2680     debugsymbols_GetSymbolEntryBySymbolEntry,
2681     debugsymbols_GetSourceEntriesByOffset,
2682     debugsymbols_GetSourceEntriesByLine,
2683     debugsymbols_GetSourceEntriesByLineWide,
2684     debugsymbols_GetSourceEntryString,
2685     debugsymbols_GetSourceEntryStringWide,
2686     debugsymbols_GetSourceEntryOffsetRegions,
2687     debugsymbols_GetSourceEntryBySourceEntry,
2688 };
2689
2690 static HRESULT STDMETHODCALLTYPE debugcontrol_QueryInterface(IDebugControl4 *iface, REFIID riid, void **obj)
2691 {
2692     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2693     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2694     return IUnknown_QueryInterface(unk, riid, obj);
2695 }
2696
2697 static ULONG STDMETHODCALLTYPE debugcontrol_AddRef(IDebugControl4 *iface)
2698 {
2699     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2700     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2701     return IUnknown_AddRef(unk);
2702 }
2703
2704 static ULONG STDMETHODCALLTYPE debugcontrol_Release(IDebugControl4 *iface)
2705 {
2706     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2707     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
2708     return IUnknown_Release(unk);
2709 }
2710
2711 static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterrupt(IDebugControl4 *iface)
2712 {
2713     FIXME("%p stub.\n", iface);
2714
2715     return E_NOTIMPL;
2716 }
2717
2718 static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterrupt(IDebugControl4 *iface, ULONG flags)
2719 {
2720     FIXME("%p, %#lx stub.\n", iface, flags);
2721
2722     return E_NOTIMPL;
2723 }
2724
2725 static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterruptTimeout(IDebugControl4 *iface, ULONG *timeout)
2726 {
2727     FIXME("%p, %p stub.\n", iface, timeout);
2728
2729     return E_NOTIMPL;
2730 }
2731
2732 static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterruptTimeout(IDebugControl4 *iface, ULONG timeout)
2733 {
2734     FIXME("%p, %lu stub.\n", iface, timeout);
2735
2736     return E_NOTIMPL;
2737 }
2738
2739 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
2740         ULONG *file_size, BOOL *append)
2741 {
2742     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
2743
2744     return E_NOTIMPL;
2745 }
2746
2747 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile(IDebugControl4 *iface, const char *file, BOOL append)
2748 {
2749     FIXME("%p, %s, %d stub.\n", iface, debugstr_a(file), append);
2750
2751     return E_NOTIMPL;
2752 }
2753 static HRESULT STDMETHODCALLTYPE debugcontrol_CloseLogFile(IDebugControl4 *iface)
2754 {
2755     FIXME("%p stub.\n", iface);
2756
2757     return E_NOTIMPL;
2758 }
2759 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogMask(IDebugControl4 *iface, ULONG *mask)
2760 {
2761     FIXME("%p, %p stub.\n", iface, mask);
2762
2763     return E_NOTIMPL;
2764 }
2765
2766 static HRESULT STDMETHODCALLTYPE debugcontrol_SetLogMask(IDebugControl4 *iface, ULONG mask)
2767 {
2768     FIXME("%p, %#lx stub.\n", iface, mask);
2769
2770     return E_NOTIMPL;
2771 }
2772
2773 static HRESULT STDMETHODCALLTYPE debugcontrol_Input(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
2774         ULONG *input_size)
2775 {
2776     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, input_size);
2777
2778     return E_NOTIMPL;
2779 }
2780
2781 static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInput(IDebugControl4 *iface, const char *buffer)
2782 {
2783     FIXME("%p, %s stub.\n", iface, debugstr_a(buffer));
2784
2785     return E_NOTIMPL;
2786 }
2787
2788 static HRESULT STDMETHODVCALLTYPE debugcontrol_Output(IDebugControl4 *iface, ULONG mask, const char *format, ...)
2789 {
2790     FIXME("%p, %#lx, %s stub.\n", iface, mask, debugstr_a(format));
2791
2792     return E_NOTIMPL;
2793 }
2794
2795 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl4 *iface, ULONG mask, const char *format,
2796         va_list args)
2797 {
2798     FIXME("%p, %#lx, %s stub.\n", iface, mask, debugstr_a(format));
2799
2800     return E_NOTIMPL;
2801 }
2802
2803 static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl4 *iface, ULONG output_control,
2804         ULONG mask, const char *format, ...)
2805 {
2806     FIXME("%p, %lu, %#lx, %s stub.\n", iface, output_control, mask, debugstr_a(format));
2807
2808     return E_NOTIMPL;
2809 }
2810
2811 static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugControl4 *iface, ULONG output_control,
2812         ULONG mask, const char *format, va_list args)
2813 {
2814     FIXME("%p, %lu, %#lx, %s stub.\n", iface, output_control, mask, debugstr_a(format));
2815
2816     return E_NOTIMPL;
2817 }
2818
2819 static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl4 *iface, ULONG output_control,
2820         const char *format, ...)
2821 {
2822     FIXME("%p, %lu, %s stub.\n", iface, output_control, debugstr_a(format));
2823
2824     return E_NOTIMPL;
2825 }
2826
2827 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl4 *iface, ULONG output_control,
2828         const char *format, va_list args)
2829 {
2830     FIXME("%p, %lu, %s stub.\n", iface, output_control, debugstr_a(format));
2831
2832     return E_NOTIMPL;
2833 }
2834
2835 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptText(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
2836         ULONG *text_size)
2837 {
2838     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, text_size);
2839
2840     return E_NOTIMPL;
2841 }
2842
2843 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl4 *iface, ULONG output_control,
2844         ULONG flags)
2845 {
2846     FIXME("%p, %lu, %#lx stub.\n", iface, output_control, flags);
2847
2848     return E_NOTIMPL;
2849 }
2850
2851 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVersionInformation(IDebugControl4 *iface, ULONG output_control)
2852 {
2853     FIXME("%p, %lu stub.\n", iface, output_control);
2854
2855     return E_NOTIMPL;
2856 }
2857
2858 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNotifyEventHandle(IDebugControl4 *iface, ULONG64 *handle)
2859 {
2860     FIXME("%p, %p stub.\n", iface, handle);
2861
2862     return E_NOTIMPL;
2863 }
2864
2865 static HRESULT STDMETHODCALLTYPE debugcontrol_SetNotifyEventHandle(IDebugControl4 *iface, ULONG64 handle)
2866 {
2867     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
2868
2869     return E_NOTIMPL;
2870 }
2871
2872 static HRESULT STDMETHODCALLTYPE debugcontrol_Assemble(IDebugControl4 *iface, ULONG64 offset, const char *code,
2873         ULONG64 *end_offset)
2874 {
2875     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), debugstr_a(code), end_offset);
2876
2877     return E_NOTIMPL;
2878 }
2879
2880 static HRESULT STDMETHODCALLTYPE debugcontrol_Disassemble(IDebugControl4 *iface, ULONG64 offset, ULONG flags,
2881         char *buffer, ULONG buffer_size, ULONG *disassm_size, ULONG64 *end_offset)
2882 {
2883     FIXME("%p, %s, %#lx, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
2884             disassm_size, end_offset);
2885
2886     return E_NOTIMPL;
2887 }
2888
2889 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDisassembleEffectiveOffset(IDebugControl4 *iface, ULONG64 *offset)
2890 {
2891     FIXME("%p, %p stub.\n", iface, offset);
2892
2893     return E_NOTIMPL;
2894 }
2895
2896 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl4 *iface, ULONG output_control,
2897         ULONG64 offset, ULONG flags, ULONG64 *end_offset)
2898 {
2899     FIXME("%p, %lu, %s, %#lx, %p stub.\n", iface, output_control, wine_dbgstr_longlong(offset), flags, end_offset);
2900
2901     return E_NOTIMPL;
2902 }
2903
2904 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugControl4 *iface, ULONG output_control,
2905         ULONG prev_lines, ULONG total_lines, ULONG64 offset, ULONG flags, ULONG *offset_line, ULONG64 *start_offset,
2906         ULONG64 *end_offset, ULONG64 *line_offsets)
2907 {
2908     FIXME("%p, %lu, %lu, %lu, %s, %#lx, %p, %p, %p, %p stub.\n", iface, output_control, prev_lines, total_lines,
2909             wine_dbgstr_longlong(offset), flags, offset_line, start_offset, end_offset, line_offsets);
2910
2911     return E_NOTIMPL;
2912 }
2913
2914 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNearInstruction(IDebugControl4 *iface, ULONG64 offset, LONG delta,
2915         ULONG64 *instr_offset)
2916 {
2917     FIXME("%p, %s, %ld, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, instr_offset);
2918
2919     return E_NOTIMPL;
2920 }
2921
2922 static HRESULT STDMETHODCALLTYPE debugcontrol_GetStackTrace(IDebugControl4 *iface, ULONG64 frame_offset,
2923         ULONG64 stack_offset, ULONG64 instr_offset, DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG *frames_filled)
2924 {
2925     FIXME("%p, %s, %s, %s, %p, %lu, %p stub.\n", iface, wine_dbgstr_longlong(frame_offset),
2926             wine_dbgstr_longlong(stack_offset), wine_dbgstr_longlong(instr_offset), frames, frames_size, frames_filled);
2927
2928     return E_NOTIMPL;
2929 }
2930
2931 static HRESULT STDMETHODCALLTYPE debugcontrol_GetReturnOffset(IDebugControl4 *iface, ULONG64 *offset)
2932 {
2933     FIXME("%p, %p stub.\n", iface, offset);
2934
2935     return E_NOTIMPL;
2936 }
2937
2938 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl4 *iface, ULONG output_control,
2939         DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG flags)
2940 {
2941     FIXME("%p, %lu, %p, %lu, %#lx stub.\n", iface, output_control, frames, frames_size, flags);
2942
2943     return E_NOTIMPL;
2944 }
2945
2946 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl4 *iface, ULONG *debug_class,
2947         ULONG *qualifier)
2948 {
2949     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2950     static struct target_process *target;
2951
2952     FIXME("%p, %p, %p stub.\n", iface, debug_class, qualifier);
2953
2954     *debug_class = DEBUG_CLASS_UNINITIALIZED;
2955     *qualifier = 0;
2956
2957     if (!(target = debug_client_get_target(debug_client)))
2958         return E_UNEXPECTED;
2959
2960     *debug_class = DEBUG_CLASS_USER_WINDOWS;
2961     *qualifier = DEBUG_USER_WINDOWS_PROCESS;
2962
2963     return S_OK;
2964 }
2965
2966 static HRESULT STDMETHODCALLTYPE debugcontrol_GetActualProcessorType(IDebugControl4 *iface, ULONG *type)
2967 {
2968     FIXME("%p, %p stub.\n", iface, type);
2969
2970     return E_NOTIMPL;
2971 }
2972
2973 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutingProcessorType(IDebugControl4 *iface, ULONG *type)
2974 {
2975     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
2976     static struct target_process *target;
2977     HRESULT hr;
2978
2979     TRACE("%p, %p.\n", iface, type);
2980
2981     if (!(target = debug_client_get_target(debug_client)))
2982         return E_UNEXPECTED;
2983
2984     if (FAILED(hr = debug_target_init_modules_info(target)))
2985         return hr;
2986
2987     *type = target->cpu_type;
2988
2989     return S_OK;
2990 }
2991
2992 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberPossibleExecutingProcessorTypes(IDebugControl4 *iface,
2993         ULONG *count)
2994 {
2995     FIXME("%p, %p stub.\n", iface, count);
2996
2997     return E_NOTIMPL;
2998 }
2999
3000 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPossibleExecutingProcessorTypes(IDebugControl4 *iface, ULONG start,
3001         ULONG count, ULONG *types)
3002 {
3003     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, types);
3004
3005     return E_NOTIMPL;
3006 }
3007
3008 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberProcessors(IDebugControl4 *iface, ULONG *count)
3009 {
3010     FIXME("%p, %p stub.\n", iface, count);
3011
3012     return E_NOTIMPL;
3013 }
3014
3015 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersion(IDebugControl4 *iface, ULONG *platform_id, ULONG *major,
3016         ULONG *minor, char *sp_string, ULONG sp_string_size, ULONG *sp_string_used, ULONG *sp_number,
3017         char *build_string, ULONG build_string_size, ULONG *build_string_used)
3018 {
3019     FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %p, %lu, %p stub.\n", iface, platform_id, major, minor, sp_string,
3020             sp_string_size, sp_string_used, sp_number, build_string, build_string_size, build_string_used);
3021
3022     return E_NOTIMPL;
3023 }
3024
3025 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPageSize(IDebugControl4 *iface, ULONG *size)
3026 {
3027     FIXME("%p, %p stub.\n", iface, size);
3028
3029     return E_NOTIMPL;
3030 }
3031
3032 static HRESULT STDMETHODCALLTYPE debugcontrol_IsPointer64Bit(IDebugControl4 *iface)
3033 {
3034     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3035     static struct target_process *target;
3036     HRESULT hr;
3037
3038     TRACE("%p.\n", iface);
3039
3040     if (!(target = debug_client_get_target(debug_client)))
3041         return E_UNEXPECTED;
3042
3043     if (FAILED(hr = debug_target_init_modules_info(target)))
3044         return hr;
3045
3046     switch (target->cpu_type)
3047     {
3048         case IMAGE_FILE_MACHINE_I386:
3049         case IMAGE_FILE_MACHINE_ARMNT:
3050             hr = S_FALSE;
3051             break;
3052         case IMAGE_FILE_MACHINE_IA64:
3053         case IMAGE_FILE_MACHINE_AMD64:
3054         case IMAGE_FILE_MACHINE_ARM64:
3055             hr = S_OK;
3056             break;
3057         default:
3058             FIXME("Unexpected cpu type %#lx.\n", target->cpu_type);
3059             hr = E_UNEXPECTED;
3060     }
3061
3062     return hr;
3063 }
3064
3065 static HRESULT STDMETHODCALLTYPE debugcontrol_ReadBugCheckData(IDebugControl4 *iface, ULONG *code, ULONG64 *arg1,
3066         ULONG64 *arg2, ULONG64 *arg3, ULONG64 *arg4)
3067 {
3068     FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, code, arg1, arg2, arg3, arg4);
3069
3070     return E_NOTIMPL;
3071 }
3072
3073 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberSupportedProcessorTypes(IDebugControl4 *iface, ULONG *count)
3074 {
3075     FIXME("%p, %p stub.\n", iface, count);
3076
3077     return E_NOTIMPL;
3078 }
3079
3080 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSupportedProcessorTypes(IDebugControl4 *iface, ULONG start,
3081         ULONG count, ULONG *types)
3082 {
3083     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, types);
3084
3085     return E_NOTIMPL;
3086 }
3087
3088 static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugControl4 *iface, ULONG type, char *full_name,
3089         ULONG full_name_buffer_size, ULONG *full_name_size, char *abbrev_name, ULONG abbrev_name_buffer_size,
3090         ULONG *abbrev_name_size)
3091 {
3092     FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, full_name, full_name_buffer_size, full_name_size,
3093             abbrev_name, abbrev_name_buffer_size, abbrev_name_size);
3094
3095     return E_NOTIMPL;
3096 }
3097
3098 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEffectiveProcessorType(IDebugControl4 *iface, ULONG *type)
3099 {
3100     FIXME("%p, %p stub.\n", iface, type);
3101
3102     return E_NOTIMPL;
3103 }
3104
3105 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEffectiveProcessorType(IDebugControl4 *iface, ULONG type)
3106 {
3107     FIXME("%p, %lu stub.\n", iface, type);
3108
3109     return E_NOTIMPL;
3110 }
3111
3112 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutionStatus(IDebugControl4 *iface, ULONG *status)
3113 {
3114     FIXME("%p, %p stub.\n", iface, status);
3115
3116     return E_NOTIMPL;
3117 }
3118
3119 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExecutionStatus(IDebugControl4 *iface, ULONG status)
3120 {
3121     FIXME("%p, %lu stub.\n", iface, status);
3122
3123     return E_NOTIMPL;
3124 }
3125
3126 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCodeLevel(IDebugControl4 *iface, ULONG *level)
3127 {
3128     FIXME("%p, %p stub.\n", iface, level);
3129
3130     return E_NOTIMPL;
3131 }
3132
3133 static HRESULT STDMETHODCALLTYPE debugcontrol_SetCodeLevel(IDebugControl4 *iface, ULONG level)
3134 {
3135     FIXME("%p, %lu stub.\n", iface, level);
3136
3137     return E_NOTIMPL;
3138 }
3139
3140 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEngineOptions(IDebugControl4 *iface, ULONG *options)
3141 {
3142     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3143
3144     TRACE("%p, %p.\n", iface, options);
3145
3146     *options = debug_client->engine_options;
3147
3148     return S_OK;
3149 }
3150
3151 static HRESULT STDMETHODCALLTYPE debugcontrol_AddEngineOptions(IDebugControl4 *iface, ULONG options)
3152 {
3153     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3154
3155     TRACE("%p, %#lx.\n", iface, options);
3156
3157     if (options & ~DEBUG_ENGOPT_ALL)
3158         return E_INVALIDARG;
3159
3160     debug_client->engine_options |= options;
3161
3162     return S_OK;
3163 }
3164
3165 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveEngineOptions(IDebugControl4 *iface, ULONG options)
3166 {
3167     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3168
3169     TRACE("%p, %#lx.\n", iface, options);
3170
3171     debug_client->engine_options &= ~options;
3172
3173     return S_OK;
3174 }
3175
3176 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEngineOptions(IDebugControl4 *iface, ULONG options)
3177 {
3178     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3179
3180     TRACE("%p, %#lx.\n", iface, options);
3181
3182     if (options & ~DEBUG_ENGOPT_ALL)
3183         return E_INVALIDARG;
3184
3185     debug_client->engine_options = options;
3186
3187     return S_OK;
3188 }
3189
3190 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugControl4 *iface, ULONG *output_level,
3191         ULONG *break_level)
3192 {
3193     FIXME("%p, %p, %p stub.\n", iface, output_level, break_level);
3194
3195     return E_NOTIMPL;
3196 }
3197
3198 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugControl4 *iface, ULONG output_level,
3199         ULONG break_level)
3200 {
3201     FIXME("%p, %lu, %lu stub.\n", iface, output_level, break_level);
3202
3203     return E_NOTIMPL;
3204 }
3205
3206 static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacro(IDebugControl4 *iface, ULONG slot, char *buffer,
3207         ULONG buffer_size, ULONG *macro_size)
3208 {
3209     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
3210
3211     return E_NOTIMPL;
3212 }
3213
3214 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacro(IDebugControl4 *iface, ULONG slot, const char *macro)
3215 {
3216     FIXME("%p, %lu, %s stub.\n", iface, slot, debugstr_a(macro));
3217
3218     return E_NOTIMPL;
3219 }
3220
3221 static HRESULT STDMETHODCALLTYPE debugcontrol_GetRadix(IDebugControl4 *iface, ULONG *radix)
3222 {
3223     FIXME("%p, %p stub.\n", iface, radix);
3224
3225     return E_NOTIMPL;
3226 }
3227
3228 static HRESULT STDMETHODCALLTYPE debugcontrol_SetRadix(IDebugControl4 *iface, ULONG radix)
3229 {
3230     FIXME("%p, %lu stub.\n", iface, radix);
3231
3232     return E_NOTIMPL;
3233 }
3234
3235 static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl4 *iface, const char *expression,
3236         ULONG desired_type, DEBUG_VALUE *value, ULONG *remainder_index)
3237 {
3238     FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_a(expression), desired_type, value, remainder_index);
3239
3240     return E_NOTIMPL;
3241 }
3242
3243 static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValue(IDebugControl4 *iface, DEBUG_VALUE input, ULONG output_type,
3244         DEBUG_VALUE *output)
3245 {
3246     FIXME("%p, %lu, %p stub.\n", iface, output_type, output);
3247
3248     return E_NOTIMPL;
3249 }
3250
3251 static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValues(IDebugControl4 *iface, ULONG count, DEBUG_VALUE *input,
3252         ULONG *output_types, DEBUG_VALUE *output)
3253 {
3254     FIXME("%p, %lu, %p, %p, %p stub.\n", iface, count, input, output_types, output);
3255
3256     return E_NOTIMPL;
3257 }
3258
3259 static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl4 *iface, ULONG output_control, const char *command,
3260         ULONG flags)
3261 {
3262     FIXME("%p, %lu, %s, %#lx stub.\n", iface, output_control, debugstr_a(command), flags);
3263
3264     return E_NOTIMPL;
3265 }
3266
3267 static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl4 *iface, ULONG output_control,
3268         const char *command_file, ULONG flags)
3269 {
3270     FIXME("%p, %lu, %s, %#lx stub.\n", iface, output_control, debugstr_a(command_file), flags);
3271
3272     return E_NOTIMPL;
3273 }
3274
3275 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberBreakpoints(IDebugControl4 *iface, ULONG *count)
3276 {
3277     FIXME("%p, %p stub.\n", iface, count);
3278
3279     return E_NOTIMPL;
3280 }
3281
3282 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex(IDebugControl4 *iface, ULONG index,
3283         IDebugBreakpoint **bp)
3284 {
3285     FIXME("%p, %lu, %p stub.\n", iface, index, bp);
3286
3287     return E_NOTIMPL;
3288 }
3289
3290 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById(IDebugControl4 *iface, ULONG id, IDebugBreakpoint **bp)
3291 {
3292     FIXME("%p, %lu, %p stub.\n", iface, id, bp);
3293
3294     return E_NOTIMPL;
3295 }
3296
3297 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointParameters(IDebugControl4 *iface, ULONG count, ULONG *ids,
3298         ULONG start, DEBUG_BREAKPOINT_PARAMETERS *parameters)
3299 {
3300     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, count, ids, start, parameters);
3301
3302     return E_NOTIMPL;
3303 }
3304
3305 static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl4 *iface, ULONG type, ULONG desired_id,
3306         IDebugBreakpoint **bp)
3307 {
3308     FIXME("%p, %lu, %lu, %p stub.\n", iface, type, desired_id, bp);
3309
3310     return E_NOTIMPL;
3311 }
3312
3313 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint(IDebugControl4 *iface, IDebugBreakpoint *bp)
3314 {
3315     FIXME("%p, %p stub.\n", iface, bp);
3316
3317     return E_NOTIMPL;
3318 }
3319
3320 static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtension(IDebugControl4 *iface, const char *path, ULONG flags,
3321         ULONG64 *handle)
3322 {
3323     FIXME("%p, %s, %#lx, %p stub.\n", iface, debugstr_a(path), flags, handle);
3324
3325     return E_NOTIMPL;
3326 }
3327
3328 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveExtension(IDebugControl4 *iface, ULONG64 handle)
3329 {
3330     FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
3331
3332     return E_NOTIMPL;
3333 }
3334
3335 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPath(IDebugControl4 *iface, const char *path,
3336         ULONG64 *handle)
3337 {
3338     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(path), handle);
3339
3340     return E_NOTIMPL;
3341 }
3342
3343 static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtension(IDebugControl4 *iface, ULONG64 handle,
3344         const char *function, const char *args)
3345 {
3346     FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(function), debugstr_a(args));
3347
3348     return E_NOTIMPL;
3349 }
3350
3351 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunction(IDebugControl4 *iface, ULONG64 handle,
3352         const char *name, void *function)
3353 {
3354     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(name), function);
3355
3356     return E_NOTIMPL;
3357 }
3358
3359 static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis32(IDebugControl4 *iface,
3360         PWINDBG_EXTENSION_APIS32 api)
3361 {
3362     FIXME("%p, %p stub.\n", iface, api);
3363
3364     return E_NOTIMPL;
3365 }
3366
3367 static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis64(IDebugControl4 *iface,
3368         PWINDBG_EXTENSION_APIS64 api)
3369 {
3370     FIXME("%p, %p stub.\n", iface, api);
3371
3372     return E_NOTIMPL;
3373 }
3374
3375 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugControl4 *iface, ULONG *specific_events,
3376         ULONG *specific_exceptions, ULONG *arbitrary_exceptions)
3377 {
3378     FIXME("%p, %p, %p, %p stub.\n", iface, specific_events, specific_exceptions, arbitrary_exceptions);
3379
3380     return E_NOTIMPL;
3381 }
3382
3383 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterText(IDebugControl4 *iface, ULONG index, char *buffer,
3384         ULONG buffer_size, ULONG *text_size)
3385 {
3386     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, text_size);
3387
3388     return E_NOTIMPL;
3389 }
3390
3391 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommand(IDebugControl4 *iface, ULONG index, char *buffer,
3392         ULONG buffer_size, ULONG *command_size)
3393 {
3394     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3395
3396     return E_NOTIMPL;
3397 }
3398
3399 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommand(IDebugControl4 *iface, ULONG index,
3400         const char *command)
3401 {
3402     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(command));
3403
3404     return E_NOTIMPL;
3405 }
3406
3407 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterParameters(IDebugControl4 *iface, ULONG start,
3408         ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
3409 {
3410     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, parameters);
3411
3412     return E_NOTIMPL;
3413 }
3414
3415 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterParameters(IDebugControl4 *iface, ULONG start,
3416         ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
3417 {
3418     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, parameters);
3419
3420     return E_NOTIMPL;
3421 }
3422
3423 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgument(IDebugControl4 *iface, ULONG index,
3424         char *buffer, ULONG buffer_size, ULONG *argument_size)
3425 {
3426     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
3427
3428     return E_NOTIMPL;
3429 }
3430
3431 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgument(IDebugControl4 *iface, ULONG index,
3432         const char *argument)
3433 {
3434     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(argument));
3435
3436     return E_NOTIMPL;
3437 }
3438
3439 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterParameters(IDebugControl4 *iface, ULONG count,
3440         ULONG *codes, ULONG start, DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
3441 {
3442     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, count, codes, start, parameters);
3443
3444     return E_NOTIMPL;
3445 }
3446
3447 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterParameters(IDebugControl4 *iface, ULONG count,
3448         DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
3449 {
3450     FIXME("%p, %lu, %p stub.\n", iface, count, parameters);
3451
3452     return E_NOTIMPL;
3453 }
3454
3455 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterSecondCommand(IDebugControl4 *iface, ULONG index,
3456         char *buffer, ULONG buffer_size, ULONG *command_size)
3457 {
3458     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3459
3460     return E_NOTIMPL;
3461 }
3462
3463 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterSecondCommand(IDebugControl4 *iface, ULONG index,
3464         const char *command)
3465 {
3466     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(command));
3467
3468     return E_NOTIMPL;
3469 }
3470
3471 static HRESULT STDMETHODCALLTYPE debugcontrol_WaitForEvent(IDebugControl4 *iface, ULONG flags, ULONG timeout)
3472 {
3473     struct debug_client *debug_client = impl_from_IDebugControl4(iface);
3474     struct target_process *target;
3475
3476     TRACE("%p, %#lx, %lu.\n", iface, flags, timeout);
3477
3478     /* FIXME: only one target is used currently */
3479
3480     if (!(target = debug_client_get_target(debug_client)))
3481         return E_UNEXPECTED;
3482
3483     if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
3484     {
3485         BOOL suspend = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
3486         DWORD access = PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_LIMITED_INFORMATION;
3487         NTSTATUS status;
3488
3489         if (suspend)
3490             access |= PROCESS_SUSPEND_RESUME;
3491
3492         target->handle = OpenProcess(access, FALSE, target->pid);
3493         if (!target->handle)
3494         {
3495             WARN("Failed to get process handle for pid %#x.\n", target->pid);
3496             return E_UNEXPECTED;
3497         }
3498
3499         if (suspend)
3500         {
3501             status = NtSuspendProcess(target->handle);
3502             if (status)
3503                 WARN("Failed to suspend a process, status %#lx.\n", status);
3504         }
3505
3506         return S_OK;
3507     }
3508     else
3509     {
3510         FIXME("Unsupported attach flags %#x.\n", target->attach_flags);
3511     }
3512
3513     return E_NOTIMPL;
3514 }
3515
3516 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformation(IDebugControl4 *iface, ULONG *type, ULONG *pid,
3517         ULONG *tid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, char *description,
3518         ULONG desc_size, ULONG *desc_used)
3519 {
3520     FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, pid, tid, extra_info, extra_info_size,
3521             extra_info_used, description, desc_size, desc_used);
3522
3523     return E_NOTIMPL;
3524 }
3525
3526 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentTimeDate(IDebugControl4 *iface, ULONG timedate)
3527 {
3528     FIXME("%p, %lu stub.\n", iface, timedate);
3529
3530     return E_NOTIMPL;
3531 }
3532
3533 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentSystemUpTime(IDebugControl4 *iface, ULONG uptime)
3534 {
3535     FIXME("%p, %lu stub.\n", iface, uptime);
3536
3537     return E_NOTIMPL;
3538 }
3539
3540 static HRESULT STDMETHODCALLTYPE debugcontrol_GetDumpFormatFlags(IDebugControl4 *iface, ULONG *flags)
3541 {
3542     FIXME("%p, %p stub.\n", iface, flags);
3543
3544     return E_NOTIMPL;
3545 }
3546
3547 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextPlacements(IDebugControl4 *iface, ULONG *count)
3548 {
3549     FIXME("%p, %p stub.\n", iface, count);
3550
3551     return E_NOTIMPL;
3552 }
3553
3554 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextReplacement(IDebugControl4 *iface, const char *src_text,
3555         ULONG index, char *src_buffer, ULONG src_buffer_size, ULONG *src_size, char *dst_buffer,
3556         ULONG dst_buffer_size, ULONG *dst_size)
3557 {
3558     FIXME("%p, %s, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, debugstr_a(src_text), index, src_buffer,
3559             src_buffer_size, src_size, dst_buffer, dst_buffer_size, dst_size);
3560
3561     return E_NOTIMPL;
3562 }
3563
3564 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacement(IDebugControl4 *iface, const char *src_text,
3565         const char *dst_text)
3566 {
3567     FIXME("%p, %s, %s stub.\n", iface, debugstr_a(src_text), debugstr_a(dst_text));
3568
3569     return E_NOTIMPL;
3570 }
3571
3572 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveTextReplacements(IDebugControl4 *iface)
3573 {
3574     FIXME("%p stub.\n", iface);
3575
3576     return E_NOTIMPL;
3577 }
3578
3579 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputTextReplacements(IDebugControl4 *iface, ULONG output_control,
3580         ULONG flags)
3581 {
3582     FIXME("%p, %lu, %#lx stub.\n", iface, output_control, flags);
3583
3584     return E_NOTIMPL;
3585 }
3586
3587 static HRESULT STDMETHODCALLTYPE debugcontrol_GetAssemblyOptions(IDebugControl4 *iface, ULONG *options)
3588 {
3589     FIXME("%p, %p stub.\n", iface, options);
3590
3591     return E_NOTIMPL;
3592 }
3593
3594 static HRESULT STDMETHODCALLTYPE debugcontrol_AddAssemblyOptions(IDebugControl4 *iface, ULONG options)
3595 {
3596     FIXME("%p, %#lx stub.\n", iface, options);
3597
3598     return E_NOTIMPL;
3599 }
3600
3601 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveAssemblyOptions(IDebugControl4 *iface, ULONG options)
3602 {
3603     FIXME("%p, %#lx stub.\n", iface, options);
3604
3605     return E_NOTIMPL;
3606 }
3607
3608 static HRESULT STDMETHODCALLTYPE debugcontrol_SetAssemblyOptions(IDebugControl4 *iface, ULONG options)
3609 {
3610     FIXME("%p, %#lx stub.\n", iface, options);
3611
3612     return E_NOTIMPL;
3613 }
3614
3615 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntax(IDebugControl4 *iface, ULONG *flags)
3616 {
3617     FIXME("%p, %p stub.\n", iface, flags);
3618
3619     return E_NOTIMPL;
3620 }
3621
3622 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntax(IDebugControl4 *iface, ULONG flags)
3623 {
3624     FIXME("%p, %#lx stub.\n", iface, flags);
3625
3626     return E_NOTIMPL;
3627 }
3628
3629 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntaxByName(IDebugControl4 *iface, const char *name)
3630 {
3631     FIXME("%p, %s stub.\n", iface, debugstr_a(name));
3632
3633     return E_NOTIMPL;
3634 }
3635
3636 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberExpressionSyntaxes(IDebugControl4 *iface, ULONG *number)
3637 {
3638     FIXME("%p, %p stub.\n", iface, number);
3639
3640     return E_NOTIMPL;
3641 }
3642
3643 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntaxNames(IDebugControl4 *iface, ULONG index, char *fullname,
3644         ULONG fullname_buffer_size, ULONG *fullname_size, char *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size)
3645 {
3646     FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, index, fullname, fullname_buffer_size, fullname_size, abbrevname,
3647             abbrevname_buffer_size, abbrevname_size);
3648
3649     return E_NOTIMPL;
3650 }
3651
3652 static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEvents(IDebugControl4 *iface, ULONG *events)
3653 {
3654     FIXME("%p, %p stub.\n", iface, events);
3655
3656     return E_NOTIMPL;
3657 }
3658
3659 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventIndexDescription(IDebugControl4 *iface, ULONG index, ULONG which,
3660         char *buffer, ULONG buffer_size, ULONG *desc_size)
3661 {
3662     FIXME("%p, %lu, %lu, %p, %lu, %p stub.\n", iface, index, which, buffer, buffer_size, desc_size);
3663
3664     return E_NOTIMPL;
3665 }
3666
3667 static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentEventIndex(IDebugControl4 *iface, ULONG *index)
3668 {
3669     FIXME("%p, %p stub.\n", iface, index);
3670
3671     return E_NOTIMPL;
3672 }
3673
3674 static HRESULT STDMETHODCALLTYPE debugcontrol_SetNextEventIndex(IDebugControl4 *iface, ULONG relation, ULONG value,
3675         ULONG *next_index)
3676 {
3677     FIXME("%p, %lu, %lu, %p stub.\n", iface, relation, value, next_index);
3678
3679     return E_NOTIMPL;
3680 }
3681
3682 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFileWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
3683         ULONG *file_size, BOOL *append)
3684 {
3685     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
3686
3687     return E_NOTIMPL;
3688 }
3689
3690 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFileWide(IDebugControl4 *iface, const WCHAR *filename, BOOL append)
3691 {
3692     FIXME("%p, %s, %d stub.\n", iface, debugstr_w(filename), append);
3693
3694     return E_NOTIMPL;
3695 }
3696
3697 static HRESULT STDMETHODCALLTYPE debugcontrol_InputWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
3698        ULONG *input_size)
3699 {
3700     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, input_size);
3701
3702     return E_NOTIMPL;
3703 }
3704
3705 static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInputWide(IDebugControl4 *iface, const WCHAR *buffer)
3706 {
3707     FIXME("%p, %p stub.\n", iface, buffer);
3708
3709     return E_NOTIMPL;
3710 }
3711
3712 static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputWide(IDebugControl4 *iface, ULONG mask, const WCHAR *format, ...)
3713 {
3714     FIXME("%p, %lx, %s stub.\n", iface, mask, debugstr_w(format));
3715
3716     return E_NOTIMPL;
3717 }
3718
3719 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaListWide(IDebugControl4 *iface, ULONG mask, const WCHAR *format,
3720         va_list args)
3721 {
3722     FIXME("%p, %lx, %s stub.\n", iface, mask, debugstr_w(format));
3723
3724     return E_NOTIMPL;
3725 }
3726
3727 static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutputWide(IDebugControl4 *iface, ULONG output_control, ULONG mask,
3728         const WCHAR *format, ...)
3729 {
3730     FIXME("%p, %lx, %lx, %s stub.\n", iface, output_control, mask, debugstr_w(format));
3731
3732     return E_NOTIMPL;
3733 }
3734
3735 static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaListWide(IDebugControl4 *iface, ULONG output_control,
3736         ULONG mask, const WCHAR *format, va_list args)
3737 {
3738     FIXME("%p, %lx, %lx, %s stub.\n", iface, output_control, mask, debugstr_w(format));
3739
3740     return E_NOTIMPL;
3741 }
3742
3743 static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPromptWide(IDebugControl4 *iface, ULONG output_control,
3744         const WCHAR *format, ...)
3745 {
3746     FIXME("%p, %lx, %s stub.\n", iface, output_control, debugstr_w(format));
3747
3748     return E_NOTIMPL;
3749 }
3750
3751 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaListWide(IDebugControl4 *iface, ULONG output_control,
3752         const WCHAR *format, va_list args)
3753 {
3754     FIXME("%p, %lx, %s stub.\n", iface, output_control, debugstr_w(format));
3755
3756     return E_NOTIMPL;
3757 }
3758
3759 static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptTextWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
3760         ULONG *text_size)
3761 {
3762     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, text_size);
3763
3764     return E_NOTIMPL;
3765 }
3766
3767 static HRESULT STDMETHODCALLTYPE debugcontrol_AssembleWide(IDebugControl4 *iface, ULONG64 offset, const WCHAR *instr,
3768         ULONG64 *end_offset)
3769 {
3770     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), debugstr_w(instr), end_offset);
3771
3772     return E_NOTIMPL;
3773 }
3774
3775 static HRESULT STDMETHODCALLTYPE debugcontrol_DisassembleWide(IDebugControl4 *iface, ULONG64 offset, ULONG flags, WCHAR *buffer,
3776         ULONG buffer_size, ULONG *size, ULONG64 *end_offset)
3777 {
3778     FIXME("%p, %s, %#lx, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size, size, end_offset);
3779
3780     return E_NOTIMPL;
3781 }
3782
3783 static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNamesWide(IDebugControl4 *iface, ULONG type, WCHAR *fullname,
3784         ULONG fullname_buffer_size, ULONG *fullname_size, WCHAR *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size)
3785 {
3786     FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, fullname, fullname_buffer_size, fullname_size, abbrevname,
3787             abbrevname_buffer_size, abbrevname_size);
3788
3789     return E_NOTIMPL;
3790 }
3791
3792 static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacroWide(IDebugControl4 *iface, ULONG slot, WCHAR *buffer,
3793         ULONG buffer_size, ULONG *macro_size)
3794 {
3795     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
3796
3797     return E_NOTIMPL;
3798 }
3799
3800 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacroWide(IDebugControl4 *iface, ULONG slot, const WCHAR *macro)
3801 {
3802     FIXME("%p, %lu, %s stub.\n", iface, slot, debugstr_w(macro));
3803
3804     return E_NOTIMPL;
3805 }
3806
3807 static HRESULT STDMETHODCALLTYPE debugcontrol_EvaluateWide(IDebugControl4 *iface, const WCHAR *expression, ULONG desired_type,
3808         DEBUG_VALUE *value, ULONG *remainder_index)
3809 {
3810     FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_w(expression), desired_type, value, remainder_index);
3811
3812     return E_NOTIMPL;
3813 }
3814
3815 static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteWide(IDebugControl4 *iface, ULONG output_control, const WCHAR *command,
3816         ULONG flags)
3817 {
3818     FIXME("%p, %lx, %s, %lx stub.\n", iface, output_control, debugstr_w(command), flags);
3819
3820     return E_NOTIMPL;
3821 }
3822
3823 static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFileWide(IDebugControl4 *iface, ULONG output_control,
3824         const WCHAR *commandfile, ULONG flags)
3825 {
3826     FIXME("%p, %lx, %s, %lx stub.\n", iface, output_control, debugstr_w(commandfile), flags);
3827
3828     return E_NOTIMPL;
3829 }
3830
3831 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex2(IDebugControl4 *iface, ULONG index, PDEBUG_BREAKPOINT2 *bp)
3832 {
3833     FIXME("%p, %lu, %p stub.\n", iface, index, bp);
3834
3835     return E_NOTIMPL;
3836 }
3837
3838 static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById2(IDebugControl4 *iface, ULONG id, PDEBUG_BREAKPOINT2 *bp)
3839 {
3840     FIXME("%p, %lu, %p stub.\n", iface, id, bp);
3841
3842     return E_NOTIMPL;
3843 }
3844
3845 static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint2(IDebugControl4 *iface, ULONG type, ULONG desired_id,
3846         PDEBUG_BREAKPOINT2 *bp)
3847 {
3848     FIXME("%p, %lu, %lu, %p stub.\n", iface, type, desired_id, bp);
3849
3850     return E_NOTIMPL;
3851 }
3852
3853 static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint2(IDebugControl4 *iface, PDEBUG_BREAKPOINT2 bp)
3854 {
3855     FIXME("%p, %p stub.\n", iface, bp);
3856
3857     return E_NOTIMPL;
3858 }
3859
3860 static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtensionWide(IDebugControl4 *iface, const WCHAR *path, ULONG flags,
3861         ULONG64 *handle)
3862 {
3863     FIXME("%p, %s, %#lx, %p stub.\n", iface, debugstr_w(path), flags, handle);
3864
3865     return E_NOTIMPL;
3866 }
3867
3868 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPathWide(IDebugControl4 *iface, const WCHAR *path, ULONG64 *handle)
3869 {
3870     FIXME("%p, %s, %p stub.\n", iface, debugstr_w(path), handle);
3871
3872     return E_NOTIMPL;
3873 }
3874
3875 static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtensionWide(IDebugControl4 *iface, ULONG64 handle, const WCHAR *function,
3876         const WCHAR *arguments)
3877 {
3878     FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_w(function), debugstr_w(arguments));
3879
3880     return E_NOTIMPL;
3881 }
3882
3883 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunctionWide(IDebugControl4 *iface, ULONG64 handle,
3884         const WCHAR *function, FARPROC *func)
3885 {
3886     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_w(function), func);
3887
3888     return E_NOTIMPL;
3889 }
3890
3891 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterTextWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
3892         ULONG buffer_size, ULONG *text_size)
3893 {
3894     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, text_size);
3895
3896     return E_NOTIMPL;
3897 }
3898
3899 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommandWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
3900         ULONG buffer_size, ULONG *command_size)
3901 {
3902     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3903
3904     return E_NOTIMPL;
3905 }
3906
3907 static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommandWide(IDebugControl4 *iface, ULONG index, const WCHAR *command)
3908 {
3909     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(command));
3910
3911     return E_NOTIMPL;
3912 }
3913
3914 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgumentWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
3915         ULONG buffer_size, ULONG *argument_size)
3916 {
3917     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
3918
3919     return E_NOTIMPL;
3920 }
3921
3922 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgumentWide(IDebugControl4 *iface, ULONG index,
3923         const WCHAR *argument)
3924 {
3925     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(argument));
3926
3927     return E_NOTIMPL;
3928 }
3929
3930 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterSecondCommandWide(IDebugControl4 *iface, ULONG index,
3931         WCHAR *buffer, ULONG buffer_size, ULONG *command_size)
3932 {
3933     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3934
3935     return E_NOTIMPL;
3936 }
3937
3938 static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterSecondCommandWide(IDebugControl4 *iface, ULONG index,
3939         const WCHAR *command)
3940 {
3941     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(command));
3942
3943     return E_NOTIMPL;
3944 }
3945
3946 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformationWide(IDebugControl4 *iface, ULONG *type, ULONG *processid,
3947         ULONG *threadid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, WCHAR *desc, ULONG desc_size,
3948         ULONG *desc_used)
3949 {
3950     FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, processid, threadid, extra_info, extra_info_size,
3951             extra_info_used, desc, desc_size, desc_used);
3952
3953     return E_NOTIMPL;
3954 }
3955
3956 static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextReplacementWide(IDebugControl4 *iface, const WCHAR *src_text, ULONG index,
3957         WCHAR *src_buffer, ULONG src_buffer_size, ULONG *src_size, WCHAR *dst_buffer, ULONG dest_buffer_size, ULONG *dst_size)
3958 {
3959     FIXME("%p, %s, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, debugstr_w(src_text), index, src_buffer, src_buffer_size,
3960             src_size, dst_buffer, dest_buffer_size, dst_size);
3961
3962     return E_NOTIMPL;
3963 }
3964
3965 static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacementWide(IDebugControl4 *iface, const WCHAR *src_text,
3966         const WCHAR *dst_text)
3967 {
3968     FIXME("%p, %s, %s stub.\n", iface, debugstr_w(src_text), debugstr_w(dst_text));
3969
3970     return E_NOTIMPL;
3971 }
3972
3973 static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntaxByNameWide(IDebugControl4 *iface, const WCHAR *abbrevname)
3974 {
3975     FIXME("%p, %s stub.\n", iface, debugstr_w(abbrevname));
3976
3977     return E_NOTIMPL;
3978 }
3979
3980 static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntaxNamesWide(IDebugControl4 *iface, ULONG index,
3981         WCHAR *fullname_buffer, ULONG fullname_buffer_size, ULONG *fullname_size, WCHAR *abbrevname_buffer,
3982         ULONG abbrevname_buffer_size, ULONG *abbrev_size)
3983 {
3984     FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, index, fullname_buffer, fullname_buffer_size, fullname_size,
3985             abbrevname_buffer, abbrevname_buffer_size, abbrev_size);
3986
3987     return E_NOTIMPL;
3988 }
3989
3990 static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventIndexDescriptionWide(IDebugControl4 *iface, ULONG index, ULONG which,
3991         WCHAR *buffer, ULONG buffer_size, ULONG *desc_size)
3992 {
3993     FIXME("%p, %lu, %lu, %p, %lu, %p stub.\n", iface, index, which, buffer, buffer_size, desc_size);
3994
3995     return E_NOTIMPL;
3996 }
3997
3998 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile2(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
3999         ULONG *file_size, ULONG *flags)
4000 {
4001     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, flags);
4002
4003     return E_NOTIMPL;
4004 }
4005
4006 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile2(IDebugControl4 *iface, const char *filename, ULONG flags)
4007 {
4008     FIXME("%p, %s, %#lx stub.\n", iface, debugstr_a(filename), flags);
4009
4010     return E_NOTIMPL;
4011 }
4012
4013 static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile2Wide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
4014         ULONG *file_size, ULONG *flags)
4015 {
4016     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, flags);
4017
4018     return E_NOTIMPL;
4019 }
4020
4021 static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile2Wide(IDebugControl4 *iface, const WCHAR *filename, ULONG flags)
4022 {
4023     FIXME("%p, %s, %#lx stub.\n", iface, debugstr_w(filename), flags);
4024
4025     return E_NOTIMPL;
4026 }
4027
4028 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionValues(IDebugControl4 *iface, ULONG *platformid,
4029         ULONG *win32major, ULONG *win32minor, ULONG *kdmajor, ULONG *kdminor)
4030 {
4031     FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, platformid, win32major, win32minor, kdmajor, kdminor);
4032
4033     return E_NOTIMPL;
4034 }
4035
4036 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionString(IDebugControl4 *iface, ULONG which, char *buffer,
4037         ULONG buffer_size, ULONG *string_size)
4038 {
4039     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, which, buffer, buffer_size, string_size);
4040
4041     return E_NOTIMPL;
4042 }
4043
4044 static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionStringWide(IDebugControl4 *iface, ULONG which, WCHAR *buffer,
4045         ULONG buffer_size, ULONG *string_size)
4046 {
4047     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, which, buffer, buffer_size, string_size);
4048
4049     return E_NOTIMPL;
4050 }
4051
4052 static HRESULT STDMETHODCALLTYPE debugcontrol_GetContextStackTrace(IDebugControl4 *iface, void *start_context,
4053         ULONG start_context_size, PDEBUG_STACK_FRAME frames, ULONG frames_size, void *frame_contexts, ULONG frame_contexts_size,
4054         ULONG frame_contexts_entry_size, ULONG *frames_filled)
4055 {
4056     FIXME("%p, %p, %lu, %p, %lu, %p, %lu, %lu, %p stub.\n", iface, start_context, start_context_size, frames, frames_size,
4057             frame_contexts, frame_contexts_size, frame_contexts_entry_size, frames_filled);
4058
4059     return E_NOTIMPL;
4060 }
4061
4062 static HRESULT STDMETHODCALLTYPE debugcontrol_OutputContextStackTrace(IDebugControl4 *iface, ULONG output_control,
4063         PDEBUG_STACK_FRAME frames, ULONG frames_size, void *frame_contexts, ULONG frame_contexts_size,
4064         ULONG frame_contexts_entry_size, ULONG flags)
4065 {
4066     FIXME("%p, %#lx, %p, %lu, %p, %lu, %lu, %#lx stub.\n", iface, output_control, frames, frames_size, frame_contexts,
4067             frame_contexts_size, frame_contexts_entry_size, flags);
4068
4069     return E_NOTIMPL;
4070 }
4071
4072 static HRESULT STDMETHODCALLTYPE debugcontrol_GetStoredEventInformation(IDebugControl4 *iface, ULONG *type, ULONG *processid,
4073         ULONG *threadid, void *context, ULONG context_size, ULONG *context_used, void *extra_info, ULONG extra_info_size,
4074         ULONG *extra_info_used)
4075 {
4076     FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, processid, threadid, context, context_size,
4077             context_used, extra_info, extra_info_size, extra_info_used);
4078
4079     return E_NOTIMPL;
4080 }
4081
4082 static HRESULT STDMETHODCALLTYPE debugcontrol_GetManagedStatus(IDebugControl4 *iface, ULONG *flags, ULONG which_string,
4083         char *string, ULONG string_size, ULONG string_needed)
4084 {
4085     FIXME("%p, %p, %lu, %p, %lu, %lu stub.\n", iface, flags, which_string, string, string_size, string_needed);
4086
4087     return E_NOTIMPL;
4088 }
4089
4090 static HRESULT STDMETHODCALLTYPE debugcontrol_GetManagedStatusWide(IDebugControl4 *iface, ULONG *flags, ULONG which_string,
4091         WCHAR *string, ULONG string_size, ULONG string_needed)
4092 {
4093     FIXME("%p, %p, %lu, %p, %lu, %lu stub.\n", iface, flags, which_string, string, string_size, string_needed);
4094
4095     return E_NOTIMPL;
4096 }
4097
4098 static HRESULT STDMETHODCALLTYPE debugcontrol_ResetManagedStatus(IDebugControl4 *iface, ULONG flags)
4099 {
4100     FIXME("%p, %#lx stub.\n", iface, flags);
4101
4102     return E_NOTIMPL;
4103 }
4104
4105 static const IDebugControl4Vtbl debugcontrolvtbl =
4106 {
4107     debugcontrol_QueryInterface,
4108     debugcontrol_AddRef,
4109     debugcontrol_Release,
4110     debugcontrol_GetInterrupt,
4111     debugcontrol_SetInterrupt,
4112     debugcontrol_GetInterruptTimeout,
4113     debugcontrol_SetInterruptTimeout,
4114     debugcontrol_GetLogFile,
4115     debugcontrol_OpenLogFile,
4116     debugcontrol_CloseLogFile,
4117     debugcontrol_GetLogMask,
4118     debugcontrol_SetLogMask,
4119     debugcontrol_Input,
4120     debugcontrol_ReturnInput,
4121     debugcontrol_Output,
4122     debugcontrol_OutputVaList,
4123     debugcontrol_ControlledOutput,
4124     debugcontrol_ControlledOutputVaList,
4125     debugcontrol_OutputPrompt,
4126     debugcontrol_OutputPromptVaList,
4127     debugcontrol_GetPromptText,
4128     debugcontrol_OutputCurrentState,
4129     debugcontrol_OutputVersionInformation,
4130     debugcontrol_GetNotifyEventHandle,
4131     debugcontrol_SetNotifyEventHandle,
4132     debugcontrol_Assemble,
4133     debugcontrol_Disassemble,
4134     debugcontrol_GetDisassembleEffectiveOffset,
4135     debugcontrol_OutputDisassembly,
4136     debugcontrol_OutputDisassemblyLines,
4137     debugcontrol_GetNearInstruction,
4138     debugcontrol_GetStackTrace,
4139     debugcontrol_GetReturnOffset,
4140     debugcontrol_OutputStackTrace,
4141     debugcontrol_GetDebuggeeType,
4142     debugcontrol_GetActualProcessorType,
4143     debugcontrol_GetExecutingProcessorType,
4144     debugcontrol_GetNumberPossibleExecutingProcessorTypes,
4145     debugcontrol_GetPossibleExecutingProcessorTypes,
4146     debugcontrol_GetNumberProcessors,
4147     debugcontrol_GetSystemVersion,
4148     debugcontrol_GetPageSize,
4149     debugcontrol_IsPointer64Bit,
4150     debugcontrol_ReadBugCheckData,
4151     debugcontrol_GetNumberSupportedProcessorTypes,
4152     debugcontrol_GetSupportedProcessorTypes,
4153     debugcontrol_GetProcessorTypeNames,
4154     debugcontrol_GetEffectiveProcessorType,
4155     debugcontrol_SetEffectiveProcessorType,
4156     debugcontrol_GetExecutionStatus,
4157     debugcontrol_SetExecutionStatus,
4158     debugcontrol_GetCodeLevel,
4159     debugcontrol_SetCodeLevel,
4160     debugcontrol_GetEngineOptions,
4161     debugcontrol_AddEngineOptions,
4162     debugcontrol_RemoveEngineOptions,
4163     debugcontrol_SetEngineOptions,
4164     debugcontrol_GetSystemErrorControl,
4165     debugcontrol_SetSystemErrorControl,
4166     debugcontrol_GetTextMacro,
4167     debugcontrol_SetTextMacro,
4168     debugcontrol_GetRadix,
4169     debugcontrol_SetRadix,
4170     debugcontrol_Evaluate,
4171     debugcontrol_CoerceValue,
4172     debugcontrol_CoerceValues,
4173     debugcontrol_Execute,
4174     debugcontrol_ExecuteCommandFile,
4175     debugcontrol_GetNumberBreakpoints,
4176     debugcontrol_GetBreakpointByIndex,
4177     debugcontrol_GetBreakpointById,
4178     debugcontrol_GetBreakpointParameters,
4179     debugcontrol_AddBreakpoint,
4180     debugcontrol_RemoveBreakpoint,
4181     debugcontrol_AddExtension,
4182     debugcontrol_RemoveExtension,
4183     debugcontrol_GetExtensionByPath,
4184     debugcontrol_CallExtension,
4185     debugcontrol_GetExtensionFunction,
4186     debugcontrol_GetWindbgExtensionApis32,
4187     debugcontrol_GetWindbgExtensionApis64,
4188     debugcontrol_GetNumberEventFilters,
4189     debugcontrol_GetEventFilterText,
4190     debugcontrol_GetEventFilterCommand,
4191     debugcontrol_SetEventFilterCommand,
4192     debugcontrol_GetSpecificFilterParameters,
4193     debugcontrol_SetSpecificFilterParameters,
4194     debugcontrol_GetSpecificFilterArgument,
4195     debugcontrol_SetSpecificFilterArgument,
4196     debugcontrol_GetExceptionFilterParameters,
4197     debugcontrol_SetExceptionFilterParameters,
4198     debugcontrol_GetExceptionFilterSecondCommand,
4199     debugcontrol_SetExceptionFilterSecondCommand,
4200     debugcontrol_WaitForEvent,
4201     debugcontrol_GetLastEventInformation,
4202     debugcontrol_GetCurrentTimeDate,
4203     debugcontrol_GetCurrentSystemUpTime,
4204     debugcontrol_GetDumpFormatFlags,
4205     debugcontrol_GetNumberTextPlacements,
4206     debugcontrol_GetNumberTextReplacement,
4207     debugcontrol_SetTextReplacement,
4208     debugcontrol_RemoveTextReplacements,
4209     debugcontrol_OutputTextReplacements,
4210     debugcontrol_GetAssemblyOptions,
4211     debugcontrol_AddAssemblyOptions,
4212     debugcontrol_RemoveAssemblyOptions,
4213     debugcontrol_SetAssemblyOptions,
4214     debugcontrol_GetExpressionSyntax,
4215     debugcontrol_SetExpressionSyntax,
4216     debugcontrol_SetExpressionSyntaxByName,
4217     debugcontrol_GetNumberExpressionSyntaxes,
4218     debugcontrol_GetExpressionSyntaxNames,
4219     debugcontrol_GetNumberEvents,
4220     debugcontrol_GetEventIndexDescription,
4221     debugcontrol_GetCurrentEventIndex,
4222     debugcontrol_SetNextEventIndex,
4223     debugcontrol_GetLogFileWide,
4224     debugcontrol_OpenLogFileWide,
4225     debugcontrol_InputWide,
4226     debugcontrol_ReturnInputWide,
4227     debugcontrol_OutputWide,
4228     debugcontrol_OutputVaListWide,
4229     debugcontrol_ControlledOutputWide,
4230     debugcontrol_ControlledOutputVaListWide,
4231     debugcontrol_OutputPromptWide,
4232     debugcontrol_OutputPromptVaListWide,
4233     debugcontrol_GetPromptTextWide,
4234     debugcontrol_AssembleWide,
4235     debugcontrol_DisassembleWide,
4236     debugcontrol_GetProcessorTypeNamesWide,
4237     debugcontrol_GetTextMacroWide,
4238     debugcontrol_SetTextMacroWide,
4239     debugcontrol_EvaluateWide,
4240     debugcontrol_ExecuteWide,
4241     debugcontrol_ExecuteCommandFileWide,
4242     debugcontrol_GetBreakpointByIndex2,
4243     debugcontrol_GetBreakpointById2,
4244     debugcontrol_AddBreakpoint2,
4245     debugcontrol_RemoveBreakpoint2,
4246     debugcontrol_AddExtensionWide,
4247     debugcontrol_GetExtensionByPathWide,
4248     debugcontrol_CallExtensionWide,
4249     debugcontrol_GetExtensionFunctionWide,
4250     debugcontrol_GetEventFilterTextWide,
4251     debugcontrol_GetEventFilterCommandWide,
4252     debugcontrol_SetEventFilterCommandWide,
4253     debugcontrol_GetSpecificFilterArgumentWide,
4254     debugcontrol_SetSpecificFilterArgumentWide,
4255     debugcontrol_GetSpecificFilterSecondCommandWide,
4256     debugcontrol_SetSpecificFilterSecondCommandWide,
4257     debugcontrol_GetLastEventInformationWide,
4258     debugcontrol_GetTextReplacementWide,
4259     debugcontrol_SetTextReplacementWide,
4260     debugcontrol_SetExpressionSyntaxByNameWide,
4261     debugcontrol_GetExpressionSyntaxNamesWide,
4262     debugcontrol_GetEventIndexDescriptionWide,
4263     debugcontrol_GetLogFile2,
4264     debugcontrol_OpenLogFile2,
4265     debugcontrol_GetLogFile2Wide,
4266     debugcontrol_OpenLogFile2Wide,
4267     debugcontrol_GetSystemVersionValues,
4268     debugcontrol_GetSystemVersionString,
4269     debugcontrol_GetSystemVersionStringWide,
4270     debugcontrol_GetContextStackTrace,
4271     debugcontrol_OutputContextStackTrace,
4272     debugcontrol_GetStoredEventInformation,
4273     debugcontrol_GetManagedStatus,
4274     debugcontrol_GetManagedStatusWide,
4275     debugcontrol_ResetManagedStatus,
4276 };
4277
4278 static HRESULT STDMETHODCALLTYPE debugadvanced_QueryInterface(IDebugAdvanced3 *iface, REFIID riid, void **obj)
4279 {
4280     struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
4281     return IUnknown_QueryInterface((IUnknown *)&debug_client->IDebugClient_iface, riid, obj);
4282 }
4283
4284 static ULONG STDMETHODCALLTYPE debugadvanced_AddRef(IDebugAdvanced3 *iface)
4285 {
4286     struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
4287     return IUnknown_AddRef((IUnknown *)&debug_client->IDebugClient_iface);
4288 }
4289
4290 static ULONG STDMETHODCALLTYPE debugadvanced_Release(IDebugAdvanced3 *iface)
4291 {
4292     struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
4293     return IUnknown_Release((IUnknown *)&debug_client->IDebugClient_iface);
4294 }
4295
4296 static HRESULT STDMETHODCALLTYPE debugadvanced_GetThreadContext(IDebugAdvanced3 *iface, void *context,
4297         ULONG context_size)
4298 {
4299     FIXME("%p, %p, %lu stub.\n", iface, context, context_size);
4300
4301     return E_NOTIMPL;
4302 }
4303
4304 static HRESULT STDMETHODCALLTYPE debugadvanced_SetThreadContext(IDebugAdvanced3 *iface, void *context,
4305         ULONG context_size)
4306 {
4307     FIXME("%p, %p, %lu stub.\n", iface, context, context_size);
4308
4309     return E_NOTIMPL;
4310 }
4311
4312 static HRESULT STDMETHODCALLTYPE debugadvanced_Request(IDebugAdvanced3 *iface, ULONG request, void *inbuffer,
4313         ULONG inbuffer_size, void *outbuffer, ULONG outbuffer_size, ULONG *outsize)
4314 {
4315     FIXME("%p, %lu, %p, %lu, %p, %lu, %p stub.\n", iface, request, inbuffer, inbuffer_size, outbuffer, outbuffer_size, outsize);
4316
4317     return E_NOTIMPL;
4318 }
4319
4320 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSourceFileInformation(IDebugAdvanced3 *iface, ULONG which, char *sourcefile,
4321         ULONG64 arg64, ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
4322 {
4323     FIXME("%p, %lu, %p, %s, %#lx, %p, %lu, %p stub.\n", iface, which, sourcefile, wine_dbgstr_longlong(arg64),
4324             arg32, buffer, buffer_size, info_size);
4325
4326     return E_NOTIMPL;
4327 }
4328
4329 static HRESULT STDMETHODCALLTYPE debugadvanced_FindSourceFileAndToken(IDebugAdvanced3 *iface, ULONG start_element,
4330         ULONG64 modaddr, const char *filename, ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element,
4331         char *buffer, ULONG buffer_size, ULONG *found_size)
4332 {
4333     FIXME("%p, %lu, %s, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, start_element, wine_dbgstr_longlong(modaddr),
4334             debugstr_a(filename), flags, filetoken, filetokensize, found_element, buffer, buffer_size, found_size);
4335
4336     return E_NOTIMPL;
4337 }
4338
4339 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSymbolInformation(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
4340         ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size, char *string_buffer, ULONG string_buffer_size,
4341         ULONG *string_size)
4342 {
4343     FIXME("%p, %lu, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64),
4344             arg32, buffer, buffer_size, info_size, string_buffer, string_buffer_size, string_size);
4345
4346     return E_NOTIMPL;
4347 }
4348
4349 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSystemObjectInformation(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
4350         ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
4351 {
4352     FIXME("%p, %lu, %s, %#lx, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64), arg32, buffer,
4353             buffer_size, info_size);
4354
4355     return E_NOTIMPL;
4356 }
4357
4358 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSourceFileInformationWide(IDebugAdvanced3 *iface, ULONG which,
4359         WCHAR *source_file, ULONG64 arg64, ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
4360 {
4361     FIXME("%p, %lu, %p, %s, %#lx, %p, %lu, %p stub.\n", iface, which, source_file, wine_dbgstr_longlong(arg64),
4362             arg32, buffer, buffer_size, info_size);
4363
4364     return E_NOTIMPL;
4365 }
4366
4367 static HRESULT STDMETHODCALLTYPE debugadvanced_FindSourceFileAndTokenWide(IDebugAdvanced3 *iface, ULONG start_element,
4368         ULONG64 modaddr, const WCHAR *filename, ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element,
4369         WCHAR *buffer, ULONG buffer_size, ULONG *found_size)
4370 {
4371     FIXME("%p, %lu, %s, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, start_element, wine_dbgstr_longlong(modaddr),
4372             debugstr_w(filename), flags, filetoken, filetokensize, found_element, buffer, buffer_size, found_size);
4373
4374     return E_NOTIMPL;
4375 }
4376
4377 static HRESULT STDMETHODCALLTYPE debugadvanced_GetSymbolInformationWide(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
4378         ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size, WCHAR *string_buffer, ULONG string_buffer_size,
4379         ULONG *string_size)
4380 {
4381     FIXME("%p, %lu, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64),
4382             arg32, buffer, buffer_size, info_size, string_buffer, string_buffer_size, string_size);
4383
4384     return E_NOTIMPL;
4385 }
4386
4387 static const IDebugAdvanced3Vtbl debugadvancedvtbl =
4388 {
4389     debugadvanced_QueryInterface,
4390     debugadvanced_AddRef,
4391     debugadvanced_Release,
4392     debugadvanced_GetThreadContext,
4393     debugadvanced_SetThreadContext,
4394     debugadvanced_Request,
4395     debugadvanced_GetSourceFileInformation,
4396     debugadvanced_FindSourceFileAndToken,
4397     debugadvanced_GetSymbolInformation,
4398     debugadvanced_GetSystemObjectInformation,
4399     debugadvanced_GetSourceFileInformationWide,
4400     debugadvanced_FindSourceFileAndTokenWide,
4401     debugadvanced_GetSymbolInformationWide,
4402 };
4403
4404 static HRESULT STDMETHODCALLTYPE debugsystemobjects_QueryInterface(IDebugSystemObjects *iface, REFIID riid, void **obj)
4405 {
4406     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
4407     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
4408     return IUnknown_QueryInterface(unk, riid, obj);
4409 }
4410
4411 static ULONG STDMETHODCALLTYPE debugsystemobjects_AddRef(IDebugSystemObjects *iface)
4412 {
4413     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
4414     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
4415     return IUnknown_AddRef(unk);
4416 }
4417
4418 static ULONG STDMETHODCALLTYPE debugsystemobjects_Release(IDebugSystemObjects *iface)
4419 {
4420     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
4421     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
4422     return IUnknown_Release(unk);
4423 }
4424
4425 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventThread(IDebugSystemObjects *iface, ULONG *id)
4426 {
4427     FIXME("%p, %p stub.\n", iface, id);
4428
4429     return E_NOTIMPL;
4430 }
4431
4432 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventProcess(IDebugSystemObjects *iface, ULONG *id)
4433 {
4434     FIXME("%p, %p stub.\n", iface, id);
4435
4436     return E_NOTIMPL;
4437 }
4438
4439 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadId(IDebugSystemObjects *iface, ULONG *id)
4440 {
4441     FIXME("%p, %p stub.\n", iface, id);
4442
4443     return E_NOTIMPL;
4444 }
4445
4446 static HRESULT STDMETHODCALLTYPE debugsystemobjects_SetCurrentThreadId(IDebugSystemObjects *iface, ULONG id)
4447 {
4448     FIXME("%p, %lu stub.\n", iface, id);
4449
4450     return E_NOTIMPL;
4451 }
4452
4453 static HRESULT STDMETHODCALLTYPE debugsystemobjects_SetCurrentProcessId(IDebugSystemObjects *iface, ULONG id)
4454 {
4455     FIXME("%p, %lu stub.\n", iface, id);
4456
4457     return E_NOTIMPL;
4458 }
4459
4460 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberThreads(IDebugSystemObjects *iface, ULONG *number)
4461 {
4462     FIXME("%p, %p stub.\n", iface, number);
4463
4464     return E_NOTIMPL;
4465 }
4466
4467 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetTotalNumberThreads(IDebugSystemObjects *iface, ULONG *total,
4468         ULONG *largest_process)
4469 {
4470     FIXME("%p, %p, %p stub.\n", iface, total, largest_process);
4471
4472     return E_NOTIMPL;
4473 }
4474
4475 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdsByIndex(IDebugSystemObjects *iface, ULONG start,
4476         ULONG count, ULONG *ids, ULONG *sysids)
4477 {
4478     FIXME("%p, %lu, %lu, %p, %p stub.\n", iface, start, count, ids, sysids);
4479
4480     return E_NOTIMPL;
4481 }
4482
4483 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByProcessor(IDebugSystemObjects *iface, ULONG processor,
4484         ULONG *id)
4485 {
4486     FIXME("%p, %lu, %p stub.\n", iface, processor, id);
4487
4488     return E_NOTIMPL;
4489 }
4490
4491 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadDataOffset(IDebugSystemObjects *iface,
4492         ULONG64 *offset)
4493 {
4494     FIXME("%p, %p stub.\n", iface, offset);
4495
4496     return E_NOTIMPL;
4497 }
4498
4499 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByDataOffset(IDebugSystemObjects *iface, ULONG64 offset,
4500         ULONG *id)
4501 {
4502     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
4503
4504     return E_NOTIMPL;
4505 }
4506
4507 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadTeb(IDebugSystemObjects *iface, ULONG64 *offset)
4508 {
4509     FIXME("%p, %p stub.\n", iface, offset);
4510
4511     return E_NOTIMPL;
4512 }
4513
4514 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByTeb(IDebugSystemObjects *iface, ULONG64 offset,
4515         ULONG *id)
4516 {
4517     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
4518
4519     return E_NOTIMPL;
4520 }
4521
4522 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadSystemId(IDebugSystemObjects *iface, ULONG *sysid)
4523 {
4524     FIXME("%p, %p stub.\n", iface, sysid);
4525
4526     return E_NOTIMPL;
4527 }
4528
4529 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
4530         ULONG *id)
4531 {
4532     FIXME("%p, %lu, %p stub.\n", iface, sysid, id);
4533
4534     return E_NOTIMPL;
4535 }
4536
4537 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadHandle(IDebugSystemObjects *iface, ULONG64 *handle)
4538 {
4539     FIXME("%p, %p stub.\n", iface, handle);
4540
4541     return E_NOTIMPL;
4542 }
4543
4544 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
4545         ULONG *id)
4546 {
4547     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
4548
4549     return E_NOTIMPL;
4550 }
4551
4552 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberProcesses(IDebugSystemObjects *iface, ULONG *number)
4553 {
4554     FIXME("%p, %p stub.\n", iface, number);
4555
4556     return E_NOTIMPL;
4557 }
4558
4559 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdsByIndex(IDebugSystemObjects *iface, ULONG start,
4560         ULONG count, ULONG *ids, ULONG *sysids)
4561 {
4562     FIXME("%p, %lu, %lu, %p, %p stub.\n", iface, start, count, ids, sysids);
4563
4564     return E_NOTIMPL;
4565 }
4566
4567 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessDataOffset(IDebugSystemObjects *iface,
4568         ULONG64 *offset)
4569 {
4570     FIXME("%p, %p stub.\n", iface, offset);
4571
4572     return E_NOTIMPL;
4573 }
4574
4575 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByDataOffset(IDebugSystemObjects *iface,
4576         ULONG64 offset, ULONG *id)
4577 {
4578     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
4579
4580     return E_NOTIMPL;
4581 }
4582
4583 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessPeb(IDebugSystemObjects *iface, ULONG64 *offset)
4584 {
4585     FIXME("%p, %p stub.\n", iface, offset);
4586
4587     return E_NOTIMPL;
4588 }
4589
4590 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByPeb(IDebugSystemObjects *iface, ULONG64 offset,
4591         ULONG *id)
4592 {
4593     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
4594
4595     return E_NOTIMPL;
4596 }
4597
4598 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessSystemId(IDebugSystemObjects *iface, ULONG *sysid)
4599 {
4600     FIXME("%p, %p stub.\n", iface, sysid);
4601
4602     return E_NOTIMPL;
4603 }
4604
4605 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
4606         ULONG *id)
4607 {
4608     FIXME("%p, %lu, %p stub.\n", iface, sysid, id);
4609
4610     return E_NOTIMPL;
4611 }
4612
4613 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessHandle(IDebugSystemObjects *iface,
4614         ULONG64 *handle)
4615 {
4616     FIXME("%p, %p stub.\n", iface, handle);
4617
4618     return E_NOTIMPL;
4619 }
4620
4621 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
4622         ULONG *id)
4623 {
4624     FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
4625
4626     return E_NOTIMPL;
4627 }
4628
4629 static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessExecutableName(IDebugSystemObjects *iface,
4630         char *buffer, ULONG buffer_size, ULONG *exe_size)
4631 {
4632     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, exe_size);
4633
4634     return E_NOTIMPL;
4635 }
4636
4637 static const IDebugSystemObjectsVtbl debugsystemobjectsvtbl =
4638 {
4639     debugsystemobjects_QueryInterface,
4640     debugsystemobjects_AddRef,
4641     debugsystemobjects_Release,
4642     debugsystemobjects_GetEventThread,
4643     debugsystemobjects_GetEventProcess,
4644     debugsystemobjects_GetCurrentThreadId,
4645     debugsystemobjects_SetCurrentThreadId,
4646     debugsystemobjects_SetCurrentProcessId,
4647     debugsystemobjects_GetNumberThreads,
4648     debugsystemobjects_GetTotalNumberThreads,
4649     debugsystemobjects_GetThreadIdsByIndex,
4650     debugsystemobjects_GetThreadIdByProcessor,
4651     debugsystemobjects_GetCurrentThreadDataOffset,
4652     debugsystemobjects_GetThreadIdByDataOffset,
4653     debugsystemobjects_GetCurrentThreadTeb,
4654     debugsystemobjects_GetThreadIdByTeb,
4655     debugsystemobjects_GetCurrentThreadSystemId,
4656     debugsystemobjects_GetThreadIdBySystemId,
4657     debugsystemobjects_GetCurrentThreadHandle,
4658     debugsystemobjects_GetThreadIdByHandle,
4659     debugsystemobjects_GetNumberProcesses,
4660     debugsystemobjects_GetProcessIdsByIndex,
4661     debugsystemobjects_GetCurrentProcessDataOffset,
4662     debugsystemobjects_GetProcessIdByDataOffset,
4663     debugsystemobjects_GetCurrentProcessPeb,
4664     debugsystemobjects_GetProcessIdByPeb,
4665     debugsystemobjects_GetCurrentProcessSystemId,
4666     debugsystemobjects_GetProcessIdBySystemId,
4667     debugsystemobjects_GetCurrentProcessHandle,
4668     debugsystemobjects_GetProcessIdByHandle,
4669     debugsystemobjects_GetCurrentProcessExecutableName,
4670 };
4671
4672 /************************************************************
4673 *                    DebugExtensionInitialize   (DBGENG.@)
4674 *
4675 * Initializing Debug Engine
4676 *
4677 * PARAMS
4678 *   pVersion  [O] Receiving the version of extension
4679 *   pFlags    [O] Reserved
4680 *
4681 * RETURNS
4682 *   Success: S_OK
4683 *   Failure: Anything other than S_OK
4684 *
4685 * BUGS
4686 *   Unimplemented
4687 */
4688 HRESULT WINAPI DebugExtensionInitialize(ULONG * pVersion, ULONG * pFlags)
4689 {
4690     FIXME("(%p,%p): stub\n", pVersion, pFlags);
4691
4692     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4693
4694     return E_NOTIMPL;
4695 }
4696
4697 /************************************************************
4698 *                    DebugCreate   (dbgeng.@)
4699 */
4700 HRESULT WINAPI DebugCreate(REFIID riid, void **obj)
4701 {
4702     struct debug_client *debug_client;
4703     IUnknown *unk;
4704     HRESULT hr;
4705
4706     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
4707
4708     if (!(debug_client = calloc(1, sizeof(*debug_client))))
4709         return E_OUTOFMEMORY;
4710
4711     debug_client->IDebugClient_iface.lpVtbl = &debugclientvtbl;
4712     debug_client->IDebugDataSpaces_iface.lpVtbl = &debugdataspacesvtbl;
4713     debug_client->IDebugSymbols3_iface.lpVtbl = &debugsymbolsvtbl;
4714     debug_client->IDebugControl4_iface.lpVtbl = &debugcontrolvtbl;
4715     debug_client->IDebugAdvanced3_iface.lpVtbl = &debugadvancedvtbl;
4716     debug_client->IDebugSystemObjects_iface.lpVtbl = &debugsystemobjectsvtbl;
4717     debug_client->refcount = 1;
4718     list_init(&debug_client->targets);
4719
4720     unk = (IUnknown *)&debug_client->IDebugClient_iface;
4721
4722     hr = IUnknown_QueryInterface(unk, riid, obj);
4723     IUnknown_Release(unk);
4724
4725     return hr;
4726 }
4727
4728 /************************************************************
4729 *                    DebugCreateEx   (DBGENG.@)
4730 */
4731 HRESULT WINAPI DebugCreateEx(REFIID riid, DWORD flags, void **obj)
4732 {
4733     FIXME("%s, %#lx, %p: stub\n", debugstr_guid(riid), flags, obj);
4734
4735     return E_NOTIMPL;
4736 }
4737
4738 /************************************************************
4739 *                    DebugConnect   (DBGENG.@)
4740 *
4741 * Creating Debug Engine client object and connecting it to remote host
4742 *
4743 * PARAMS
4744 *   RemoteOptions [I] Options which define how debugger engine connects to remote host
4745 *   InterfaceId   [I] Interface Id of debugger client
4746 *   pInterface    [O] Pointer to interface as requested via InterfaceId
4747 *
4748 * RETURNS
4749 *   Success: S_OK
4750 *   Failure: Anything other than S_OK
4751 *
4752 * BUGS
4753 *   Unimplemented
4754 */
4755 HRESULT WINAPI DebugConnect(PCSTR RemoteOptions, REFIID InterfaceId, PVOID * pInterface)
4756 {
4757     FIXME("(%p,%p,%p): stub\n", RemoteOptions, InterfaceId, pInterface);
4758
4759     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4760
4761     return E_NOTIMPL;
4762 }