dlls/dbgeng/dbgeng.c

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