forked from Mirrors/wine-wine
4091 lines
131 KiB
C
4091 lines
131 KiB
C
/*
|
|
* Support for Microsoft Debugging Extension API
|
|
*
|
|
* Copyright (C) 2010 Volodymyr Shcherbyna
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
|
|
#define COBJMACROS
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winternl.h"
|
|
#include "psapi.h"
|
|
|
|
#include "initguid.h"
|
|
#include "dbgeng.h"
|
|
|
|
#include "wine/debug.h"
|
|
#include "wine/heap.h"
|
|
#include "wine/list.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(dbgeng);
|
|
|
|
struct module_info
|
|
{
|
|
DEBUG_MODULE_PARAMETERS params;
|
|
char image_name[MAX_PATH];
|
|
};
|
|
|
|
struct target_process
|
|
{
|
|
struct list entry;
|
|
unsigned int pid;
|
|
unsigned int attach_flags;
|
|
HANDLE handle;
|
|
struct
|
|
{
|
|
struct module_info *info;
|
|
unsigned int loaded;
|
|
unsigned int unloaded;
|
|
BOOL initialized;
|
|
} modules;
|
|
ULONG cpu_type;
|
|
};
|
|
|
|
struct debug_client
|
|
{
|
|
IDebugClient7 IDebugClient_iface;
|
|
IDebugDataSpaces IDebugDataSpaces_iface;
|
|
IDebugSymbols3 IDebugSymbols3_iface;
|
|
IDebugControl2 IDebugControl2_iface;
|
|
IDebugAdvanced IDebugAdvanced_iface;
|
|
IDebugSystemObjects IDebugSystemObjects_iface;
|
|
LONG refcount;
|
|
ULONG engine_options;
|
|
struct list targets;
|
|
IDebugEventCallbacks *event_callbacks;
|
|
};
|
|
|
|
static struct target_process *debug_client_get_target(struct debug_client *debug_client)
|
|
{
|
|
if (list_empty(&debug_client->targets))
|
|
return NULL;
|
|
|
|
return LIST_ENTRY(list_head(&debug_client->targets), struct target_process, entry);
|
|
}
|
|
|
|
static HRESULT debug_target_return_string(const char *str, char *buffer, unsigned int buffer_size,
|
|
unsigned int *size)
|
|
{
|
|
unsigned int len = strlen(str), dst_len;
|
|
|
|
if (size)
|
|
*size = len + 1;
|
|
|
|
if (buffer && buffer_size)
|
|
{
|
|
dst_len = min(len, buffer_size - 1);
|
|
if (dst_len)
|
|
memcpy(buffer, str, dst_len);
|
|
buffer[dst_len] = 0;
|
|
}
|
|
|
|
return len < buffer_size ? S_OK : S_FALSE;
|
|
}
|
|
|
|
static WORD debug_target_get_module_machine(struct target_process *target, HMODULE module)
|
|
{
|
|
IMAGE_DOS_HEADER dos = { 0 };
|
|
WORD machine = 0;
|
|
|
|
ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
|
|
if (dos.e_magic == IMAGE_DOS_SIGNATURE)
|
|
{
|
|
ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /* PE signature */, &machine,
|
|
sizeof(machine), NULL);
|
|
}
|
|
|
|
return machine;
|
|
}
|
|
|
|
static DWORD debug_target_get_module_timestamp(struct target_process *target, HMODULE module)
|
|
{
|
|
IMAGE_DOS_HEADER dos = { 0 };
|
|
DWORD timestamp = 0;
|
|
|
|
ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
|
|
if (dos.e_magic == IMAGE_DOS_SIGNATURE)
|
|
{
|
|
ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /* PE signature */ +
|
|
FIELD_OFFSET(IMAGE_FILE_HEADER, TimeDateStamp), ×tamp, sizeof(timestamp), NULL);
|
|
}
|
|
|
|
return timestamp;
|
|
}
|
|
|
|
static HRESULT debug_target_init_modules_info(struct target_process *target)
|
|
{
|
|
unsigned int i, count;
|
|
HMODULE *modules;
|
|
MODULEINFO info;
|
|
DWORD needed;
|
|
|
|
if (target->modules.initialized)
|
|
return S_OK;
|
|
|
|
if (!target->handle)
|
|
return E_UNEXPECTED;
|
|
|
|
needed = 0;
|
|
EnumProcessModules(target->handle, NULL, 0, &needed);
|
|
if (!needed)
|
|
return E_FAIL;
|
|
|
|
count = needed / sizeof(HMODULE);
|
|
|
|
if (!(modules = heap_alloc(count * sizeof(*modules))))
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (!(target->modules.info = heap_alloc_zero(count * sizeof(*target->modules.info))))
|
|
{
|
|
heap_free(modules);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (EnumProcessModules(target->handle, modules, count * sizeof(*modules), &needed))
|
|
{
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
if (!GetModuleInformation(target->handle, modules[i], &info, sizeof(info)))
|
|
{
|
|
WARN("Failed to get module information, error %d.\n", GetLastError());
|
|
continue;
|
|
}
|
|
|
|
target->modules.info[i].params.Base = (ULONG_PTR)info.lpBaseOfDll;
|
|
target->modules.info[i].params.Size = info.SizeOfImage;
|
|
target->modules.info[i].params.TimeDateStamp = debug_target_get_module_timestamp(target, modules[i]);
|
|
|
|
GetModuleFileNameExA(target->handle, modules[i], target->modules.info[i].image_name,
|
|
ARRAY_SIZE(target->modules.info[i].image_name));
|
|
}
|
|
}
|
|
|
|
target->cpu_type = debug_target_get_module_machine(target, modules[0]);
|
|
|
|
heap_free(modules);
|
|
|
|
target->modules.loaded = count;
|
|
target->modules.unloaded = 0; /* FIXME */
|
|
|
|
target->modules.initialized = TRUE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static const struct module_info *debug_target_get_module_info(struct target_process *target, unsigned int i)
|
|
{
|
|
if (FAILED(debug_target_init_modules_info(target)))
|
|
return NULL;
|
|
|
|
if (i >= target->modules.loaded)
|
|
return NULL;
|
|
|
|
return &target->modules.info[i];
|
|
}
|
|
|
|
static const struct module_info *debug_target_get_module_info_by_base(struct target_process *target, ULONG64 base)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (FAILED(debug_target_init_modules_info(target)))
|
|
return NULL;
|
|
|
|
for (i = 0; i < target->modules.loaded; ++i)
|
|
{
|
|
if (target->modules.info[i].params.Base == base)
|
|
return &target->modules.info[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void debug_client_detach_target(struct target_process *target)
|
|
{
|
|
NTSTATUS status;
|
|
|
|
if (!target->handle)
|
|
return;
|
|
|
|
if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
|
|
{
|
|
BOOL resume = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
|
|
|
|
if (resume)
|
|
{
|
|
if ((status = NtResumeProcess(target->handle)))
|
|
WARN("Failed to resume process, status %#x.\n", status);
|
|
}
|
|
}
|
|
|
|
CloseHandle(target->handle);
|
|
target->handle = NULL;
|
|
}
|
|
|
|
static struct debug_client *impl_from_IDebugClient(IDebugClient7 *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct debug_client, IDebugClient_iface);
|
|
}
|
|
|
|
static struct debug_client *impl_from_IDebugDataSpaces(IDebugDataSpaces *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct debug_client, IDebugDataSpaces_iface);
|
|
}
|
|
|
|
static struct debug_client *impl_from_IDebugSymbols3(IDebugSymbols3 *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct debug_client, IDebugSymbols3_iface);
|
|
}
|
|
|
|
static struct debug_client *impl_from_IDebugControl2(IDebugControl2 *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct debug_client, IDebugControl2_iface);
|
|
}
|
|
|
|
static struct debug_client *impl_from_IDebugAdvanced(IDebugAdvanced *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct debug_client, IDebugAdvanced_iface);
|
|
}
|
|
|
|
static struct debug_client *impl_from_IDebugSystemObjects(IDebugSystemObjects *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct debug_client, IDebugSystemObjects_iface);
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_QueryInterface(IDebugClient7 *iface, REFIID riid, void **obj)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugClient(iface);
|
|
|
|
TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
|
|
|
|
if (IsEqualIID(riid, &IID_IDebugClient) ||
|
|
IsEqualIID(riid, &IID_IDebugClient2) ||
|
|
IsEqualIID(riid, &IID_IDebugClient3) ||
|
|
IsEqualIID(riid, &IID_IDebugClient4) ||
|
|
IsEqualIID(riid, &IID_IDebugClient5) ||
|
|
IsEqualIID(riid, &IID_IDebugClient6) ||
|
|
IsEqualIID(riid, &IID_IDebugClient7) ||
|
|
IsEqualIID(riid, &IID_IUnknown))
|
|
{
|
|
*obj = iface;
|
|
}
|
|
else if (IsEqualIID(riid, &IID_IDebugDataSpaces))
|
|
{
|
|
*obj = &debug_client->IDebugDataSpaces_iface;
|
|
}
|
|
else if (IsEqualIID(riid, &IID_IDebugSymbols)
|
|
|| IsEqualIID(riid, &IID_IDebugSymbols2)
|
|
|| IsEqualIID(riid, &IID_IDebugSymbols3))
|
|
{
|
|
*obj = &debug_client->IDebugSymbols3_iface;
|
|
}
|
|
else if (IsEqualIID(riid, &IID_IDebugControl2)
|
|
|| IsEqualIID(riid, &IID_IDebugControl))
|
|
{
|
|
*obj = &debug_client->IDebugControl2_iface;
|
|
}
|
|
else if (IsEqualIID(riid, &IID_IDebugAdvanced))
|
|
{
|
|
*obj = &debug_client->IDebugAdvanced_iface;
|
|
}
|
|
else if (IsEqualIID(riid, &IID_IDebugSystemObjects))
|
|
{
|
|
*obj = &debug_client->IDebugSystemObjects_iface;
|
|
}
|
|
else
|
|
{
|
|
WARN("Unsupported interface %s.\n", debugstr_guid(riid));
|
|
*obj = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
IUnknown_AddRef((IUnknown *)*obj);
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugclient_AddRef(IDebugClient7 *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugClient(iface);
|
|
ULONG refcount = InterlockedIncrement(&debug_client->refcount);
|
|
|
|
TRACE("%p, %d.\n", iface, refcount);
|
|
|
|
return refcount;
|
|
}
|
|
|
|
static void debug_target_free(struct target_process *target)
|
|
{
|
|
heap_free(target->modules.info);
|
|
heap_free(target);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugclient_Release(IDebugClient7 *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugClient(iface);
|
|
ULONG refcount = InterlockedDecrement(&debug_client->refcount);
|
|
struct target_process *cur, *cur2;
|
|
|
|
TRACE("%p, %d.\n", debug_client, refcount);
|
|
|
|
if (!refcount)
|
|
{
|
|
LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &debug_client->targets, struct target_process, entry)
|
|
{
|
|
debug_client_detach_target(cur);
|
|
list_remove(&cur->entry);
|
|
debug_target_free(cur);
|
|
}
|
|
if (debug_client->event_callbacks)
|
|
debug_client->event_callbacks->lpVtbl->Release(debug_client->event_callbacks);
|
|
heap_free(debug_client);
|
|
}
|
|
|
|
return refcount;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_AttachKernel(IDebugClient7 *iface, ULONG flags, const char *options)
|
|
{
|
|
FIXME("%p, %#x, %s stub.\n", iface, flags, debugstr_a(options));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetKernelConnectionOptions(IDebugClient7 *iface, char *buffer,
|
|
ULONG buffer_size, ULONG *options_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, options_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetKernelConnectionOptions(IDebugClient7 *iface, const char *options)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(options));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_StartProcessServer(IDebugClient7 *iface, ULONG flags, const char *options,
|
|
void *reserved)
|
|
{
|
|
FIXME("%p, %#x, %s, %p stub.\n", iface, flags, debugstr_a(options), reserved);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_ConnectProcessServer(IDebugClient7 *iface, const char *remote_options,
|
|
ULONG64 *server)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, debugstr_a(remote_options), server);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_DisconnectProcessServer(IDebugClient7 *iface, ULONG64 server)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(server));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessSystemIds(IDebugClient7 *iface, ULONG64 server,
|
|
ULONG *ids, ULONG count, ULONG *actual_count)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(server), ids, count, actual_count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessSystemIdByExecutableName(IDebugClient7 *iface,
|
|
ULONG64 server, const char *exe_name, ULONG flags, ULONG *id)
|
|
{
|
|
FIXME("%p, %s, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(exe_name), flags, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessDescription(IDebugClient7 *iface, ULONG64 server,
|
|
ULONG systemid, ULONG flags, char *exe_name, ULONG exe_name_size, ULONG *actual_exe_name_size,
|
|
char *description, ULONG description_size, ULONG *actual_description_size)
|
|
{
|
|
FIXME("%p, %s, %u, %#x, %p, %u, %p, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(server), systemid, flags,
|
|
exe_name, exe_name_size, actual_exe_name_size, description, description_size, actual_description_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_AttachProcess(IDebugClient7 *iface, ULONG64 server, ULONG pid, ULONG flags)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugClient(iface);
|
|
struct target_process *process;
|
|
|
|
TRACE("%p, %s, %u, %#x.\n", iface, wine_dbgstr_longlong(server), pid, flags);
|
|
|
|
if (server)
|
|
{
|
|
FIXME("Remote debugging is not supported.\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
if (!(process = heap_alloc_zero(sizeof(*process))))
|
|
return E_OUTOFMEMORY;
|
|
|
|
process->pid = pid;
|
|
process->attach_flags = flags;
|
|
|
|
list_add_head(&debug_client->targets, &process->entry);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess(IDebugClient7 *iface, ULONG64 server, char *cmdline,
|
|
ULONG flags)
|
|
{
|
|
FIXME("%p, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(cmdline), flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach(IDebugClient7 *iface, ULONG64 server, char *cmdline,
|
|
ULONG create_flags, ULONG pid, ULONG attach_flags)
|
|
{
|
|
FIXME("%p, %s, %s, %#x, %u, %#x stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(cmdline), create_flags,
|
|
pid, attach_flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetProcessOptions(IDebugClient7 *iface, ULONG *options)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_AddProcessOptions(IDebugClient7 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_RemoveProcessOptions(IDebugClient7 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetProcessOptions(IDebugClient7 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_OpenDumpFile(IDebugClient7 *iface, const char *filename)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(filename));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFile(IDebugClient7 *iface, const char *filename, ULONG qualifier)
|
|
{
|
|
FIXME("%p, %s, %u stub.\n", iface, debugstr_a(filename), qualifier);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_ConnectSession(IDebugClient7 *iface, ULONG flags, ULONG history_limit)
|
|
{
|
|
FIXME("%p, %#x, %u stub.\n", iface, flags, history_limit);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_StartServer(IDebugClient7 *iface, const char *options)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(options));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_OutputServers(IDebugClient7 *iface, ULONG output_control,
|
|
const char *machine, ULONG flags)
|
|
{
|
|
FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(machine), flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_TerminateProcesses(IDebugClient7 *iface)
|
|
{
|
|
FIXME("%p stub.\n", iface);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_DetachProcesses(IDebugClient7 *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugClient(iface);
|
|
struct target_process *target;
|
|
|
|
TRACE("%p.\n", iface);
|
|
|
|
LIST_FOR_EACH_ENTRY(target, &debug_client->targets, struct target_process, entry)
|
|
{
|
|
debug_client_detach_target(target);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_EndSession(IDebugClient7 *iface, ULONG flags)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetExitCode(IDebugClient7 *iface, ULONG *code)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, code);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_DispatchCallbacks(IDebugClient7 *iface, ULONG timeout)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, timeout);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_ExitDispatch(IDebugClient7 *iface, IDebugClient *client)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, client);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateClient(IDebugClient7 *iface, IDebugClient **client)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, client);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetInputCallbacks(IDebugClient7 *iface, IDebugInputCallbacks **callbacks)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, callbacks);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetInputCallbacks(IDebugClient7 *iface, IDebugInputCallbacks *callbacks)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, callbacks);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetOutputCallbacks(IDebugClient7 *iface, IDebugOutputCallbacks **callbacks)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, callbacks);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetOutputCallbacks(IDebugClient7 *iface, IDebugOutputCallbacks *callbacks)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, callbacks);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetOutputMask(IDebugClient7 *iface, ULONG *mask)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, mask);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetOutputMask(IDebugClient7 *iface, ULONG mask)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, mask);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetOtherOutputMask(IDebugClient7 *iface, IDebugClient *client, ULONG *mask)
|
|
{
|
|
FIXME("%p, %p, %p stub.\n", iface, client, mask);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetOtherOutputMask(IDebugClient7 *iface, IDebugClient *client, ULONG mask)
|
|
{
|
|
FIXME("%p, %p, %#x stub.\n", iface, client, mask);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetOutputWidth(IDebugClient7 *iface, ULONG *columns)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, columns);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetOutputWidth(IDebugClient7 *iface, ULONG columns)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, columns);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetOutputLinePrefix(IDebugClient7 *iface, char *buffer, ULONG buffer_size,
|
|
ULONG *prefix_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, prefix_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetOutputLinePrefix(IDebugClient7 *iface, const char *prefix)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(prefix));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetIdentity(IDebugClient7 *iface, char *buffer, ULONG buffer_size,
|
|
ULONG *identity_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, identity_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_OutputIdentity(IDebugClient7 *iface, ULONG output_control, ULONG flags,
|
|
const char *format)
|
|
{
|
|
FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, flags, debugstr_a(format));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetEventCallbacks(IDebugClient7 *iface, IDebugEventCallbacks **callbacks)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugClient(iface);
|
|
|
|
TRACE("%p, %p.\n", iface, callbacks);
|
|
|
|
if (debug_client->event_callbacks)
|
|
{
|
|
*callbacks = debug_client->event_callbacks;
|
|
(*callbacks)->lpVtbl->AddRef(*callbacks);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetEventCallbacks(IDebugClient7 *iface, IDebugEventCallbacks *callbacks)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugClient(iface);
|
|
|
|
TRACE("%p, %p.\n", iface, callbacks);
|
|
|
|
if (debug_client->event_callbacks)
|
|
debug_client->event_callbacks->lpVtbl->Release(debug_client->event_callbacks);
|
|
if ((debug_client->event_callbacks = callbacks))
|
|
debug_client->event_callbacks->lpVtbl->AddRef(debug_client->event_callbacks);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_FlushCallbacks(IDebugClient7 *iface)
|
|
{
|
|
FIXME("%p stub.\n", iface);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFile2(IDebugClient7 *iface, const char *dumpfile, ULONG qualifier,
|
|
ULONG flags, const char *comment)
|
|
{
|
|
FIXME("%p, %s, %d, 0x%08x, %s.\n", iface, debugstr_a(dumpfile), qualifier, flags, debugstr_a(comment));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_AddDumpInformationFile(IDebugClient7 *iface, const char *infofile, ULONG type)
|
|
{
|
|
FIXME("%p, %s, %d.\n", iface, debugstr_a(infofile), type);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_EndProcessServer(IDebugClient7 *iface, ULONG64 server)
|
|
{
|
|
FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(server));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_WaitForProcessServerEnd(IDebugClient7 *iface, ULONG timeout)
|
|
{
|
|
FIXME("%p, %d.\n", iface, timeout);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_IsKernelDebuggerEnabled(IDebugClient7 *iface)
|
|
{
|
|
FIXME("%p.\n", iface);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_TerminateCurrentProcess(IDebugClient7 *iface)
|
|
{
|
|
FIXME("%p.\n", iface);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_DetachCurrentProcess(IDebugClient7 *iface)
|
|
{
|
|
FIXME("%p.\n", iface);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_AbandonCurrentProcess(IDebugClient7 *iface)
|
|
{
|
|
FIXME("%p.\n", iface);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessSystemIdByExecutableNameWide(IDebugClient7 *iface, ULONG64 server,
|
|
const WCHAR *exename, ULONG flags, ULONG *id)
|
|
{
|
|
FIXME("%p, %s, %s, 0x%08x, %p.\n", iface, wine_dbgstr_longlong(server), debugstr_w(exename), flags, id);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessDescriptionWide(IDebugClient7 *iface, ULONG64 server, ULONG id,
|
|
ULONG flags, WCHAR *exename, ULONG size, ULONG *actualsize, WCHAR *description, ULONG desc_size, ULONG *actual_desc_size)
|
|
{
|
|
FIXME("%p, %s, %d, 0x%08x, %s, %d, %p, %s, %d, %p.\n", iface, wine_dbgstr_longlong(server), id, flags, debugstr_w(exename), size,
|
|
actualsize, debugstr_w(description), desc_size, actual_desc_size );
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessWide(IDebugClient7 *iface, ULONG64 server, WCHAR *commandline, ULONG flags)
|
|
{
|
|
FIXME("%p, %s, %s, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(commandline), flags);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttachWide(IDebugClient7 *iface, ULONG64 server, WCHAR *commandline,
|
|
ULONG flags, ULONG processid, ULONG attachflags)
|
|
{
|
|
FIXME("%p, %s, %s, 0x%08x, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(commandline), flags, processid, attachflags);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_OpenDumpFileWide(IDebugClient7 *iface, const WCHAR *filename, ULONG64 handle)
|
|
{
|
|
FIXME("%p, %s, %s.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFileWide(IDebugClient7 *iface, const WCHAR *filename, ULONG64 handle,
|
|
ULONG qualifier, ULONG flags, const WCHAR *comment)
|
|
{
|
|
FIXME("%p, %s, %s, %d, 0x%08x, %s.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle),
|
|
qualifier, flags, debugstr_w(comment));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_AddDumpInformationFileWide(IDebugClient7 *iface, const WCHAR *filename,
|
|
ULONG64 handle, ULONG type)
|
|
{
|
|
FIXME("%p, %s, %s, %d.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle), type);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetNumberDumpFiles(IDebugClient7 *iface, ULONG *count)
|
|
{
|
|
FIXME("%p, %p.\n", iface, count);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetDumpFile(IDebugClient7 *iface, ULONG index, char *buffer, ULONG buf_size,
|
|
ULONG *name_size, ULONG64 *handle, ULONG *type)
|
|
{
|
|
FIXME("%p, %d, %p, %d, %p, %p, %p.\n", iface, index, buffer, buf_size, name_size, handle, type);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetDumpFileWide(IDebugClient7 *iface, ULONG index, WCHAR *buffer, ULONG buf_size,
|
|
ULONG *name_size, ULONG64 *handle, ULONG *type)
|
|
{
|
|
FIXME("%p, %d, %p, %d, %p, %p, %p.\n", iface, index, buffer, buf_size, name_size, handle, type);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_AttachKernelWide(IDebugClient7 *iface, ULONG flags, const WCHAR *options)
|
|
{
|
|
FIXME("%p, 0x%08x, %s.\n", iface, flags, debugstr_w(options));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetKernelConnectionOptionsWide(IDebugClient7 *iface, WCHAR *buffer,
|
|
ULONG buf_size, ULONG *size)
|
|
{
|
|
FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, size);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetKernelConnectionOptionsWide(IDebugClient7 *iface, const WCHAR *options)
|
|
{
|
|
FIXME("%p, %p.\n", iface, options);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_StartProcessServerWide(IDebugClient7 *iface, ULONG flags, const WCHAR *options, void *reserved)
|
|
{
|
|
FIXME("%p, 0x%08x, %s, %p.\n", iface, flags, debugstr_w(options), reserved);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_ConnectProcessServerWide(IDebugClient7 *iface, const WCHAR *options, ULONG64 *server)
|
|
{
|
|
FIXME("%p, %s, %p.\n", iface, debugstr_w(options), server);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_StartServerWide(IDebugClient7 *iface, const WCHAR *options)
|
|
{
|
|
FIXME("%p, %s.\n", iface, debugstr_w(options));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_OutputServersWide(IDebugClient7 *iface, ULONG control, const WCHAR *machine, ULONG flags)
|
|
{
|
|
FIXME("%p, %d, %s, 0x%08x.\n", iface, control, debugstr_w(machine), flags);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetOutputCallbacksWide(IDebugClient7 *iface, IDebugOutputCallbacksWide **callbacks)
|
|
{
|
|
FIXME("%p, %p.\n", iface, callbacks);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetOutputCallbacksWide(IDebugClient7 *iface, IDebugOutputCallbacksWide *callbacks)
|
|
{
|
|
FIXME("%p, %p.\n", iface, callbacks);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetOutputLinePrefixWide(IDebugClient7 *iface, WCHAR *buffer, ULONG buf_size, ULONG *size)
|
|
{
|
|
FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, size);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetOutputLinePrefixWide(IDebugClient7 *iface, const WCHAR *prefix)
|
|
{
|
|
FIXME("%p, %s.\n", iface, debugstr_w(prefix));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetIdentityWide(IDebugClient7 *iface, WCHAR *buffer, ULONG buf_size, ULONG *identity)
|
|
{
|
|
FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, identity);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_OutputIdentityWide(IDebugClient7 *iface, ULONG control, ULONG flags, const WCHAR *format)
|
|
{
|
|
FIXME("%p, %d, 0x%08x, %s.\n", iface, control, flags, debugstr_w(format));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetEventCallbacksWide(IDebugClient7 *iface, IDebugEventCallbacksWide **callbacks)
|
|
{
|
|
FIXME("%p, %p .\n", iface, callbacks);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetEventCallbacksWide(IDebugClient7 *iface, IDebugEventCallbacksWide *callbacks)
|
|
{
|
|
FIXME("%p .\n", iface);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess2(IDebugClient7 *iface, ULONG64 server, char *command, void *options,
|
|
ULONG buf_size, const char *initial, const char *environment)
|
|
{
|
|
FIXME("%p %s, %s, %p, %d, %s, %s.\n", iface, wine_dbgstr_longlong(server), debugstr_a(command), options,
|
|
buf_size, debugstr_a(initial), debugstr_a(environment));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess2Wide(IDebugClient7 *iface, ULONG64 server, WCHAR *command, void *options,
|
|
ULONG size, const WCHAR *initial, const WCHAR *environment)
|
|
{
|
|
FIXME("%p %s, %s, %p, %d, %s, %s.\n", iface, wine_dbgstr_longlong(server), debugstr_w(command), options,
|
|
size, debugstr_w(initial), debugstr_w(environment));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach2(IDebugClient7 *iface, ULONG64 server, char *command,
|
|
void *options, ULONG buf_size, const char *initial, const char *environment, ULONG processid, ULONG flags)
|
|
{
|
|
FIXME("%p %s, %s, %p, %d, %s, %s, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_a(command), options,
|
|
buf_size, debugstr_a(initial), debugstr_a(environment), processid, flags);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach2Wide(IDebugClient7 *iface, ULONG64 server, WCHAR *command,
|
|
void *buffer, ULONG buf_size, const WCHAR *initial, const WCHAR *environment, ULONG processid, ULONG flags)
|
|
{
|
|
FIXME("%p %s, %s, %p, %d, %s, %s, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(command), buffer,
|
|
buf_size, debugstr_w(initial), debugstr_w(environment), processid, flags);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_PushOutputLinePrefix(IDebugClient7 *iface, const char *prefix, ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %p.\n", iface, handle);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_PushOutputLinePrefixWide(IDebugClient7 *iface, const WCHAR *prefix, ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %p.\n", iface, handle);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_PopOutputLinePrefix(IDebugClient7 *iface, ULONG64 handle)
|
|
{
|
|
FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(handle));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetNumberInputCallbacks(IDebugClient7 *iface, ULONG *count)
|
|
{
|
|
FIXME("%p, %p.\n", iface, count);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetNumberOutputCallbacks(IDebugClient7 *iface, ULONG *count)
|
|
{
|
|
FIXME("%p, %p.\n", iface, count);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetNumberEventCallbacks(IDebugClient7 *iface, ULONG flags, ULONG *count)
|
|
{
|
|
FIXME("%p, 0x%08x, %p.\n", iface, flags, count);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetQuitLockString(IDebugClient7 *iface, char *buffer, ULONG buf_size, ULONG *size)
|
|
{
|
|
FIXME("%p, %s, %d, %p.\n", iface, debugstr_a(buffer), buf_size, size);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetQuitLockString(IDebugClient7 *iface, char *string)
|
|
{
|
|
FIXME("%p, %s.\n", iface, debugstr_a(string));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_GetQuitLockStringWide(IDebugClient7 *iface, WCHAR *buffer, ULONG buf_size, ULONG *size)
|
|
{
|
|
FIXME("%p, %s, %d, %p.\n", iface, debugstr_w(buffer), buf_size, size);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetQuitLockStringWide(IDebugClient7 *iface, const WCHAR *string)
|
|
{
|
|
FIXME("%p, %s.\n", iface, debugstr_w(string));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetEventContextCallbacks(IDebugClient7 *iface, IDebugEventContextCallbacks *callbacks)
|
|
{
|
|
FIXME("%p, %p.\n", iface, callbacks);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugclient_SetClientContext(IDebugClient7 *iface, void *context, ULONG size)
|
|
{
|
|
FIXME("%p, %p, %d.\n", iface, context, size);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IDebugClient7Vtbl debugclientvtbl =
|
|
{
|
|
debugclient_QueryInterface,
|
|
debugclient_AddRef,
|
|
debugclient_Release,
|
|
debugclient_AttachKernel,
|
|
debugclient_GetKernelConnectionOptions,
|
|
debugclient_SetKernelConnectionOptions,
|
|
debugclient_StartProcessServer,
|
|
debugclient_ConnectProcessServer,
|
|
debugclient_DisconnectProcessServer,
|
|
debugclient_GetRunningProcessSystemIds,
|
|
debugclient_GetRunningProcessSystemIdByExecutableName,
|
|
debugclient_GetRunningProcessDescription,
|
|
debugclient_AttachProcess,
|
|
debugclient_CreateProcess,
|
|
debugclient_CreateProcessAndAttach,
|
|
debugclient_GetProcessOptions,
|
|
debugclient_AddProcessOptions,
|
|
debugclient_RemoveProcessOptions,
|
|
debugclient_SetProcessOptions,
|
|
debugclient_OpenDumpFile,
|
|
debugclient_WriteDumpFile,
|
|
debugclient_ConnectSession,
|
|
debugclient_StartServer,
|
|
debugclient_OutputServers,
|
|
debugclient_TerminateProcesses,
|
|
debugclient_DetachProcesses,
|
|
debugclient_EndSession,
|
|
debugclient_GetExitCode,
|
|
debugclient_DispatchCallbacks,
|
|
debugclient_ExitDispatch,
|
|
debugclient_CreateClient,
|
|
debugclient_GetInputCallbacks,
|
|
debugclient_SetInputCallbacks,
|
|
debugclient_GetOutputCallbacks,
|
|
debugclient_SetOutputCallbacks,
|
|
debugclient_GetOutputMask,
|
|
debugclient_SetOutputMask,
|
|
debugclient_GetOtherOutputMask,
|
|
debugclient_SetOtherOutputMask,
|
|
debugclient_GetOutputWidth,
|
|
debugclient_SetOutputWidth,
|
|
debugclient_GetOutputLinePrefix,
|
|
debugclient_SetOutputLinePrefix,
|
|
debugclient_GetIdentity,
|
|
debugclient_OutputIdentity,
|
|
debugclient_GetEventCallbacks,
|
|
debugclient_SetEventCallbacks,
|
|
debugclient_FlushCallbacks,
|
|
/* IDebugClient2 */
|
|
debugclient_WriteDumpFile2,
|
|
debugclient_AddDumpInformationFile,
|
|
debugclient_EndProcessServer,
|
|
debugclient_WaitForProcessServerEnd,
|
|
debugclient_IsKernelDebuggerEnabled,
|
|
debugclient_TerminateCurrentProcess,
|
|
debugclient_DetachCurrentProcess,
|
|
debugclient_AbandonCurrentProcess,
|
|
/* IDebugClient3 */
|
|
debugclient_GetRunningProcessSystemIdByExecutableNameWide,
|
|
debugclient_GetRunningProcessDescriptionWide,
|
|
debugclient_CreateProcessWide,
|
|
debugclient_CreateProcessAndAttachWide,
|
|
/* IDebugClient4 */
|
|
debugclient_OpenDumpFileWide,
|
|
debugclient_WriteDumpFileWide,
|
|
debugclient_AddDumpInformationFileWide,
|
|
debugclient_GetNumberDumpFiles,
|
|
debugclient_GetDumpFile,
|
|
debugclient_GetDumpFileWide,
|
|
/* IDebugClient5 */
|
|
debugclient_AttachKernelWide,
|
|
debugclient_GetKernelConnectionOptionsWide,
|
|
debugclient_SetKernelConnectionOptionsWide,
|
|
debugclient_StartProcessServerWide,
|
|
debugclient_ConnectProcessServerWide,
|
|
debugclient_StartServerWide,
|
|
debugclient_OutputServersWide,
|
|
debugclient_GetOutputCallbacksWide,
|
|
debugclient_SetOutputCallbacksWide,
|
|
debugclient_GetOutputLinePrefixWide,
|
|
debugclient_SetOutputLinePrefixWide,
|
|
debugclient_GetIdentityWide,
|
|
debugclient_OutputIdentityWide,
|
|
debugclient_GetEventCallbacksWide,
|
|
debugclient_SetEventCallbacksWide,
|
|
debugclient_CreateProcess2,
|
|
debugclient_CreateProcess2Wide,
|
|
debugclient_CreateProcessAndAttach2,
|
|
debugclient_CreateProcessAndAttach2Wide,
|
|
debugclient_PushOutputLinePrefix,
|
|
debugclient_PushOutputLinePrefixWide,
|
|
debugclient_PopOutputLinePrefix,
|
|
debugclient_GetNumberInputCallbacks,
|
|
debugclient_GetNumberOutputCallbacks,
|
|
debugclient_GetNumberEventCallbacks,
|
|
debugclient_GetQuitLockString,
|
|
debugclient_SetQuitLockString,
|
|
debugclient_GetQuitLockStringWide,
|
|
debugclient_SetQuitLockStringWide,
|
|
/* IDebugClient6 */
|
|
debugclient_SetEventContextCallbacks,
|
|
/* IDebugClient7 */
|
|
debugclient_SetClientContext,
|
|
};
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_QueryInterface(IDebugDataSpaces *iface, REFIID riid, void **obj)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_QueryInterface(unk, riid, obj);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugdataspaces_AddRef(IDebugDataSpaces *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_AddRef(unk);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugdataspaces_Release(IDebugDataSpaces *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_Release(unk);
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadVirtual(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
|
|
ULONG buffer_size, ULONG *read_len)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
|
|
static struct target_process *target;
|
|
HRESULT hr = S_OK;
|
|
SIZE_T length;
|
|
|
|
TRACE("%p, %s, %p, %u, %p.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (ReadProcessMemory(target->handle, (const void *)(ULONG_PTR)offset, buffer, buffer_size, &length))
|
|
{
|
|
if (read_len)
|
|
*read_len = length;
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
WARN("Failed to read process memory %#x.\n", hr);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteVirtual(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
|
|
ULONG buffer_size, ULONG *written)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_SearchVirtual(IDebugDataSpaces *iface, ULONG64 offset, ULONG64 length,
|
|
void *pattern, ULONG pattern_size, ULONG pattern_granularity, ULONG64 *ret_offset)
|
|
{
|
|
FIXME("%p, %s, %s, %p, %u, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(length),
|
|
pattern, pattern_size, pattern_granularity, ret_offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadVirtualUncached(IDebugDataSpaces *iface, ULONG64 offset,
|
|
void *buffer, ULONG buffer_size, ULONG *read_len)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteVirtualUncached(IDebugDataSpaces *iface, ULONG64 offset,
|
|
void *buffer, ULONG buffer_size, ULONG *written)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadPointersVirtual(IDebugDataSpaces *iface, ULONG count,
|
|
ULONG64 offset, ULONG64 *pointers)
|
|
{
|
|
FIXME("%p, %u, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset), pointers);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_WritePointersVirtual(IDebugDataSpaces *iface, ULONG count,
|
|
ULONG64 offset, ULONG64 *pointers)
|
|
{
|
|
FIXME("%p, %u, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset), pointers);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadPhysical(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
|
|
ULONG buffer_size, ULONG *read_len)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_WritePhysical(IDebugDataSpaces *iface, ULONG64 offset, void *buffer,
|
|
ULONG buffer_size, ULONG *written)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadControl(IDebugDataSpaces *iface, ULONG processor, ULONG64 offset,
|
|
void *buffer, ULONG buffer_size, ULONG *read_len)
|
|
{
|
|
FIXME("%p, %u, %s, %p, %u, %p stub.\n", iface, processor, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteControl(IDebugDataSpaces *iface, ULONG processor, ULONG64 offset,
|
|
void *buffer, ULONG buffer_size, ULONG *written)
|
|
{
|
|
FIXME("%p, %u, %s, %p, %u, %p stub.\n", iface, processor, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadIo(IDebugDataSpaces *iface, ULONG type, ULONG bus_number,
|
|
ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG *read_len)
|
|
{
|
|
FIXME("%p, %u, %u, %u, %s, %p, %u, %p stub.\n", iface, type, bus_number, address_space, wine_dbgstr_longlong(offset),
|
|
buffer, buffer_size, read_len);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteIo(IDebugDataSpaces *iface, ULONG type, ULONG bus_number,
|
|
ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG *written)
|
|
{
|
|
FIXME("%p, %u, %u, %u, %s, %p, %u, %p stub.\n", iface, type, bus_number, address_space, wine_dbgstr_longlong(offset),
|
|
buffer, buffer_size, written);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadMsr(IDebugDataSpaces *iface, ULONG msr, ULONG64 *value)
|
|
{
|
|
FIXME("%p, %u, %p stub.\n", iface, msr, value);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteMsr(IDebugDataSpaces *iface, ULONG msr, ULONG64 value)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, msr, wine_dbgstr_longlong(value));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadBusData(IDebugDataSpaces *iface, ULONG data_type,
|
|
ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG buffer_size, ULONG *read_len)
|
|
{
|
|
FIXME("%p, %u, %u, %u, %u, %p, %u, %p stub.\n", iface, data_type, bus_number, slot_number, offset, buffer,
|
|
buffer_size, read_len);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteBusData(IDebugDataSpaces *iface, ULONG data_type,
|
|
ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG buffer_size, ULONG *written)
|
|
{
|
|
FIXME("%p, %u, %u, %u, %u, %p, %u, %p stub.\n", iface, data_type, bus_number, slot_number, offset, buffer,
|
|
buffer_size, written);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_CheckLowMemory(IDebugDataSpaces *iface)
|
|
{
|
|
FIXME("%p stub.\n", iface);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadDebuggerData(IDebugDataSpaces *iface, ULONG index, void *buffer,
|
|
ULONG buffer_size, ULONG *data_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, data_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadProcessorSystemData(IDebugDataSpaces *iface, ULONG processor,
|
|
ULONG index, void *buffer, ULONG buffer_size, ULONG *data_size)
|
|
{
|
|
FIXME("%p, %u, %u, %p, %u, %p stub.\n", iface, processor, index, buffer, buffer_size, data_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IDebugDataSpacesVtbl debugdataspacesvtbl =
|
|
{
|
|
debugdataspaces_QueryInterface,
|
|
debugdataspaces_AddRef,
|
|
debugdataspaces_Release,
|
|
debugdataspaces_ReadVirtual,
|
|
debugdataspaces_WriteVirtual,
|
|
debugdataspaces_SearchVirtual,
|
|
debugdataspaces_ReadVirtualUncached,
|
|
debugdataspaces_WriteVirtualUncached,
|
|
debugdataspaces_ReadPointersVirtual,
|
|
debugdataspaces_WritePointersVirtual,
|
|
debugdataspaces_ReadPhysical,
|
|
debugdataspaces_WritePhysical,
|
|
debugdataspaces_ReadControl,
|
|
debugdataspaces_WriteControl,
|
|
debugdataspaces_ReadIo,
|
|
debugdataspaces_WriteIo,
|
|
debugdataspaces_ReadMsr,
|
|
debugdataspaces_WriteMsr,
|
|
debugdataspaces_ReadBusData,
|
|
debugdataspaces_WriteBusData,
|
|
debugdataspaces_CheckLowMemory,
|
|
debugdataspaces_ReadDebuggerData,
|
|
debugdataspaces_ReadProcessorSystemData,
|
|
};
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_QueryInterface(IDebugSymbols3 *iface, REFIID riid, void **obj)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_QueryInterface(unk, riid, obj);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugsymbols_AddRef(IDebugSymbols3 *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_AddRef(unk);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugsymbols_Release(IDebugSymbols3 *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_Release(unk);
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolOptions(IDebugSymbols3 *iface, ULONG *options)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AddSymbolOptions(IDebugSymbols3 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSymbolOptions(IDebugSymbols3 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolOptions(IDebugSymbols3 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffset(IDebugSymbols3 *iface, ULONG64 offset, char *buffer,
|
|
ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size,
|
|
name_size, displacement);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByName(IDebugSymbols3 *iface, const char *symbol,
|
|
ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffset(IDebugSymbols3 *iface, ULONG64 offset, LONG delta,
|
|
char *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
|
|
{
|
|
FIXME("%p, %s, %d, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
|
|
name_size, displacement);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffset(IDebugSymbols3 *iface, ULONG64 offset, ULONG *line,
|
|
char *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
|
|
{
|
|
FIXME("%p, %s, %p, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
|
|
file_size, displacement);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLine(IDebugSymbols3 *iface, ULONG line, const char *file,
|
|
ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %u, %s, %p stub.\n", iface, line, debugstr_a(file), offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetNumberModules(IDebugSymbols3 *iface, ULONG *loaded, ULONG *unloaded)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
static struct target_process *target;
|
|
HRESULT hr;
|
|
|
|
TRACE("%p, %p, %p.\n", iface, loaded, unloaded);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (FAILED(hr = debug_target_init_modules_info(target)))
|
|
return hr;
|
|
|
|
*loaded = target->modules.loaded;
|
|
*unloaded = target->modules.unloaded;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByIndex(IDebugSymbols3 *iface, ULONG index, ULONG64 *base)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
const struct module_info *info;
|
|
struct target_process *target;
|
|
|
|
TRACE("%p, %u, %p.\n", iface, index, base);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (!(info = debug_target_get_module_info(target, index)))
|
|
return E_INVALIDARG;
|
|
|
|
*base = info->params.Base;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName(IDebugSymbols3 *iface, const char *name,
|
|
ULONG start_index, ULONG *index, ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_a(name), start_index, index, base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset(IDebugSymbols3 *iface, ULONG64 offset,
|
|
ULONG start_index, ULONG *index, ULONG64 *base)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
static struct target_process *target;
|
|
const struct module_info *info;
|
|
|
|
TRACE("%p, %s, %u, %p, %p.\n", iface, wine_dbgstr_longlong(offset), start_index, index, base);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
while ((info = debug_target_get_module_info(target, start_index)))
|
|
{
|
|
if (offset >= info->params.Base && offset < info->params.Base + info->params.Size)
|
|
{
|
|
if (index)
|
|
*index = start_index;
|
|
if (base)
|
|
*base = info->params.Base;
|
|
return S_OK;
|
|
}
|
|
|
|
start_index++;
|
|
}
|
|
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNames(IDebugSymbols3 *iface, ULONG index, ULONG64 base,
|
|
char *image_name, ULONG image_name_buffer_size, ULONG *image_name_size, char *module_name,
|
|
ULONG module_name_buffer_size, ULONG *module_name_size, char *loaded_image_name,
|
|
ULONG loaded_image_name_buffer_size, ULONG *loaded_image_size)
|
|
{
|
|
FIXME("%p, %u, %s, %p, %u, %p, %p, %u, %p, %p, %u, %p stub.\n", iface, index, wine_dbgstr_longlong(base),
|
|
image_name, image_name_buffer_size, image_name_size, module_name, module_name_buffer_size,
|
|
module_name_size, loaded_image_name, loaded_image_name_buffer_size, loaded_image_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleParameters(IDebugSymbols3 *iface, ULONG count, ULONG64 *bases,
|
|
ULONG start, DEBUG_MODULE_PARAMETERS *params)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
const struct module_info *info;
|
|
struct target_process *target;
|
|
unsigned int i;
|
|
|
|
TRACE("%p, %u, %p, %u, %p.\n", iface, count, bases, start, params);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (bases)
|
|
{
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
if ((info = debug_target_get_module_info_by_base(target, bases[i])))
|
|
{
|
|
params[i] = info->params;
|
|
}
|
|
else
|
|
{
|
|
memset(¶ms[i], 0, sizeof(*params));
|
|
params[i].Base = DEBUG_INVALID_OFFSET;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = start; i < start + count; ++i)
|
|
{
|
|
if (!(info = debug_target_get_module_info(target, i)))
|
|
return E_INVALIDARG;
|
|
params[i] = info->params;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModule(IDebugSymbols3 *iface, const char *symbol, ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeName(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
|
|
char *buffer, ULONG buffer_size, ULONG *name_size)
|
|
{
|
|
FIXME("%p, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, buffer,
|
|
buffer_size, name_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeId(IDebugSymbols3 *iface, ULONG64 base, const char *name,
|
|
ULONG *type_id)
|
|
{
|
|
FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), debugstr_a(name), type_id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeSize(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
|
|
ULONG *size)
|
|
{
|
|
FIXME("%p, %s, %u, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffset(IDebugSymbols3 *iface, ULONG64 base, ULONG type_id,
|
|
const char *field, ULONG *offset)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, debugstr_a(field), offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeId(IDebugSymbols3 *iface, const char *symbol, ULONG *type_id,
|
|
ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_a(symbol), type_id, base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetTypeId(IDebugSymbols3 *iface, ULONG64 offset, ULONG *type_id,
|
|
ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), type_id, base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_ReadTypedDataVirtual(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
|
|
ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
|
|
{
|
|
FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
|
|
type_id, buffer, buffer_size, read_len);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_WriteTypedDataVirtual(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
|
|
ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
|
|
{
|
|
FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
|
|
type_id, buffer, buffer_size, written);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataVirtual(IDebugSymbols3 *iface, ULONG output_control,
|
|
ULONG64 offset, ULONG64 base, ULONG type_id, ULONG flags)
|
|
{
|
|
FIXME("%p, %#x, %s, %s, %u, %#x stub.\n", iface, output_control, wine_dbgstr_longlong(offset),
|
|
wine_dbgstr_longlong(base), type_id, flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_ReadTypedDataPhysical(IDebugSymbols3 *iface, ULONG64 offset, ULONG64 base,
|
|
ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
|
|
{
|
|
FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
|
|
type_id, buffer, buffer_size, read_len);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_WriteTypedDataPhysical(IDebugSymbols3 *iface, ULONG64 offset,
|
|
ULONG64 base, ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
|
|
{
|
|
FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
|
|
type_id, buffer, buffer_size, written);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataPhysical(IDebugSymbols3 *iface, ULONG output_control,
|
|
ULONG64 offset, ULONG64 base, ULONG type_id, ULONG flags)
|
|
{
|
|
FIXME("%p, %#x, %s, %s, %u, %#x stub.\n", iface, output_control, wine_dbgstr_longlong(offset),
|
|
wine_dbgstr_longlong(base), type_id, flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetScope(IDebugSymbols3 *iface, ULONG64 *instr_offset,
|
|
DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
|
|
{
|
|
FIXME("%p, %p, %p, %p, %u stub.\n", iface, instr_offset, frame, scope_context, scope_context_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetScope(IDebugSymbols3 *iface, ULONG64 instr_offset,
|
|
DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
|
|
{
|
|
FIXME("%p, %s, %p, %p, %u stub.\n", iface, wine_dbgstr_longlong(instr_offset), frame, scope_context,
|
|
scope_context_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_ResetScope(IDebugSymbols3 *iface)
|
|
{
|
|
FIXME("%p stub.\n", iface);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup(IDebugSymbols3 *iface, ULONG flags,
|
|
IDebugSymbolGroup *update, IDebugSymbolGroup **symbols)
|
|
{
|
|
FIXME("%p, %#x, %p, %p stub.\n", iface, flags, update, symbols);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup(IDebugSymbols3 *iface, IDebugSymbolGroup **group)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, group);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatch(IDebugSymbols3 *iface, const char *pattern,
|
|
ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, pattern, handle);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatch(IDebugSymbols3 *iface, ULONG64 handle, char *buffer,
|
|
ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_EndSymbolMatch(IDebugSymbols3 *iface, ULONG64 handle)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_Reload(IDebugSymbols3 *iface, const char *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
|
|
ULONG *path_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPath(IDebugSymbols3 *iface, const char *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPath(IDebugSymbols3 *iface, const char *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
|
|
ULONG *path_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePath(IDebugSymbols3 *iface, const char *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePath(IDebugSymbols3 *iface, const char *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePath(IDebugSymbols3 *iface, char *buffer, ULONG buffer_size,
|
|
ULONG *path_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElement(IDebugSymbols3 *iface, ULONG index, char *buffer,
|
|
ULONG buffer_size, ULONG *element_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, element_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePath(IDebugSymbols3 *iface, const char *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePath(IDebugSymbols3 *iface, const char *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFile(IDebugSymbols3 *iface, ULONG start, const char *file,
|
|
ULONG flags, ULONG *found_element, char *buffer, ULONG buffer_size, ULONG *found_size)
|
|
{
|
|
FIXME("%p, %u, %s, %#x, %p, %p, %u, %p stub.\n", iface, start, debugstr_a(file), flags, found_element, buffer,
|
|
buffer_size, found_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsets(IDebugSymbols3 *iface, const char *file,
|
|
ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p stub.\n", iface, debugstr_a(file), buffer, buffer_lines, file_lines);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleVersionInformation(IDebugSymbols3 *iface, ULONG index,
|
|
ULONG64 base, const char *item, void *buffer, ULONG buffer_size, ULONG *info_size)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
const struct module_info *info;
|
|
struct target_process *target;
|
|
void *version_info, *ptr;
|
|
HRESULT hr = E_FAIL;
|
|
DWORD handle, size;
|
|
|
|
TRACE("%p, %u, %s, %s, %p, %u, %p.\n", iface, index, wine_dbgstr_longlong(base), debugstr_a(item), buffer,
|
|
buffer_size, info_size);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (index == DEBUG_ANY_ID)
|
|
info = debug_target_get_module_info_by_base(target, base);
|
|
else
|
|
info = debug_target_get_module_info(target, index);
|
|
|
|
if (!info)
|
|
{
|
|
WARN("Was unable to locate module.\n");
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (!(size = GetFileVersionInfoSizeA(info->image_name, &handle)))
|
|
return E_FAIL;
|
|
|
|
if (!(version_info = heap_alloc(size)))
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (GetFileVersionInfoA(info->image_name, handle, size, version_info))
|
|
{
|
|
if (VerQueryValueA(version_info, item, &ptr, &size))
|
|
{
|
|
if (info_size)
|
|
*info_size = size;
|
|
|
|
if (buffer && buffer_size)
|
|
{
|
|
unsigned int dst_len = min(size, buffer_size);
|
|
if (dst_len)
|
|
memcpy(buffer, ptr, dst_len);
|
|
}
|
|
|
|
hr = buffer && buffer_size < size ? S_FALSE : S_OK;
|
|
}
|
|
}
|
|
|
|
heap_free(version_info);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameString(IDebugSymbols3 *iface, ULONG which, ULONG index,
|
|
ULONG64 base, char *buffer, ULONG buffer_size, ULONG *name_size)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
|
|
const struct module_info *info;
|
|
struct target_process *target;
|
|
HRESULT hr;
|
|
|
|
TRACE("%p, %u, %u, %s, %p, %u, %p.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
|
|
name_size);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (index == DEBUG_ANY_ID)
|
|
info = debug_target_get_module_info_by_base(target, base);
|
|
else
|
|
info = debug_target_get_module_info(target, index);
|
|
|
|
if (!info)
|
|
{
|
|
WARN("Was unable to locate module.\n");
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
switch (which)
|
|
{
|
|
case DEBUG_MODNAME_IMAGE:
|
|
hr = debug_target_return_string(info->image_name, buffer, buffer_size, name_size);
|
|
break;
|
|
case DEBUG_MODNAME_MODULE:
|
|
case DEBUG_MODNAME_LOADED_IMAGE:
|
|
case DEBUG_MODNAME_SYMBOL_FILE:
|
|
case DEBUG_MODNAME_MAPPED_IMAGE:
|
|
FIXME("Unsupported name info %d.\n", which);
|
|
return E_NOTIMPL;
|
|
default:
|
|
WARN("Unknown name info %d.\n", which);
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantName(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
|
|
ULONG64 value, char *buffer, ULONG buffer_size, ULONG *name_size)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
|
|
wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldName(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
|
|
ULONG field_index, char *buffer, ULONG buffer_size, ULONG *name_size)
|
|
{
|
|
FIXME("%p, %s, %u, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
|
|
buffer_size, name_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeOptions(IDebugSymbols3 *iface, ULONG *options)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AddTypeOptions(IDebugSymbols3 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveTypeOptions(IDebugSymbols3 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetTypeOptions(IDebugSymbols3 *iface, ULONG options)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, options);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset, WCHAR *buffer,
|
|
ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, name_size,
|
|
displacement);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
|
|
ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset,
|
|
LONG delta, WCHAR *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
|
|
{
|
|
FIXME("%p, %s, %d, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
|
|
name_size, displacement);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffsetWide(IDebugSymbols3 *iface, ULONG64 offset, ULONG *line,
|
|
WCHAR *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
|
|
{
|
|
FIXME("%p, %s, %p, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
|
|
file_size, displacement);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLineWide(IDebugSymbols3 *iface, ULONG line, const WCHAR *file,
|
|
ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %u, %s, %p stub.\n", iface, line, debugstr_w(file), offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleNameWide(IDebugSymbols3 *iface, const WCHAR *name,
|
|
ULONG start_index, ULONG *index, ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_w(name), start_index, index, base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModuleWide(IDebugSymbols3 *iface, const WCHAR *symbol,
|
|
ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
|
|
WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
|
|
{
|
|
FIXME("%p, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, buffer, buffer_size,
|
|
name_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeIdWide(IDebugSymbols3 *iface, ULONG64 module, const WCHAR *name,
|
|
ULONG *type_id)
|
|
{
|
|
FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), debugstr_w(name), type_id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffsetWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
|
|
const WCHAR *field, ULONG *offset)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, debugstr_w(field), offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeIdWide(IDebugSymbols3 *iface, const WCHAR *symbol,
|
|
ULONG *type_id, ULONG64 *module)
|
|
{
|
|
FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_w(symbol), type_id, module);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup2(IDebugSymbols3 *iface, ULONG flags,
|
|
PDEBUG_SYMBOL_GROUP2 update, PDEBUG_SYMBOL_GROUP2 *symbols)
|
|
{
|
|
FIXME("%p, %#x, %p, %p stub.\n", iface, flags, update, symbols);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup2(IDebugSymbols3 *iface, PDEBUG_SYMBOL_GROUP2 *group)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, group);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatchWide(IDebugSymbols3 *iface, const WCHAR *pattern,
|
|
ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, debugstr_w(pattern), handle);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatchWide(IDebugSymbols3 *iface, ULONG64 handle,
|
|
WCHAR *buffer, ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_ReloadWide(IDebugSymbols3 *iface, const WCHAR *module)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_w(module));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
|
|
ULONG *path_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_w(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *addition)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
|
|
ULONG *path_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePathWide(IDebugSymbols3 *iface, const WCHAR *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_w(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathWide(IDebugSymbols3 *iface, WCHAR *buffer, ULONG buffer_size,
|
|
ULONG *path_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElementWide(IDebugSymbols3 *iface, ULONG index,
|
|
WCHAR *buffer, ULONG buffer_size, ULONG *element_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, element_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePathWide(IDebugSymbols3 *iface, const WCHAR *path)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_w(path));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFileWide(IDebugSymbols3 *iface, ULONG start_element,
|
|
const WCHAR *file, ULONG flags, ULONG *found_element, WCHAR *buffer, ULONG buffer_size, ULONG *found_size)
|
|
{
|
|
FIXME("%p, %u, %s, %#x, %p, %p, %u, %p stub.\n", iface, start_element, debugstr_w(file), flags, found_element,
|
|
buffer, buffer_size, found_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsetsWide(IDebugSymbols3 *iface, const WCHAR *file,
|
|
ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
|
|
{
|
|
FIXME("%p, %s, %p, %u, %p stub.\n", iface, debugstr_w(file), buffer, buffer_lines, file_lines);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleVersionInformationWide(IDebugSymbols3 *iface, ULONG index,
|
|
ULONG64 base, const WCHAR *item, void *buffer, ULONG buffer_size, ULONG *version_info_size)
|
|
{
|
|
FIXME("%p, %u, %s, %s, %p, %u, %p stub.\n", iface, index, wine_dbgstr_longlong(base), debugstr_w(item), buffer,
|
|
buffer_size, version_info_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameStringWide(IDebugSymbols3 *iface, ULONG which, ULONG index,
|
|
ULONG64 base, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
|
|
{
|
|
FIXME("%p, %u, %u, %s, %p, %u, %p stub.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
|
|
name_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
|
|
ULONG64 value, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
|
|
wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldNameWide(IDebugSymbols3 *iface, ULONG64 module, ULONG type_id,
|
|
ULONG field_index, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
|
|
{
|
|
FIXME("%p, %s, %u, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
|
|
buffer_size, name_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_IsManagedModule(IDebugSymbols3 *iface, ULONG index, ULONG64 base)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, index, wine_dbgstr_longlong(base));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2(IDebugSymbols3 *iface, const char *name,
|
|
ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, debugstr_a(name), start_index, flags, index, base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2Wide(IDebugSymbols3 *iface, const WCHAR *name,
|
|
ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, debugstr_w(name), start_index, flags, index, base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset2(IDebugSymbols3 *iface, ULONG64 offset,
|
|
ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
|
|
{
|
|
FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), start_index, flags, index, base);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModule(IDebugSymbols3 *iface, ULONG64 base, ULONG size,
|
|
const char *image_path, const char *module_name, ULONG flags)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_a(image_path),
|
|
debugstr_a(module_name), flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModuleWide(IDebugSymbols3 *iface, ULONG64 base, ULONG size,
|
|
const WCHAR *image_path, const WCHAR *module_name, ULONG flags)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_w(image_path),
|
|
debugstr_w(module_name), flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticModule(IDebugSymbols3 *iface, ULONG64 base)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(base));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetCurrentScopeFrameIndex(IDebugSymbols3 *iface, ULONG *index)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, index);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFrameByIndex(IDebugSymbols3 *iface, ULONG index)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, index);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromJitDebugInfo(IDebugSymbols3 *iface, ULONG output_control,
|
|
ULONG64 info_offset)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, output_control, wine_dbgstr_longlong(info_offset));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromStoredEvent(IDebugSymbols3 *iface)
|
|
{
|
|
FIXME("%p stub.\n", iface);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_OutputSymbolByOffset(IDebugSymbols3 *iface, ULONG output_control,
|
|
ULONG flags, ULONG64 offset)
|
|
{
|
|
FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, flags, wine_dbgstr_longlong(offset));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetFunctionEntryByOffset(IDebugSymbols3 *iface, ULONG64 offset,
|
|
ULONG flags, void *buffer, ULONG buffer_size, ULONG *needed_size)
|
|
{
|
|
FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
|
|
needed_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffset(IDebugSymbols3 *iface, ULONG64 module,
|
|
ULONG container_type_id, const char *field, ULONG *field_type_id, ULONG *offset)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_a(field),
|
|
field_type_id, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffsetWide(IDebugSymbols3 *iface, ULONG64 module,
|
|
ULONG container_type_id, const WCHAR *field, ULONG *field_type_id, ULONG *offset)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_w(field),
|
|
field_type_id, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbol(IDebugSymbols3 *iface, ULONG64 offset, ULONG size,
|
|
const char *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_a(name), flags, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbolWide(IDebugSymbols3 *iface, ULONG64 offset, ULONG size,
|
|
const WCHAR *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
|
|
{
|
|
FIXME("%p, %s, %u, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_w(name), flags, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticSymbol(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByOffset(IDebugSymbols3 *iface, ULONG64 offset,
|
|
ULONG flags, DEBUG_MODULE_AND_ID *ids, LONG64 *displacements, ULONG count, ULONG *entries)
|
|
{
|
|
FIXME("%p, %s, %#x, %p, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, ids, displacements, count,
|
|
entries);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByName(IDebugSymbols3 *iface, const char *symbol,
|
|
ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
|
|
{
|
|
FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_a(symbol), flags, ids, count, entries);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
|
|
ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
|
|
{
|
|
FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_w(symbol), flags, ids, count, entries);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryByToken(IDebugSymbols3 *iface, ULONG64 base, ULONG token,
|
|
DEBUG_MODULE_AND_ID *id)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryInformation(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
|
|
DEBUG_SYMBOL_ENTRY *info)
|
|
{
|
|
FIXME("%p, %p, %p stub.\n", iface, id, info);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryString(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
|
|
ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryStringWide(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
|
|
ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryOffsetRegions(IDebugSymbols3 *iface, DEBUG_MODULE_AND_ID *id,
|
|
ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG regions_count, ULONG *regions_avail)
|
|
{
|
|
FIXME("%p, %p, %#x, %p, %u, %p stub.\n", iface, id, flags, regions, regions_count, regions_avail);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryBySymbolEntry(IDebugSymbols3 *iface,
|
|
DEBUG_MODULE_AND_ID *from_id, ULONG flags, DEBUG_MODULE_AND_ID *to_id)
|
|
{
|
|
FIXME("%p, %p, %#x, %p stub.\n", iface, from_id, flags, to_id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByOffset(IDebugSymbols3 *iface, ULONG64 offset,
|
|
ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
|
|
{
|
|
FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, entries, count, entries_avail);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLine(IDebugSymbols3 *iface, ULONG line,
|
|
const char *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
|
|
{
|
|
FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_a(file), flags, entries, count, entries_avail);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLineWide(IDebugSymbols3 *iface, ULONG line,
|
|
const WCHAR *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
|
|
{
|
|
FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_w(file), flags, entries, count, entries_avail);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryString(IDebugSymbols3 *iface,
|
|
DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryStringWide(IDebugSymbols3 *iface,
|
|
DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryOffsetRegions(IDebugSymbols3 *iface,
|
|
DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG count, ULONG *regions_avail)
|
|
{
|
|
FIXME("%p, %p, %#x, %p, %u, %p stub.\n", iface, entry, flags, regions, count, regions_avail);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryBySourceEntry(IDebugSymbols3 *iface,
|
|
DEBUG_SYMBOL_SOURCE_ENTRY *from_entry, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *to_entry)
|
|
{
|
|
FIXME("%p, %p, %#x, %p stub.\n", iface, from_entry, flags, to_entry);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IDebugSymbols3Vtbl debugsymbolsvtbl =
|
|
{
|
|
debugsymbols_QueryInterface,
|
|
debugsymbols_AddRef,
|
|
debugsymbols_Release,
|
|
debugsymbols_GetSymbolOptions,
|
|
debugsymbols_AddSymbolOptions,
|
|
debugsymbols_RemoveSymbolOptions,
|
|
debugsymbols_SetSymbolOptions,
|
|
debugsymbols_GetNameByOffset,
|
|
debugsymbols_GetOffsetByName,
|
|
debugsymbols_GetNearNameByOffset,
|
|
debugsymbols_GetLineByOffset,
|
|
debugsymbols_GetOffsetByLine,
|
|
debugsymbols_GetNumberModules,
|
|
debugsymbols_GetModuleByIndex,
|
|
debugsymbols_GetModuleByModuleName,
|
|
debugsymbols_GetModuleByOffset,
|
|
debugsymbols_GetModuleNames,
|
|
debugsymbols_GetModuleParameters,
|
|
debugsymbols_GetSymbolModule,
|
|
debugsymbols_GetTypeName,
|
|
debugsymbols_GetTypeId,
|
|
debugsymbols_GetTypeSize,
|
|
debugsymbols_GetFieldOffset,
|
|
debugsymbols_GetSymbolTypeId,
|
|
debugsymbols_GetOffsetTypeId,
|
|
debugsymbols_ReadTypedDataVirtual,
|
|
debugsymbols_WriteTypedDataVirtual,
|
|
debugsymbols_OutputTypedDataVirtual,
|
|
debugsymbols_ReadTypedDataPhysical,
|
|
debugsymbols_WriteTypedDataPhysical,
|
|
debugsymbols_OutputTypedDataPhysical,
|
|
debugsymbols_GetScope,
|
|
debugsymbols_SetScope,
|
|
debugsymbols_ResetScope,
|
|
debugsymbols_GetScopeSymbolGroup,
|
|
debugsymbols_CreateSymbolGroup,
|
|
debugsymbols_StartSymbolMatch,
|
|
debugsymbols_GetNextSymbolMatch,
|
|
debugsymbols_EndSymbolMatch,
|
|
debugsymbols_Reload,
|
|
debugsymbols_GetSymbolPath,
|
|
debugsymbols_SetSymbolPath,
|
|
debugsymbols_AppendSymbolPath,
|
|
debugsymbols_GetImagePath,
|
|
debugsymbols_SetImagePath,
|
|
debugsymbols_AppendImagePath,
|
|
debugsymbols_GetSourcePath,
|
|
debugsymbols_GetSourcePathElement,
|
|
debugsymbols_SetSourcePath,
|
|
debugsymbols_AppendSourcePath,
|
|
debugsymbols_FindSourceFile,
|
|
debugsymbols_GetSourceFileLineOffsets,
|
|
/* IDebugSymbols2 */
|
|
debugsymbols_GetModuleVersionInformation,
|
|
debugsymbols_GetModuleNameString,
|
|
debugsymbols_GetConstantName,
|
|
debugsymbols_GetFieldName,
|
|
debugsymbols_GetTypeOptions,
|
|
debugsymbols_AddTypeOptions,
|
|
debugsymbols_RemoveTypeOptions,
|
|
debugsymbols_SetTypeOptions,
|
|
/* IDebugSymbols3 */
|
|
debugsymbols_GetNameByOffsetWide,
|
|
debugsymbols_GetOffsetByNameWide,
|
|
debugsymbols_GetNearNameByOffsetWide,
|
|
debugsymbols_GetLineByOffsetWide,
|
|
debugsymbols_GetOffsetByLineWide,
|
|
debugsymbols_GetModuleByModuleNameWide,
|
|
debugsymbols_GetSymbolModuleWide,
|
|
debugsymbols_GetTypeNameWide,
|
|
debugsymbols_GetTypeIdWide,
|
|
debugsymbols_GetFieldOffsetWide,
|
|
debugsymbols_GetSymbolTypeIdWide,
|
|
debugsymbols_GetScopeSymbolGroup2,
|
|
debugsymbols_CreateSymbolGroup2,
|
|
debugsymbols_StartSymbolMatchWide,
|
|
debugsymbols_GetNextSymbolMatchWide,
|
|
debugsymbols_ReloadWide,
|
|
debugsymbols_GetSymbolPathWide,
|
|
debugsymbols_SetSymbolPathWide,
|
|
debugsymbols_AppendSymbolPathWide,
|
|
debugsymbols_GetImagePathWide,
|
|
debugsymbols_SetImagePathWide,
|
|
debugsymbols_AppendImagePathWide,
|
|
debugsymbols_GetSourcePathWide,
|
|
debugsymbols_GetSourcePathElementWide,
|
|
debugsymbols_SetSourcePathWide,
|
|
debugsymbols_AppendSourcePathWide,
|
|
debugsymbols_FindSourceFileWide,
|
|
debugsymbols_GetSourceFileLineOffsetsWide,
|
|
debugsymbols_GetModuleVersionInformationWide,
|
|
debugsymbols_GetModuleNameStringWide,
|
|
debugsymbols_GetConstantNameWide,
|
|
debugsymbols_GetFieldNameWide,
|
|
debugsymbols_IsManagedModule,
|
|
debugsymbols_GetModuleByModuleName2,
|
|
debugsymbols_GetModuleByModuleName2Wide,
|
|
debugsymbols_GetModuleByOffset2,
|
|
debugsymbols_AddSyntheticModule,
|
|
debugsymbols_AddSyntheticModuleWide,
|
|
debugsymbols_RemoveSyntheticModule,
|
|
debugsymbols_GetCurrentScopeFrameIndex,
|
|
debugsymbols_SetScopeFrameByIndex,
|
|
debugsymbols_SetScopeFromJitDebugInfo,
|
|
debugsymbols_SetScopeFromStoredEvent,
|
|
debugsymbols_OutputSymbolByOffset,
|
|
debugsymbols_GetFunctionEntryByOffset,
|
|
debugsymbols_GetFieldTypeAndOffset,
|
|
debugsymbols_GetFieldTypeAndOffsetWide,
|
|
debugsymbols_AddSyntheticSymbol,
|
|
debugsymbols_AddSyntheticSymbolWide,
|
|
debugsymbols_RemoveSyntheticSymbol,
|
|
debugsymbols_GetSymbolEntriesByOffset,
|
|
debugsymbols_GetSymbolEntriesByName,
|
|
debugsymbols_GetSymbolEntriesByNameWide,
|
|
debugsymbols_GetSymbolEntryByToken,
|
|
debugsymbols_GetSymbolEntryInformation,
|
|
debugsymbols_GetSymbolEntryString,
|
|
debugsymbols_GetSymbolEntryStringWide,
|
|
debugsymbols_GetSymbolEntryOffsetRegions,
|
|
debugsymbols_GetSymbolEntryBySymbolEntry,
|
|
debugsymbols_GetSourceEntriesByOffset,
|
|
debugsymbols_GetSourceEntriesByLine,
|
|
debugsymbols_GetSourceEntriesByLineWide,
|
|
debugsymbols_GetSourceEntryString,
|
|
debugsymbols_GetSourceEntryStringWide,
|
|
debugsymbols_GetSourceEntryOffsetRegions,
|
|
debugsymbols_GetSourceEntryBySourceEntry,
|
|
};
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_QueryInterface(IDebugControl2 *iface, REFIID riid, void **obj)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_QueryInterface(unk, riid, obj);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugcontrol_AddRef(IDebugControl2 *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_AddRef(unk);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugcontrol_Release(IDebugControl2 *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_Release(unk);
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterrupt(IDebugControl2 *iface)
|
|
{
|
|
FIXME("%p stub.\n", iface);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterrupt(IDebugControl2 *iface, ULONG flags)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterruptTimeout(IDebugControl2 *iface, ULONG *timeout)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, timeout);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterruptTimeout(IDebugControl2 *iface, ULONG timeout)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, timeout);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
|
|
ULONG *file_size, BOOL *append)
|
|
{
|
|
FIXME("%p, %p, %u, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile(IDebugControl2 *iface, const char *file, BOOL append)
|
|
{
|
|
FIXME("%p, %s, %d stub.\n", iface, debugstr_a(file), append);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_CloseLogFile(IDebugControl2 *iface)
|
|
{
|
|
FIXME("%p stub.\n", iface);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogMask(IDebugControl2 *iface, ULONG *mask)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, mask);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetLogMask(IDebugControl2 *iface, ULONG mask)
|
|
{
|
|
FIXME("%p, %#x stub.\n", iface, mask);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_Input(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
|
|
ULONG *input_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, input_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInput(IDebugControl2 *iface, const char *buffer)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, debugstr_a(buffer));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODVCALLTYPE debugcontrol_Output(IDebugControl2 *iface, ULONG mask, const char *format, ...)
|
|
{
|
|
FIXME("%p, %#x, %s stub.\n", iface, mask, debugstr_a(format));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl2 *iface, ULONG mask, const char *format,
|
|
__ms_va_list args)
|
|
{
|
|
FIXME("%p, %#x, %s stub.\n", iface, mask, debugstr_a(format));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl2 *iface, ULONG output_control,
|
|
ULONG mask, const char *format, ...)
|
|
{
|
|
FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, mask, debugstr_a(format));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugControl2 *iface, ULONG output_control,
|
|
ULONG mask, const char *format, __ms_va_list args)
|
|
{
|
|
FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, mask, debugstr_a(format));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl2 *iface, ULONG output_control,
|
|
const char *format, ...)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, output_control, debugstr_a(format));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl2 *iface, ULONG output_control,
|
|
const char *format, __ms_va_list args)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, output_control, debugstr_a(format));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptText(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
|
|
ULONG *text_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, text_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl2 *iface, ULONG output_control,
|
|
ULONG flags)
|
|
{
|
|
FIXME("%p, %u, %#x stub.\n", iface, output_control, flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVersionInformation(IDebugControl2 *iface, ULONG output_control)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, output_control);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNotifyEventHandle(IDebugControl2 *iface, ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, handle);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetNotifyEventHandle(IDebugControl2 *iface, ULONG64 handle)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_Assemble(IDebugControl2 *iface, ULONG64 offset, const char *code,
|
|
ULONG64 *end_offset)
|
|
{
|
|
FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), debugstr_a(code), end_offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_Disassemble(IDebugControl2 *iface, ULONG64 offset, ULONG flags,
|
|
char *buffer, ULONG buffer_size, ULONG *disassm_size, ULONG64 *end_offset)
|
|
{
|
|
FIXME("%p, %s, %#x, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
|
|
disassm_size, end_offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetDisassembleEffectiveOffset(IDebugControl2 *iface, ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl2 *iface, ULONG output_control,
|
|
ULONG64 offset, ULONG flags, ULONG64 *end_offset)
|
|
{
|
|
FIXME("%p, %u, %s, %#x, %p stub.\n", iface, output_control, wine_dbgstr_longlong(offset), flags, end_offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugControl2 *iface, ULONG output_control,
|
|
ULONG prev_lines, ULONG total_lines, ULONG64 offset, ULONG flags, ULONG *offset_line, ULONG64 *start_offset,
|
|
ULONG64 *end_offset, ULONG64 *line_offsets)
|
|
{
|
|
FIXME("%p, %u, %u, %u, %s, %#x, %p, %p, %p, %p stub.\n", iface, output_control, prev_lines, total_lines,
|
|
wine_dbgstr_longlong(offset), flags, offset_line, start_offset, end_offset, line_offsets);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNearInstruction(IDebugControl2 *iface, ULONG64 offset, LONG delta,
|
|
ULONG64 *instr_offset)
|
|
{
|
|
FIXME("%p, %s, %d, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, instr_offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetStackTrace(IDebugControl2 *iface, ULONG64 frame_offset,
|
|
ULONG64 stack_offset, ULONG64 instr_offset, DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG *frames_filled)
|
|
{
|
|
FIXME("%p, %s, %s, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(frame_offset),
|
|
wine_dbgstr_longlong(stack_offset), wine_dbgstr_longlong(instr_offset), frames, frames_size, frames_filled);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetReturnOffset(IDebugControl2 *iface, ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl2 *iface, ULONG output_control,
|
|
DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG flags)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %#x stub.\n", iface, output_control, frames, frames_size, flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl2 *iface, ULONG *debug_class,
|
|
ULONG *qualifier)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
static struct target_process *target;
|
|
|
|
FIXME("%p, %p, %p stub.\n", iface, debug_class, qualifier);
|
|
|
|
*debug_class = DEBUG_CLASS_UNINITIALIZED;
|
|
*qualifier = 0;
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
*debug_class = DEBUG_CLASS_USER_WINDOWS;
|
|
*qualifier = DEBUG_USER_WINDOWS_PROCESS;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetActualProcessorType(IDebugControl2 *iface, ULONG *type)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, type);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutingProcessorType(IDebugControl2 *iface, ULONG *type)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
static struct target_process *target;
|
|
HRESULT hr;
|
|
|
|
TRACE("%p, %p.\n", iface, type);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (FAILED(hr = debug_target_init_modules_info(target)))
|
|
return hr;
|
|
|
|
*type = target->cpu_type;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberPossibleExecutingProcessorTypes(IDebugControl2 *iface,
|
|
ULONG *count)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetPossibleExecutingProcessorTypes(IDebugControl2 *iface, ULONG start,
|
|
ULONG count, ULONG *types)
|
|
{
|
|
FIXME("%p, %u, %u, %p stub.\n", iface, start, count, types);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberProcessors(IDebugControl2 *iface, ULONG *count)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersion(IDebugControl2 *iface, ULONG *platform_id, ULONG *major,
|
|
ULONG *minor, char *sp_string, ULONG sp_string_size, ULONG *sp_string_used, ULONG *sp_number,
|
|
char *build_string, ULONG build_string_size, ULONG *build_string_used)
|
|
{
|
|
FIXME("%p, %p, %p, %p, %p, %u, %p, %p, %p, %u, %p stub.\n", iface, platform_id, major, minor, sp_string,
|
|
sp_string_size, sp_string_used, sp_number, build_string, build_string_size, build_string_used);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetPageSize(IDebugControl2 *iface, ULONG *size)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_IsPointer64Bit(IDebugControl2 *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
static struct target_process *target;
|
|
HRESULT hr;
|
|
|
|
TRACE("%p.\n", iface);
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (FAILED(hr = debug_target_init_modules_info(target)))
|
|
return hr;
|
|
|
|
switch (target->cpu_type)
|
|
{
|
|
case IMAGE_FILE_MACHINE_I386:
|
|
case IMAGE_FILE_MACHINE_ARM:
|
|
hr = S_FALSE;
|
|
break;
|
|
case IMAGE_FILE_MACHINE_IA64:
|
|
case IMAGE_FILE_MACHINE_AMD64:
|
|
case IMAGE_FILE_MACHINE_ARM64:
|
|
hr = S_OK;
|
|
break;
|
|
default:
|
|
FIXME("Unexpected cpu type %#x.\n", target->cpu_type);
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_ReadBugCheckData(IDebugControl2 *iface, ULONG *code, ULONG64 *arg1,
|
|
ULONG64 *arg2, ULONG64 *arg3, ULONG64 *arg4)
|
|
{
|
|
FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, code, arg1, arg2, arg3, arg4);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberSupportedProcessorTypes(IDebugControl2 *iface, ULONG *count)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetSupportedProcessorTypes(IDebugControl2 *iface, ULONG start,
|
|
ULONG count, ULONG *types)
|
|
{
|
|
FIXME("%p, %u, %u, %p stub.\n", iface, start, count, types);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugControl2 *iface, ULONG type, char *full_name,
|
|
ULONG full_name_buffer_size, ULONG *full_name_size, char *abbrev_name, ULONG abbrev_name_buffer_size,
|
|
ULONG *abbrev_name_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p, %p, %u, %p stub.\n", iface, type, full_name, full_name_buffer_size, full_name_size,
|
|
abbrev_name, abbrev_name_buffer_size, abbrev_name_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetEffectiveProcessorType(IDebugControl2 *iface, ULONG *type)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, type);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetEffectiveProcessorType(IDebugControl2 *iface, ULONG type)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, type);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutionStatus(IDebugControl2 *iface, ULONG *status)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, status);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetExecutionStatus(IDebugControl2 *iface, ULONG status)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, status);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetCodeLevel(IDebugControl2 *iface, ULONG *level)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, level);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetCodeLevel(IDebugControl2 *iface, ULONG level)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, level);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetEngineOptions(IDebugControl2 *iface, ULONG *options)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
|
|
TRACE("%p, %p.\n", iface, options);
|
|
|
|
*options = debug_client->engine_options;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_AddEngineOptions(IDebugControl2 *iface, ULONG options)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
|
|
TRACE("%p, %#x.\n", iface, options);
|
|
|
|
if (options & ~DEBUG_ENGOPT_ALL)
|
|
return E_INVALIDARG;
|
|
|
|
debug_client->engine_options |= options;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveEngineOptions(IDebugControl2 *iface, ULONG options)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
|
|
TRACE("%p, %#x.\n", iface, options);
|
|
|
|
debug_client->engine_options &= ~options;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetEngineOptions(IDebugControl2 *iface, ULONG options)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
|
|
TRACE("%p, %#x.\n", iface, options);
|
|
|
|
if (options & ~DEBUG_ENGOPT_ALL)
|
|
return E_INVALIDARG;
|
|
|
|
debug_client->engine_options = options;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugControl2 *iface, ULONG *output_level,
|
|
ULONG *break_level)
|
|
{
|
|
FIXME("%p, %p, %p stub.\n", iface, output_level, break_level);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugControl2 *iface, ULONG output_level,
|
|
ULONG break_level)
|
|
{
|
|
FIXME("%p, %u, %u stub.\n", iface, output_level, break_level);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacro(IDebugControl2 *iface, ULONG slot, char *buffer,
|
|
ULONG buffer_size, ULONG *macro_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacro(IDebugControl2 *iface, ULONG slot, const char *macro)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, slot, debugstr_a(macro));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetRadix(IDebugControl2 *iface, ULONG *radix)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, radix);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetRadix(IDebugControl2 *iface, ULONG radix)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, radix);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl2 *iface, const char *expression,
|
|
ULONG desired_type, DEBUG_VALUE *value, ULONG *remainder_index)
|
|
{
|
|
FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_a(expression), desired_type, value, remainder_index);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValue(IDebugControl2 *iface, DEBUG_VALUE input, ULONG output_type,
|
|
DEBUG_VALUE *output)
|
|
{
|
|
FIXME("%p, %u, %p stub.\n", iface, output_type, output);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValues(IDebugControl2 *iface, ULONG count, DEBUG_VALUE *input,
|
|
ULONG *output_types, DEBUG_VALUE *output)
|
|
{
|
|
FIXME("%p, %u, %p, %p, %p stub.\n", iface, count, input, output_types, output);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl2 *iface, ULONG output_control, const char *command,
|
|
ULONG flags)
|
|
{
|
|
FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(command), flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl2 *iface, ULONG output_control,
|
|
const char *command_file, ULONG flags)
|
|
{
|
|
FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(command_file), flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberBreakpoints(IDebugControl2 *iface, ULONG *count)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex(IDebugControl2 *iface, ULONG index,
|
|
IDebugBreakpoint **bp)
|
|
{
|
|
FIXME("%p, %u, %p stub.\n", iface, index, bp);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById(IDebugControl2 *iface, ULONG id, IDebugBreakpoint **bp)
|
|
{
|
|
FIXME("%p, %u, %p stub.\n", iface, id, bp);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointParameters(IDebugControl2 *iface, ULONG count, ULONG *ids,
|
|
ULONG start, DEBUG_BREAKPOINT_PARAMETERS *parameters)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, count, ids, start, parameters);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl2 *iface, ULONG type, ULONG desired_id,
|
|
IDebugBreakpoint **bp)
|
|
{
|
|
FIXME("%p, %u, %u, %p stub.\n", iface, type, desired_id, bp);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint(IDebugControl2 *iface, IDebugBreakpoint *bp)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, bp);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtension(IDebugControl2 *iface, const char *path, ULONG flags,
|
|
ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %s, %#x, %p stub.\n", iface, debugstr_a(path), flags, handle);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveExtension(IDebugControl2 *iface, ULONG64 handle)
|
|
{
|
|
FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPath(IDebugControl2 *iface, const char *path,
|
|
ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, debugstr_a(path), handle);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtension(IDebugControl2 *iface, ULONG64 handle,
|
|
const char *function, const char *args)
|
|
{
|
|
FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(function), debugstr_a(args));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunction(IDebugControl2 *iface, ULONG64 handle,
|
|
const char *name, void *function)
|
|
{
|
|
FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(name), function);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis32(IDebugControl2 *iface,
|
|
PWINDBG_EXTENSION_APIS32 api)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, api);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis64(IDebugControl2 *iface,
|
|
PWINDBG_EXTENSION_APIS64 api)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, api);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugControl2 *iface, ULONG *specific_events,
|
|
ULONG *specific_exceptions, ULONG *arbitrary_exceptions)
|
|
{
|
|
FIXME("%p, %p, %p, %p stub.\n", iface, specific_events, specific_exceptions, arbitrary_exceptions);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterText(IDebugControl2 *iface, ULONG index, char *buffer,
|
|
ULONG buffer_size, ULONG *text_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, text_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommand(IDebugControl2 *iface, ULONG index, char *buffer,
|
|
ULONG buffer_size, ULONG *command_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, command_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommand(IDebugControl2 *iface, ULONG index,
|
|
const char *command)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(command));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterParameters(IDebugControl2 *iface, ULONG start,
|
|
ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
|
|
{
|
|
FIXME("%p, %u, %u, %p stub.\n", iface, start, count, parameters);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterParameters(IDebugControl2 *iface, ULONG start,
|
|
ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
|
|
{
|
|
FIXME("%p, %u, %u, %p stub.\n", iface, start, count, parameters);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgument(IDebugControl2 *iface, ULONG index,
|
|
char *buffer, ULONG buffer_size, ULONG *argument_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgument(IDebugControl2 *iface, ULONG index,
|
|
const char *argument)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(argument));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterParameters(IDebugControl2 *iface, ULONG count,
|
|
ULONG *codes, ULONG start, DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, count, codes, start, parameters);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterParameters(IDebugControl2 *iface, ULONG count,
|
|
DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
|
|
{
|
|
FIXME("%p, %u, %p stub.\n", iface, count, parameters);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterSecondCommand(IDebugControl2 *iface, ULONG index,
|
|
char *buffer, ULONG buffer_size, ULONG *command_size)
|
|
{
|
|
FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, command_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterSecondCommand(IDebugControl2 *iface, ULONG index,
|
|
const char *command)
|
|
{
|
|
FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(command));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_WaitForEvent(IDebugControl2 *iface, ULONG flags, ULONG timeout)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugControl2(iface);
|
|
struct target_process *target;
|
|
|
|
TRACE("%p, %#x, %u.\n", iface, flags, timeout);
|
|
|
|
/* FIXME: only one target is used currently */
|
|
|
|
if (!(target = debug_client_get_target(debug_client)))
|
|
return E_UNEXPECTED;
|
|
|
|
if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
|
|
{
|
|
BOOL suspend = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
|
|
DWORD access = PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_QUERY_LIMITED_INFORMATION;
|
|
NTSTATUS status;
|
|
|
|
if (suspend)
|
|
access |= PROCESS_SUSPEND_RESUME;
|
|
|
|
target->handle = OpenProcess(access, FALSE, target->pid);
|
|
if (!target->handle)
|
|
{
|
|
WARN("Failed to get process handle for pid %#x.\n", target->pid);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
if (suspend)
|
|
{
|
|
status = NtSuspendProcess(target->handle);
|
|
if (status)
|
|
WARN("Failed to suspend a process, status %#x.\n", status);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
FIXME("Unsupported attach flags %#x.\n", target->attach_flags);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformation(IDebugControl2 *iface, ULONG *type, ULONG *pid,
|
|
ULONG *tid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, char *description,
|
|
ULONG desc_size, ULONG *desc_used)
|
|
{
|
|
FIXME("%p, %p, %p, %p, %p, %u, %p, %p, %u, %p stub.\n", iface, type, pid, tid, extra_info, extra_info_size,
|
|
extra_info_used, description, desc_size, desc_used);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentTimeDate(IDebugControl2 *iface, ULONG timedate)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, timedate);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentSystemUpTime(IDebugControl2 *iface, ULONG uptime)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, uptime);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetDumpFormatFlags(IDebugControl2 *iface, ULONG *flags)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextPlacements(IDebugControl2 *iface, ULONG *count)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextReplacement(IDebugControl2 *iface, const char *src_text,
|
|
ULONG index, char *src_buffer, ULONG src_buffer_size, ULONG *src_size, char *dst_buffer,
|
|
ULONG dst_buffer_size, ULONG *dst_size)
|
|
{
|
|
FIXME("%p, %s, %u, %p, %u, %p, %p, %u, %p stub.\n", iface, debugstr_a(src_text), index, src_buffer,
|
|
src_buffer_size, src_size, dst_buffer, dst_buffer_size, dst_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacement(IDebugControl2 *iface, const char *src_text,
|
|
const char *dst_text)
|
|
{
|
|
FIXME("%p, %s, %s stub.\n", iface, debugstr_a(src_text), debugstr_a(dst_text));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveTextReplacements(IDebugControl2 *iface)
|
|
{
|
|
FIXME("%p stub.\n", iface);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugcontrol_OutputTextReplacements(IDebugControl2 *iface, ULONG output_control,
|
|
ULONG flags)
|
|
{
|
|
FIXME("%p, %u, %#x stub.\n", iface, output_control, flags);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IDebugControl2Vtbl debugcontrolvtbl =
|
|
{
|
|
debugcontrol_QueryInterface,
|
|
debugcontrol_AddRef,
|
|
debugcontrol_Release,
|
|
debugcontrol_GetInterrupt,
|
|
debugcontrol_SetInterrupt,
|
|
debugcontrol_GetInterruptTimeout,
|
|
debugcontrol_SetInterruptTimeout,
|
|
debugcontrol_GetLogFile,
|
|
debugcontrol_OpenLogFile,
|
|
debugcontrol_CloseLogFile,
|
|
debugcontrol_GetLogMask,
|
|
debugcontrol_SetLogMask,
|
|
debugcontrol_Input,
|
|
debugcontrol_ReturnInput,
|
|
debugcontrol_Output,
|
|
debugcontrol_OutputVaList,
|
|
debugcontrol_ControlledOutput,
|
|
debugcontrol_ControlledOutputVaList,
|
|
debugcontrol_OutputPrompt,
|
|
debugcontrol_OutputPromptVaList,
|
|
debugcontrol_GetPromptText,
|
|
debugcontrol_OutputCurrentState,
|
|
debugcontrol_OutputVersionInformation,
|
|
debugcontrol_GetNotifyEventHandle,
|
|
debugcontrol_SetNotifyEventHandle,
|
|
debugcontrol_Assemble,
|
|
debugcontrol_Disassemble,
|
|
debugcontrol_GetDisassembleEffectiveOffset,
|
|
debugcontrol_OutputDisassembly,
|
|
debugcontrol_OutputDisassemblyLines,
|
|
debugcontrol_GetNearInstruction,
|
|
debugcontrol_GetStackTrace,
|
|
debugcontrol_GetReturnOffset,
|
|
debugcontrol_OutputStackTrace,
|
|
debugcontrol_GetDebuggeeType,
|
|
debugcontrol_GetActualProcessorType,
|
|
debugcontrol_GetExecutingProcessorType,
|
|
debugcontrol_GetNumberPossibleExecutingProcessorTypes,
|
|
debugcontrol_GetPossibleExecutingProcessorTypes,
|
|
debugcontrol_GetNumberProcessors,
|
|
debugcontrol_GetSystemVersion,
|
|
debugcontrol_GetPageSize,
|
|
debugcontrol_IsPointer64Bit,
|
|
debugcontrol_ReadBugCheckData,
|
|
debugcontrol_GetNumberSupportedProcessorTypes,
|
|
debugcontrol_GetSupportedProcessorTypes,
|
|
debugcontrol_GetProcessorTypeNames,
|
|
debugcontrol_GetEffectiveProcessorType,
|
|
debugcontrol_SetEffectiveProcessorType,
|
|
debugcontrol_GetExecutionStatus,
|
|
debugcontrol_SetExecutionStatus,
|
|
debugcontrol_GetCodeLevel,
|
|
debugcontrol_SetCodeLevel,
|
|
debugcontrol_GetEngineOptions,
|
|
debugcontrol_AddEngineOptions,
|
|
debugcontrol_RemoveEngineOptions,
|
|
debugcontrol_SetEngineOptions,
|
|
debugcontrol_GetSystemErrorControl,
|
|
debugcontrol_SetSystemErrorControl,
|
|
debugcontrol_GetTextMacro,
|
|
debugcontrol_SetTextMacro,
|
|
debugcontrol_GetRadix,
|
|
debugcontrol_SetRadix,
|
|
debugcontrol_Evaluate,
|
|
debugcontrol_CoerceValue,
|
|
debugcontrol_CoerceValues,
|
|
debugcontrol_Execute,
|
|
debugcontrol_ExecuteCommandFile,
|
|
debugcontrol_GetNumberBreakpoints,
|
|
debugcontrol_GetBreakpointByIndex,
|
|
debugcontrol_GetBreakpointById,
|
|
debugcontrol_GetBreakpointParameters,
|
|
debugcontrol_AddBreakpoint,
|
|
debugcontrol_RemoveBreakpoint,
|
|
debugcontrol_AddExtension,
|
|
debugcontrol_RemoveExtension,
|
|
debugcontrol_GetExtensionByPath,
|
|
debugcontrol_CallExtension,
|
|
debugcontrol_GetExtensionFunction,
|
|
debugcontrol_GetWindbgExtensionApis32,
|
|
debugcontrol_GetWindbgExtensionApis64,
|
|
debugcontrol_GetNumberEventFilters,
|
|
debugcontrol_GetEventFilterText,
|
|
debugcontrol_GetEventFilterCommand,
|
|
debugcontrol_SetEventFilterCommand,
|
|
debugcontrol_GetSpecificFilterParameters,
|
|
debugcontrol_SetSpecificFilterParameters,
|
|
debugcontrol_GetSpecificFilterArgument,
|
|
debugcontrol_SetSpecificFilterArgument,
|
|
debugcontrol_GetExceptionFilterParameters,
|
|
debugcontrol_SetExceptionFilterParameters,
|
|
debugcontrol_GetExceptionFilterSecondCommand,
|
|
debugcontrol_SetExceptionFilterSecondCommand,
|
|
debugcontrol_WaitForEvent,
|
|
debugcontrol_GetLastEventInformation,
|
|
debugcontrol_GetCurrentTimeDate,
|
|
debugcontrol_GetCurrentSystemUpTime,
|
|
debugcontrol_GetDumpFormatFlags,
|
|
debugcontrol_GetNumberTextPlacements,
|
|
debugcontrol_GetNumberTextReplacement,
|
|
debugcontrol_SetTextReplacement,
|
|
debugcontrol_RemoveTextReplacements,
|
|
debugcontrol_OutputTextReplacements,
|
|
};
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugadvanced_QueryInterface(IDebugAdvanced *iface, REFIID riid, void **obj)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_QueryInterface(unk, riid, obj);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugadvanced_AddRef(IDebugAdvanced *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_AddRef(unk);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugadvanced_Release(IDebugAdvanced *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_Release(unk);
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugadvanced_GetThreadContext(IDebugAdvanced *iface, void *context,
|
|
ULONG context_size)
|
|
{
|
|
FIXME("%p, %p, %u stub.\n", iface, context, context_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugadvanced_SetThreadContext(IDebugAdvanced *iface, void *context,
|
|
ULONG context_size)
|
|
{
|
|
FIXME("%p, %p, %u stub.\n", iface, context, context_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IDebugAdvancedVtbl debugadvancedvtbl =
|
|
{
|
|
debugadvanced_QueryInterface,
|
|
debugadvanced_AddRef,
|
|
debugadvanced_Release,
|
|
/* IDebugAdvanced */
|
|
debugadvanced_GetThreadContext,
|
|
debugadvanced_SetThreadContext,
|
|
};
|
|
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_QueryInterface(IDebugSystemObjects *iface, REFIID riid, void **obj)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_QueryInterface(unk, riid, obj);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugsystemobjects_AddRef(IDebugSystemObjects *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_AddRef(unk);
|
|
}
|
|
|
|
static ULONG STDMETHODCALLTYPE debugsystemobjects_Release(IDebugSystemObjects *iface)
|
|
{
|
|
struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
|
|
IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
return IUnknown_Release(unk);
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventThread(IDebugSystemObjects *iface, ULONG *id)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventProcess(IDebugSystemObjects *iface, ULONG *id)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadId(IDebugSystemObjects *iface, ULONG *id)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_SetCurrentThreadId(IDebugSystemObjects *iface, ULONG id)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_SetCurrentProcessId(IDebugSystemObjects *iface, ULONG id)
|
|
{
|
|
FIXME("%p, %u stub.\n", iface, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberThreads(IDebugSystemObjects *iface, ULONG *number)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, number);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetTotalNumberThreads(IDebugSystemObjects *iface, ULONG *total,
|
|
ULONG *largest_process)
|
|
{
|
|
FIXME("%p, %p, %p stub.\n", iface, total, largest_process);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdsByIndex(IDebugSystemObjects *iface, ULONG start,
|
|
ULONG count, ULONG *ids, ULONG *sysids)
|
|
{
|
|
FIXME("%p, %u, %u, %p, %p stub.\n", iface, start, count, ids, sysids);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByProcessor(IDebugSystemObjects *iface, ULONG processor,
|
|
ULONG *id)
|
|
{
|
|
FIXME("%p, %u, %p stub.\n", iface, processor, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadDataOffset(IDebugSystemObjects *iface,
|
|
ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByDataOffset(IDebugSystemObjects *iface, ULONG64 offset,
|
|
ULONG *id)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadTeb(IDebugSystemObjects *iface, ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByTeb(IDebugSystemObjects *iface, ULONG64 offset,
|
|
ULONG *id)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadSystemId(IDebugSystemObjects *iface, ULONG *sysid)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, sysid);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
|
|
ULONG *id)
|
|
{
|
|
FIXME("%p, %u, %p stub.\n", iface, sysid, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentThreadHandle(IDebugSystemObjects *iface, ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, handle);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
|
|
ULONG *id)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberProcesses(IDebugSystemObjects *iface, ULONG *number)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, number);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdsByIndex(IDebugSystemObjects *iface, ULONG start,
|
|
ULONG count, ULONG *ids, ULONG *sysids)
|
|
{
|
|
FIXME("%p, %u, %u, %p, %p stub.\n", iface, start, count, ids, sysids);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessDataOffset(IDebugSystemObjects *iface,
|
|
ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByDataOffset(IDebugSystemObjects *iface,
|
|
ULONG64 offset, ULONG *id)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessPeb(IDebugSystemObjects *iface, ULONG64 *offset)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, offset);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByPeb(IDebugSystemObjects *iface, ULONG64 offset,
|
|
ULONG *id)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessSystemId(IDebugSystemObjects *iface, ULONG *sysid)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, sysid);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
|
|
ULONG *id)
|
|
{
|
|
FIXME("%p, %u, %p stub.\n", iface, sysid, id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessHandle(IDebugSystemObjects *iface,
|
|
ULONG64 *handle)
|
|
{
|
|
FIXME("%p, %p stub.\n", iface, handle);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
|
|
ULONG *id)
|
|
{
|
|
FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetCurrentProcessExecutableName(IDebugSystemObjects *iface,
|
|
char *buffer, ULONG buffer_size, ULONG *exe_size)
|
|
{
|
|
FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, exe_size);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IDebugSystemObjectsVtbl debugsystemobjectsvtbl =
|
|
{
|
|
debugsystemobjects_QueryInterface,
|
|
debugsystemobjects_AddRef,
|
|
debugsystemobjects_Release,
|
|
debugsystemobjects_GetEventThread,
|
|
debugsystemobjects_GetEventProcess,
|
|
debugsystemobjects_GetCurrentThreadId,
|
|
debugsystemobjects_SetCurrentThreadId,
|
|
debugsystemobjects_SetCurrentProcessId,
|
|
debugsystemobjects_GetNumberThreads,
|
|
debugsystemobjects_GetTotalNumberThreads,
|
|
debugsystemobjects_GetThreadIdsByIndex,
|
|
debugsystemobjects_GetThreadIdByProcessor,
|
|
debugsystemobjects_GetCurrentThreadDataOffset,
|
|
debugsystemobjects_GetThreadIdByDataOffset,
|
|
debugsystemobjects_GetCurrentThreadTeb,
|
|
debugsystemobjects_GetThreadIdByTeb,
|
|
debugsystemobjects_GetCurrentThreadSystemId,
|
|
debugsystemobjects_GetThreadIdBySystemId,
|
|
debugsystemobjects_GetCurrentThreadHandle,
|
|
debugsystemobjects_GetThreadIdByHandle,
|
|
debugsystemobjects_GetNumberProcesses,
|
|
debugsystemobjects_GetProcessIdsByIndex,
|
|
debugsystemobjects_GetCurrentProcessDataOffset,
|
|
debugsystemobjects_GetProcessIdByDataOffset,
|
|
debugsystemobjects_GetCurrentProcessPeb,
|
|
debugsystemobjects_GetProcessIdByPeb,
|
|
debugsystemobjects_GetCurrentProcessSystemId,
|
|
debugsystemobjects_GetProcessIdBySystemId,
|
|
debugsystemobjects_GetCurrentProcessHandle,
|
|
debugsystemobjects_GetProcessIdByHandle,
|
|
debugsystemobjects_GetCurrentProcessExecutableName,
|
|
};
|
|
|
|
/************************************************************
|
|
* DebugExtensionInitialize (DBGENG.@)
|
|
*
|
|
* Initializing Debug Engine
|
|
*
|
|
* PARAMS
|
|
* pVersion [O] Receiving the version of extension
|
|
* pFlags [O] Reserved
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK
|
|
* Failure: Anything other than S_OK
|
|
*
|
|
* BUGS
|
|
* Unimplemented
|
|
*/
|
|
HRESULT WINAPI DebugExtensionInitialize(ULONG * pVersion, ULONG * pFlags)
|
|
{
|
|
FIXME("(%p,%p): stub\n", pVersion, pFlags);
|
|
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/************************************************************
|
|
* DebugCreate (dbgeng.@)
|
|
*/
|
|
HRESULT WINAPI DebugCreate(REFIID riid, void **obj)
|
|
{
|
|
struct debug_client *debug_client;
|
|
IUnknown *unk;
|
|
HRESULT hr;
|
|
|
|
TRACE("%s, %p.\n", debugstr_guid(riid), obj);
|
|
|
|
debug_client = heap_alloc_zero(sizeof(*debug_client));
|
|
if (!debug_client)
|
|
return E_OUTOFMEMORY;
|
|
|
|
debug_client->IDebugClient_iface.lpVtbl = &debugclientvtbl;
|
|
debug_client->IDebugDataSpaces_iface.lpVtbl = &debugdataspacesvtbl;
|
|
debug_client->IDebugSymbols3_iface.lpVtbl = &debugsymbolsvtbl;
|
|
debug_client->IDebugControl2_iface.lpVtbl = &debugcontrolvtbl;
|
|
debug_client->IDebugAdvanced_iface.lpVtbl = &debugadvancedvtbl;
|
|
debug_client->IDebugSystemObjects_iface.lpVtbl = &debugsystemobjectsvtbl;
|
|
debug_client->refcount = 1;
|
|
list_init(&debug_client->targets);
|
|
|
|
unk = (IUnknown *)&debug_client->IDebugClient_iface;
|
|
|
|
hr = IUnknown_QueryInterface(unk, riid, obj);
|
|
IUnknown_Release(unk);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/************************************************************
|
|
* DebugCreateEx (DBGENG.@)
|
|
*/
|
|
HRESULT WINAPI DebugCreateEx(REFIID riid, DWORD flags, void **obj)
|
|
{
|
|
FIXME("(%s, %#x, %p): stub\n", debugstr_guid(riid), flags, obj);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/************************************************************
|
|
* DebugConnect (DBGENG.@)
|
|
*
|
|
* Creating Debug Engine client object and connecting it to remote host
|
|
*
|
|
* PARAMS
|
|
* RemoteOptions [I] Options which define how debugger engine connects to remote host
|
|
* InterfaceId [I] Interface Id of debugger client
|
|
* pInterface [O] Pointer to interface as requested via InterfaceId
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK
|
|
* Failure: Anything other than S_OK
|
|
*
|
|
* BUGS
|
|
* Unimplemented
|
|
*/
|
|
HRESULT WINAPI DebugConnect(PCSTR RemoteOptions, REFIID InterfaceId, PVOID * pInterface)
|
|
{
|
|
FIXME("(%p,%p,%p): stub\n", RemoteOptions, InterfaceId, pInterface);
|
|
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
|
|
return E_NOTIMPL;
|
|
}
|