ReactOS 0.4.15-dev-8428-g6910fa6
dbgeng.c
Go to the documentation of this file.
1/*
2 * Support for Microsoft Debugging Extension API
3 *
4 * Copyright (C) 2010 Volodymyr Shcherbyna
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21#include <stdarg.h>
22
23#define COBJMACROS
24
25#include "windef.h"
26#include "winbase.h"
27#ifdef __REACTOS__
28#include "wine/winternl.h"
29#else
30#include "winternl.h"
31#endif
32#include "psapi.h"
33
34#include "initguid.h"
35#include "dbgeng.h"
36
37#include "wine/debug.h"
38#include "wine/heap.h"
39#include "wine/list.h"
40
42
45
47{
50};
51
53{
54 struct list entry;
55 unsigned int pid;
56 unsigned int attach_flags;
58 struct
59 {
61 unsigned int loaded;
62 unsigned int unloaded;
66};
67
69{
70 IDebugClient7 IDebugClient_iface;
71 IDebugDataSpaces IDebugDataSpaces_iface;
72 IDebugSymbols3 IDebugSymbols3_iface;
73 IDebugControl2 IDebugControl2_iface;
74 IDebugAdvanced IDebugAdvanced_iface;
75 IDebugSystemObjects IDebugSystemObjects_iface;
78 struct list targets;
79 IDebugEventCallbacks *event_callbacks;
80};
81
83{
85 return NULL;
86
88}
89
90static HRESULT debug_target_return_string(const char *str, char *buffer, unsigned int buffer_size,
91 unsigned int *size)
92{
93 unsigned int len = strlen(str), dst_len;
94
95 if (size)
96 *size = len + 1;
97
98 if (buffer && buffer_size)
99 {
100 dst_len = min(len, buffer_size - 1);
101 if (dst_len)
102 memcpy(buffer, str, dst_len);
103 buffer[dst_len] = 0;
104 }
105
106 return len < buffer_size ? S_OK : S_FALSE;
107}
108
110{
111 IMAGE_DOS_HEADER dos = { 0 };
112 WORD machine = 0;
113
114 ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
116 {
117 ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /* PE signature */, &machine,
118 sizeof(machine), NULL);
119 }
120
121 return machine;
122}
123
125{
126 IMAGE_DOS_HEADER dos = { 0 };
127 DWORD timestamp = 0;
128
129 ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
131 {
132 ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /* PE signature */ +
133 FIELD_OFFSET(IMAGE_FILE_HEADER, TimeDateStamp), &timestamp, sizeof(timestamp), NULL);
134 }
135
136 return timestamp;
137}
138
140{
141 unsigned int i, count;
144 DWORD needed;
145
146 if (target->modules.initialized)
147 return S_OK;
148
149 if (!target->handle)
150 return E_UNEXPECTED;
151
152 needed = 0;
153 EnumProcessModules(target->handle, NULL, 0, &needed);
154 if (!needed)
155 return E_FAIL;
156
157 count = needed / sizeof(HMODULE);
158
159 if (!(modules = heap_alloc(count * sizeof(*modules))))
160 return E_OUTOFMEMORY;
161
162 if (!(target->modules.info = heap_alloc_zero(count * sizeof(*target->modules.info))))
163 {
165 return E_OUTOFMEMORY;
166 }
167
168 if (EnumProcessModules(target->handle, modules, count * sizeof(*modules), &needed))
169 {
170 for (i = 0; i < count; ++i)
171 {
172 if (!GetModuleInformation(target->handle, modules[i], &info, sizeof(info)))
173 {
174 WARN("Failed to get module information, error %d.\n", GetLastError());
175 continue;
176 }
177
178 target->modules.info[i].params.Base = (ULONG_PTR)info.lpBaseOfDll;
179 target->modules.info[i].params.Size = info.SizeOfImage;
180 target->modules.info[i].params.TimeDateStamp = debug_target_get_module_timestamp(target, modules[i]);
181
182 GetModuleFileNameExA(target->handle, modules[i], target->modules.info[i].image_name,
183 ARRAY_SIZE(target->modules.info[i].image_name));
184 }
185 }
186
188
190
191 target->modules.loaded = count;
192 target->modules.unloaded = 0; /* FIXME */
193
194 target->modules.initialized = TRUE;
195
196 return S_OK;
197}
198
199static const struct module_info *debug_target_get_module_info(struct target_process *target, unsigned int i)
200{
202 return NULL;
203
204 if (i >= target->modules.loaded)
205 return NULL;
206
207 return &target->modules.info[i];
208}
209
211{
212 unsigned int i;
213
215 return NULL;
216
217 for (i = 0; i < target->modules.loaded; ++i)
218 {
219 if (target->modules.info[i].params.Base == base)
220 return &target->modules.info[i];
221 }
222
223 return NULL;
224}
225
227{
229
230 if (!target->handle)
231 return;
232
233 if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
234 {
235 BOOL resume = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
236
237 if (resume)
238 {
239 if ((status = NtResumeProcess(target->handle)))
240 WARN("Failed to resume process, status %#x.\n", status);
241 }
242 }
243
244 CloseHandle(target->handle);
245 target->handle = NULL;
246}
247
248static struct debug_client *impl_from_IDebugClient(IDebugClient7 *iface)
249{
251}
252
253static struct debug_client *impl_from_IDebugDataSpaces(IDebugDataSpaces *iface)
254{
256}
257
258static struct debug_client *impl_from_IDebugSymbols3(IDebugSymbols3 *iface)
259{
261}
262
263static struct debug_client *impl_from_IDebugControl2(IDebugControl2 *iface)
264{
266}
267
268static struct debug_client *impl_from_IDebugAdvanced(IDebugAdvanced *iface)
269{
271}
272
273static struct debug_client *impl_from_IDebugSystemObjects(IDebugSystemObjects *iface)
274{
276}
277
279{
281
282 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
283
284 if (IsEqualIID(riid, &IID_IDebugClient) ||
285 IsEqualIID(riid, &IID_IDebugClient2) ||
286 IsEqualIID(riid, &IID_IDebugClient3) ||
287 IsEqualIID(riid, &IID_IDebugClient4) ||
288 IsEqualIID(riid, &IID_IDebugClient5) ||
289 IsEqualIID(riid, &IID_IDebugClient6) ||
290 IsEqualIID(riid, &IID_IDebugClient7) ||
292 {
293 *obj = iface;
294 }
295 else if (IsEqualIID(riid, &IID_IDebugDataSpaces))
296 {
298 }
299 else if (IsEqualIID(riid, &IID_IDebugSymbols)
300 || IsEqualIID(riid, &IID_IDebugSymbols2)
301 || IsEqualIID(riid, &IID_IDebugSymbols3))
302 {
304 }
305 else if (IsEqualIID(riid, &IID_IDebugControl2)
306 || IsEqualIID(riid, &IID_IDebugControl))
307 {
309 }
310 else if (IsEqualIID(riid, &IID_IDebugAdvanced))
311 {
313 }
314 else if (IsEqualIID(riid, &IID_IDebugSystemObjects))
315 {
317 }
318 else
319 {
320 WARN("Unsupported interface %s.\n", debugstr_guid(riid));
321 *obj = NULL;
322 return E_NOINTERFACE;
323 }
324
325 IUnknown_AddRef((IUnknown *)*obj);
326 return S_OK;
327}
328
329static ULONG STDMETHODCALLTYPE debugclient_AddRef(IDebugClient7 *iface)
330{
333
334 TRACE("%p, %d.\n", iface, refcount);
335
336 return refcount;
337}
338
340{
341 heap_free(target->modules.info);
343}
344
345static ULONG STDMETHODCALLTYPE debugclient_Release(IDebugClient7 *iface)
346{
349 struct target_process *cur, *cur2;
350
351 TRACE("%p, %d.\n", debug_client, refcount);
352
353 if (!refcount)
354 {
356 {
358 list_remove(&cur->entry);
360 }
364 }
365
366 return refcount;
367}
368
369static HRESULT STDMETHODCALLTYPE debugclient_AttachKernel(IDebugClient7 *iface, ULONG flags, const char *options)
370{
371 FIXME("%p, %#x, %s stub.\n", iface, flags, debugstr_a(options));
372
373 return E_NOTIMPL;
374}
375
377 ULONG buffer_size, ULONG *options_size)
378{
379 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, options_size);
380
381 return E_NOTIMPL;
382}
383
385{
386 FIXME("%p, %s stub.\n", iface, debugstr_a(options));
387
388 return E_NOTIMPL;
389}
390
392 void *reserved)
393{
394 FIXME("%p, %#x, %s, %p stub.\n", iface, flags, debugstr_a(options), reserved);
395
396 return E_NOTIMPL;
397}
398
399static HRESULT STDMETHODCALLTYPE debugclient_ConnectProcessServer(IDebugClient7 *iface, const char *remote_options,
401{
402 FIXME("%p, %s, %p stub.\n", iface, debugstr_a(remote_options), server);
403
404 return E_NOTIMPL;
405}
406
408{
409 FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(server));
410
411 return E_NOTIMPL;
412}
413
415 ULONG *ids, ULONG count, ULONG *actual_count)
416{
417 FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(server), ids, count, actual_count);
418
419 return E_NOTIMPL;
420}
421
423 ULONG64 server, const char *exe_name, ULONG flags, ULONG *id)
424{
425 FIXME("%p, %s, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(exe_name), flags, id);
426
427 return E_NOTIMPL;
428}
429
431 ULONG systemid, ULONG flags, char *exe_name, ULONG exe_name_size, ULONG *actual_exe_name_size,
432 char *description, ULONG description_size, ULONG *actual_description_size)
433{
434 FIXME("%p, %s, %u, %#x, %p, %u, %p, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(server), systemid, flags,
435 exe_name, exe_name_size, actual_exe_name_size, description, description_size, actual_description_size);
436
437 return E_NOTIMPL;
438}
439
441{
443 struct target_process *process;
444
445 TRACE("%p, %s, %u, %#x.\n", iface, wine_dbgstr_longlong(server), pid, flags);
446
447 if (server)
448 {
449 FIXME("Remote debugging is not supported.\n");
450 return E_NOTIMPL;
451 }
452
453 if (!(process = heap_alloc_zero(sizeof(*process))))
454 return E_OUTOFMEMORY;
455
456 process->pid = pid;
457 process->attach_flags = flags;
458
460
461 return S_OK;
462}
463
465 ULONG flags)
466{
467 FIXME("%p, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(cmdline), flags);
468
469 return E_NOTIMPL;
470}
471
474{
475 FIXME("%p, %s, %s, %#x, %u, %#x stub.\n", iface, wine_dbgstr_longlong(server), debugstr_a(cmdline), create_flags,
477
478 return E_NOTIMPL;
479}
480
482{
483 FIXME("%p, %p stub.\n", iface, options);
484
485 return E_NOTIMPL;
486}
487
489{
490 FIXME("%p, %#x stub.\n", iface, options);
491
492 return E_NOTIMPL;
493}
494
496{
497 FIXME("%p, %#x stub.\n", iface, options);
498
499 return E_NOTIMPL;
500}
501
503{
504 FIXME("%p, %#x stub.\n", iface, options);
505
506 return E_NOTIMPL;
507}
508
509static HRESULT STDMETHODCALLTYPE debugclient_OpenDumpFile(IDebugClient7 *iface, const char *filename)
510{
511 FIXME("%p, %s stub.\n", iface, debugstr_a(filename));
512
513 return E_NOTIMPL;
514}
515
517{
518 FIXME("%p, %s, %u stub.\n", iface, debugstr_a(filename), qualifier);
519
520 return E_NOTIMPL;
521}
522
523static HRESULT STDMETHODCALLTYPE debugclient_ConnectSession(IDebugClient7 *iface, ULONG flags, ULONG history_limit)
524{
525 FIXME("%p, %#x, %u stub.\n", iface, flags, history_limit);
526
527 return E_NOTIMPL;
528}
529
530static HRESULT STDMETHODCALLTYPE debugclient_StartServer(IDebugClient7 *iface, const char *options)
531{
532 FIXME("%p, %s stub.\n", iface, debugstr_a(options));
533
534 return E_NOTIMPL;
535}
536
537static HRESULT STDMETHODCALLTYPE debugclient_OutputServers(IDebugClient7 *iface, ULONG output_control,
538 const char *machine, ULONG flags)
539{
540 FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(machine), flags);
541
542 return E_NOTIMPL;
543}
544
546{
547 FIXME("%p stub.\n", iface);
548
549 return E_NOTIMPL;
550}
551
553{
555 struct target_process *target;
556
557 TRACE("%p.\n", iface);
558
560 {
562 }
563
564 return S_OK;
565}
566
568{
569 FIXME("%p, %#x stub.\n", iface, flags);
570
571 return E_NOTIMPL;
572}
573
575{
576 FIXME("%p, %p stub.\n", iface, code);
577
578 return E_NOTIMPL;
579}
580
582{
583 FIXME("%p, %u stub.\n", iface, timeout);
584
585 return E_NOTIMPL;
586}
587
589{
590 FIXME("%p, %p stub.\n", iface, client);
591
592 return E_NOTIMPL;
593}
594
596{
597 FIXME("%p, %p stub.\n", iface, client);
598
599 return E_NOTIMPL;
600}
601
602static HRESULT STDMETHODCALLTYPE debugclient_GetInputCallbacks(IDebugClient7 *iface, IDebugInputCallbacks **callbacks)
603{
604 FIXME("%p, %p stub.\n", iface, callbacks);
605
606 return E_NOTIMPL;
607}
608
609static HRESULT STDMETHODCALLTYPE debugclient_SetInputCallbacks(IDebugClient7 *iface, IDebugInputCallbacks *callbacks)
610{
611 FIXME("%p, %p stub.\n", iface, callbacks);
612
613 return E_NOTIMPL;
614}
615
616static HRESULT STDMETHODCALLTYPE debugclient_GetOutputCallbacks(IDebugClient7 *iface, IDebugOutputCallbacks **callbacks)
617{
618 FIXME("%p, %p stub.\n", iface, callbacks);
619
620 return E_NOTIMPL;
621}
622
623static HRESULT STDMETHODCALLTYPE debugclient_SetOutputCallbacks(IDebugClient7 *iface, IDebugOutputCallbacks *callbacks)
624{
625 FIXME("%p, %p stub.\n", iface, callbacks);
626
627 return E_NOTIMPL;
628}
629
631{
632 FIXME("%p, %p stub.\n", iface, mask);
633
634 return E_NOTIMPL;
635}
636
638{
639 FIXME("%p, %#x stub.\n", iface, mask);
640
641 return E_NOTIMPL;
642}
643
645{
646 FIXME("%p, %p, %p stub.\n", iface, client, mask);
647
648 return E_NOTIMPL;
649}
650
652{
653 FIXME("%p, %p, %#x stub.\n", iface, client, mask);
654
655 return E_NOTIMPL;
656}
657
658static HRESULT STDMETHODCALLTYPE debugclient_GetOutputWidth(IDebugClient7 *iface, ULONG *columns)
659{
660 FIXME("%p, %p stub.\n", iface, columns);
661
662 return E_NOTIMPL;
663}
664
665static HRESULT STDMETHODCALLTYPE debugclient_SetOutputWidth(IDebugClient7 *iface, ULONG columns)
666{
667 FIXME("%p, %u stub.\n", iface, columns);
668
669 return E_NOTIMPL;
670}
671
673 ULONG *prefix_size)
674{
675 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, prefix_size);
676
677 return E_NOTIMPL;
678}
679
680static HRESULT STDMETHODCALLTYPE debugclient_SetOutputLinePrefix(IDebugClient7 *iface, const char *prefix)
681{
682 FIXME("%p, %s stub.\n", iface, debugstr_a(prefix));
683
684 return E_NOTIMPL;
685}
686
688 ULONG *identity_size)
689{
690 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, identity_size);
691
692 return E_NOTIMPL;
693}
694
695static HRESULT STDMETHODCALLTYPE debugclient_OutputIdentity(IDebugClient7 *iface, ULONG output_control, ULONG flags,
696 const char *format)
697{
698 FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, flags, debugstr_a(format));
699
700 return E_NOTIMPL;
701}
702
703static HRESULT STDMETHODCALLTYPE debugclient_GetEventCallbacks(IDebugClient7 *iface, IDebugEventCallbacks **callbacks)
704{
706
707 TRACE("%p, %p.\n", iface, callbacks);
708
710 {
712 (*callbacks)->lpVtbl->AddRef(*callbacks);
713 }
714
715 return S_OK;
716}
717
718static HRESULT STDMETHODCALLTYPE debugclient_SetEventCallbacks(IDebugClient7 *iface, IDebugEventCallbacks *callbacks)
719{
721
722 TRACE("%p, %p.\n", iface, callbacks);
723
728
729 return S_OK;
730}
731
733{
734 FIXME("%p stub.\n", iface);
735
736 return E_NOTIMPL;
737}
738
739static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFile2(IDebugClient7 *iface, const char *dumpfile, ULONG qualifier,
740 ULONG flags, const char *comment)
741{
742 FIXME("%p, %s, %d, 0x%08x, %s.\n", iface, debugstr_a(dumpfile), qualifier, flags, debugstr_a(comment));
743 return E_NOTIMPL;
744}
745
746static HRESULT STDMETHODCALLTYPE debugclient_AddDumpInformationFile(IDebugClient7 *iface, const char *infofile, ULONG type)
747{
748 FIXME("%p, %s, %d.\n", iface, debugstr_a(infofile), type);
749 return E_NOTIMPL;
750}
751
753{
754 FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(server));
755 return E_NOTIMPL;
756}
757
759{
760 FIXME("%p, %d.\n", iface, timeout);
761 return E_NOTIMPL;
762}
763
765{
766 FIXME("%p.\n", iface);
767 return E_NOTIMPL;
768}
769
771{
772 FIXME("%p.\n", iface);
773 return E_NOTIMPL;
774}
775
777{
778 FIXME("%p.\n", iface);
779 return E_NOTIMPL;
780}
781
783{
784 FIXME("%p.\n", iface);
785 return E_NOTIMPL;
786}
787
789 const WCHAR *exename, ULONG flags, ULONG *id)
790{
791 FIXME("%p, %s, %s, 0x%08x, %p.\n", iface, wine_dbgstr_longlong(server), debugstr_w(exename), flags, id);
792 return E_NOTIMPL;
793}
794
796 ULONG flags, WCHAR *exename, ULONG size, ULONG *actualsize, WCHAR *description, ULONG desc_size, ULONG *actual_desc_size)
797{
798 FIXME("%p, %s, %d, 0x%08x, %s, %d, %p, %s, %d, %p.\n", iface, wine_dbgstr_longlong(server), id, flags, debugstr_w(exename), size,
799 actualsize, debugstr_w(description), desc_size, actual_desc_size );
800 return E_NOTIMPL;
801}
802
804{
805 FIXME("%p, %s, %s, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(commandline), flags);
806 return E_NOTIMPL;
807}
808
810 ULONG flags, ULONG processid, ULONG attachflags)
811{
812 FIXME("%p, %s, %s, 0x%08x, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(commandline), flags, processid, attachflags);
813 return E_NOTIMPL;
814}
815
817{
818 FIXME("%p, %s, %s.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle));
819 return E_NOTIMPL;
820}
821
824{
825 FIXME("%p, %s, %s, %d, 0x%08x, %s.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle),
827 return E_NOTIMPL;
828}
829
832{
833 FIXME("%p, %s, %s, %d.\n", iface, debugstr_w(filename), wine_dbgstr_longlong(handle), type);
834 return E_NOTIMPL;
835}
836
838{
839 FIXME("%p, %p.\n", iface, count);
840 return E_NOTIMPL;
841}
842
843static HRESULT STDMETHODCALLTYPE debugclient_GetDumpFile(IDebugClient7 *iface, ULONG index, char *buffer, ULONG buf_size,
844 ULONG *name_size, ULONG64 *handle, ULONG *type)
845{
846 FIXME("%p, %d, %p, %d, %p, %p, %p.\n", iface, index, buffer, buf_size, name_size, handle, type);
847 return E_NOTIMPL;
848}
849
851 ULONG *name_size, ULONG64 *handle, ULONG *type)
852{
853 FIXME("%p, %d, %p, %d, %p, %p, %p.\n", iface, index, buffer, buf_size, name_size, handle, type);
854 return E_NOTIMPL;
855}
856
858{
859 FIXME("%p, 0x%08x, %s.\n", iface, flags, debugstr_w(options));
860 return E_NOTIMPL;
861}
862
864 ULONG buf_size, ULONG *size)
865{
866 FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, size);
867 return E_NOTIMPL;
868}
869
871{
872 FIXME("%p, %p.\n", iface, options);
873 return E_NOTIMPL;
874}
875
877{
878 FIXME("%p, 0x%08x, %s, %p.\n", iface, flags, debugstr_w(options), reserved);
879 return E_NOTIMPL;
880}
881
883{
884 FIXME("%p, %s, %p.\n", iface, debugstr_w(options), server);
885 return E_NOTIMPL;
886}
887
889{
890 FIXME("%p, %s.\n", iface, debugstr_w(options));
891 return E_NOTIMPL;
892}
893
895{
896 FIXME("%p, %d, %s, 0x%08x.\n", iface, control, debugstr_w(machine), flags);
897 return E_NOTIMPL;
898}
899
900static HRESULT STDMETHODCALLTYPE debugclient_GetOutputCallbacksWide(IDebugClient7 *iface, IDebugOutputCallbacksWide **callbacks)
901{
902 FIXME("%p, %p.\n", iface, callbacks);
903 return E_NOTIMPL;
904}
905
906static HRESULT STDMETHODCALLTYPE debugclient_SetOutputCallbacksWide(IDebugClient7 *iface, IDebugOutputCallbacksWide *callbacks)
907{
908 FIXME("%p, %p.\n", iface, callbacks);
909 return E_NOTIMPL;
910}
911
913{
914 FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, size);
915 return E_NOTIMPL;
916}
917
918static HRESULT STDMETHODCALLTYPE debugclient_SetOutputLinePrefixWide(IDebugClient7 *iface, const WCHAR *prefix)
919{
920 FIXME("%p, %s.\n", iface, debugstr_w(prefix));
921 return E_NOTIMPL;
922}
923
925{
926 FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, identity);
927 return E_NOTIMPL;
928}
929
931{
932 FIXME("%p, %d, 0x%08x, %s.\n", iface, control, flags, debugstr_w(format));
933 return E_NOTIMPL;
934}
935
936static HRESULT STDMETHODCALLTYPE debugclient_GetEventCallbacksWide(IDebugClient7 *iface, IDebugEventCallbacksWide **callbacks)
937{
938 FIXME("%p, %p .\n", iface, callbacks);
939 return E_NOTIMPL;
940}
941
942static HRESULT STDMETHODCALLTYPE debugclient_SetEventCallbacksWide(IDebugClient7 *iface, IDebugEventCallbacksWide *callbacks)
943{
944 FIXME("%p .\n", iface);
945 return E_NOTIMPL;
946}
947
949 ULONG buf_size, const char *initial, const char *environment)
950{
951 FIXME("%p %s, %s, %p, %d, %s, %s.\n", iface, wine_dbgstr_longlong(server), debugstr_a(command), options,
952 buf_size, debugstr_a(initial), debugstr_a(environment));
953 return E_NOTIMPL;
954}
955
957 ULONG size, const WCHAR *initial, const WCHAR *environment)
958{
959 FIXME("%p %s, %s, %p, %d, %s, %s.\n", iface, wine_dbgstr_longlong(server), debugstr_w(command), options,
960 size, debugstr_w(initial), debugstr_w(environment));
961 return E_NOTIMPL;
962}
963
965 void *options, ULONG buf_size, const char *initial, const char *environment, ULONG processid, ULONG flags)
966{
967 FIXME("%p %s, %s, %p, %d, %s, %s, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_a(command), options,
968 buf_size, debugstr_a(initial), debugstr_a(environment), processid, flags);
969 return E_NOTIMPL;
970}
971
973 void *buffer, ULONG buf_size, const WCHAR *initial, const WCHAR *environment, ULONG processid, ULONG flags)
974{
975 FIXME("%p %s, %s, %p, %d, %s, %s, %d, 0x%08x.\n", iface, wine_dbgstr_longlong(server), debugstr_w(command), buffer,
976 buf_size, debugstr_w(initial), debugstr_w(environment), processid, flags);
977 return E_NOTIMPL;
978}
979
980static HRESULT STDMETHODCALLTYPE debugclient_PushOutputLinePrefix(IDebugClient7 *iface, const char *prefix, ULONG64 *handle)
981{
982 FIXME("%p, %p.\n", iface, handle);
983 return E_NOTIMPL;
984}
985
987{
988 FIXME("%p, %p.\n", iface, handle);
989 return E_NOTIMPL;
990}
991
993{
994 FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(handle));
995 return E_NOTIMPL;
996}
997
999{
1000 FIXME("%p, %p.\n", iface, count);
1001 return E_NOTIMPL;
1002}
1003
1005{
1006 FIXME("%p, %p.\n", iface, count);
1007 return E_NOTIMPL;
1008}
1009
1011{
1012 FIXME("%p, 0x%08x, %p.\n", iface, flags, count);
1013 return E_NOTIMPL;
1014}
1015
1016static HRESULT STDMETHODCALLTYPE debugclient_GetQuitLockString(IDebugClient7 *iface, char *buffer, ULONG buf_size, ULONG *size)
1017{
1018 FIXME("%p, %s, %d, %p.\n", iface, debugstr_a(buffer), buf_size, size);
1019 return E_NOTIMPL;
1020}
1021
1022static HRESULT STDMETHODCALLTYPE debugclient_SetQuitLockString(IDebugClient7 *iface, char *string)
1023{
1024 FIXME("%p, %s.\n", iface, debugstr_a(string));
1025 return E_NOTIMPL;
1026}
1027
1029{
1030 FIXME("%p, %s, %d, %p.\n", iface, debugstr_w(buffer), buf_size, size);
1031 return E_NOTIMPL;
1032}
1033
1034static HRESULT STDMETHODCALLTYPE debugclient_SetQuitLockStringWide(IDebugClient7 *iface, const WCHAR *string)
1035{
1036 FIXME("%p, %s.\n", iface, debugstr_w(string));
1037 return E_NOTIMPL;
1038}
1039
1040static HRESULT STDMETHODCALLTYPE debugclient_SetEventContextCallbacks(IDebugClient7 *iface, IDebugEventContextCallbacks *callbacks)
1041{
1042 FIXME("%p, %p.\n", iface, callbacks);
1043 return E_NOTIMPL;
1044}
1045
1047{
1048 FIXME("%p, %p, %d.\n", iface, context, size);
1049 return E_NOTIMPL;
1050}
1051
1052static const IDebugClient7Vtbl debugclientvtbl =
1053{
1102 /* IDebugClient2 */
1111 /* IDebugClient3 */
1116 /* IDebugClient4 */
1123 /* IDebugClient5 */
1153 /* IDebugClient6 */
1155 /* IDebugClient7 */
1157};
1158
1160{
1163 return IUnknown_QueryInterface(unk, riid, obj);
1164}
1165
1166static ULONG STDMETHODCALLTYPE debugdataspaces_AddRef(IDebugDataSpaces *iface)
1167{
1170 return IUnknown_AddRef(unk);
1171}
1172
1173static ULONG STDMETHODCALLTYPE debugdataspaces_Release(IDebugDataSpaces *iface)
1174{
1177 return IUnknown_Release(unk);
1178}
1179
1181 ULONG buffer_size, ULONG *read_len)
1182{
1184 static struct target_process *target;
1185 HRESULT hr = S_OK;
1186 SIZE_T length;
1187
1188 TRACE("%p, %s, %p, %u, %p.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1189
1191 return E_UNEXPECTED;
1192
1193 if (ReadProcessMemory(target->handle, (const void *)(ULONG_PTR)offset, buffer, buffer_size, &length))
1194 {
1195 if (read_len)
1196 *read_len = length;
1197 }
1198 else
1199 {
1201 WARN("Failed to read process memory %#x.\n", hr);
1202 }
1203
1204 return hr;
1205}
1206
1208 ULONG buffer_size, ULONG *written)
1209{
1210 FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1211
1212 return E_NOTIMPL;
1213}
1214
1216 void *pattern, ULONG pattern_size, ULONG pattern_granularity, ULONG64 *ret_offset)
1217{
1218 FIXME("%p, %s, %s, %p, %u, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(length),
1219 pattern, pattern_size, pattern_granularity, ret_offset);
1220
1221 return E_NOTIMPL;
1222}
1223
1225 void *buffer, ULONG buffer_size, ULONG *read_len)
1226{
1227 FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1228
1229 return E_NOTIMPL;
1230}
1231
1233 void *buffer, ULONG buffer_size, ULONG *written)
1234{
1235 FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1236
1237 return E_NOTIMPL;
1238}
1239
1241 ULONG64 offset, ULONG64 *pointers)
1242{
1243 FIXME("%p, %u, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset), pointers);
1244
1245 return E_NOTIMPL;
1246}
1247
1249 ULONG64 offset, ULONG64 *pointers)
1250{
1251 FIXME("%p, %u, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset), pointers);
1252
1253 return E_NOTIMPL;
1254}
1255
1257 ULONG buffer_size, ULONG *read_len)
1258{
1259 FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1260
1261 return E_NOTIMPL;
1262}
1263
1265 ULONG buffer_size, ULONG *written)
1266{
1267 FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1268
1269 return E_NOTIMPL;
1270}
1271
1273 void *buffer, ULONG buffer_size, ULONG *read_len)
1274{
1275 FIXME("%p, %u, %s, %p, %u, %p stub.\n", iface, processor, wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
1276
1277 return E_NOTIMPL;
1278}
1279
1281 void *buffer, ULONG buffer_size, ULONG *written)
1282{
1283 FIXME("%p, %u, %s, %p, %u, %p stub.\n", iface, processor, wine_dbgstr_longlong(offset), buffer, buffer_size, written);
1284
1285 return E_NOTIMPL;
1286}
1287
1288static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadIo(IDebugDataSpaces *iface, ULONG type, ULONG bus_number,
1289 ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG *read_len)
1290{
1291 FIXME("%p, %u, %u, %u, %s, %p, %u, %p stub.\n", iface, type, bus_number, address_space, wine_dbgstr_longlong(offset),
1292 buffer, buffer_size, read_len);
1293
1294 return E_NOTIMPL;
1295}
1296
1297static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteIo(IDebugDataSpaces *iface, ULONG type, ULONG bus_number,
1298 ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG *written)
1299{
1300 FIXME("%p, %u, %u, %u, %s, %p, %u, %p stub.\n", iface, type, bus_number, address_space, wine_dbgstr_longlong(offset),
1301 buffer, buffer_size, written);
1302
1303 return E_NOTIMPL;
1304}
1305
1307{
1308 FIXME("%p, %u, %p stub.\n", iface, msr, value);
1309
1310 return E_NOTIMPL;
1311}
1312
1314{
1315 FIXME("%p, %u, %s stub.\n", iface, msr, wine_dbgstr_longlong(value));
1316
1317 return E_NOTIMPL;
1318}
1319
1320static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadBusData(IDebugDataSpaces *iface, ULONG data_type,
1321 ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG buffer_size, ULONG *read_len)
1322{
1323 FIXME("%p, %u, %u, %u, %u, %p, %u, %p stub.\n", iface, data_type, bus_number, slot_number, offset, buffer,
1324 buffer_size, read_len);
1325
1326 return E_NOTIMPL;
1327}
1328
1329static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteBusData(IDebugDataSpaces *iface, ULONG data_type,
1330 ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG buffer_size, ULONG *written)
1331{
1332 FIXME("%p, %u, %u, %u, %u, %p, %u, %p stub.\n", iface, data_type, bus_number, slot_number, offset, buffer,
1333 buffer_size, written);
1334
1335 return E_NOTIMPL;
1336}
1337
1339{
1340 FIXME("%p stub.\n", iface);
1341
1342 return E_NOTIMPL;
1343}
1344
1346 ULONG buffer_size, ULONG *data_size)
1347{
1348 FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, data_size);
1349
1350 return E_NOTIMPL;
1351}
1352
1354 ULONG index, void *buffer, ULONG buffer_size, ULONG *data_size)
1355{
1356 FIXME("%p, %u, %u, %p, %u, %p stub.\n", iface, processor, index, buffer, buffer_size, data_size);
1357
1358 return E_NOTIMPL;
1359}
1360
1361static const IDebugDataSpacesVtbl debugdataspacesvtbl =
1362{
1386};
1387
1389{
1392 return IUnknown_QueryInterface(unk, riid, obj);
1393}
1394
1395static ULONG STDMETHODCALLTYPE debugsymbols_AddRef(IDebugSymbols3 *iface)
1396{
1399 return IUnknown_AddRef(unk);
1400}
1401
1402static ULONG STDMETHODCALLTYPE debugsymbols_Release(IDebugSymbols3 *iface)
1403{
1406 return IUnknown_Release(unk);
1407}
1408
1410{
1411 FIXME("%p, %p stub.\n", iface, options);
1412
1413 return E_NOTIMPL;
1414}
1415
1417{
1418 FIXME("%p, %#x stub.\n", iface, options);
1419
1420 return E_NOTIMPL;
1421}
1422
1424{
1425 FIXME("%p, %#x stub.\n", iface, options);
1426
1427 return E_NOTIMPL;
1428}
1429
1431{
1432 FIXME("%p, %#x stub.\n", iface, options);
1433
1434 return E_NOTIMPL;
1435}
1436
1438 ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
1439{
1440 FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size,
1441 name_size, displacement);
1442
1443 return E_NOTIMPL;
1444}
1445
1446static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByName(IDebugSymbols3 *iface, const char *symbol,
1447 ULONG64 *offset)
1448{
1449 FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), offset);
1450
1451 return E_NOTIMPL;
1452}
1453
1455 char *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
1456{
1457 FIXME("%p, %s, %d, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
1458 name_size, displacement);
1459
1460 return E_NOTIMPL;
1461}
1462
1464 char *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
1465{
1466 FIXME("%p, %s, %p, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
1467 file_size, displacement);
1468
1469 return E_NOTIMPL;
1470}
1471
1472static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLine(IDebugSymbols3 *iface, ULONG line, const char *file,
1473 ULONG64 *offset)
1474{
1475 FIXME("%p, %u, %s, %p stub.\n", iface, line, debugstr_a(file), offset);
1476
1477 return E_NOTIMPL;
1478}
1479
1481{
1483 static struct target_process *target;
1484 HRESULT hr;
1485
1486 TRACE("%p, %p, %p.\n", iface, loaded, unloaded);
1487
1489 return E_UNEXPECTED;
1490
1492 return hr;
1493
1494 *loaded = target->modules.loaded;
1495 *unloaded = target->modules.unloaded;
1496
1497 return S_OK;
1498}
1499
1501{
1503 const struct module_info *info;
1504 struct target_process *target;
1505
1506 TRACE("%p, %u, %p.\n", iface, index, base);
1507
1509 return E_UNEXPECTED;
1510
1512 return E_INVALIDARG;
1513
1514 *base = info->params.Base;
1515
1516 return S_OK;
1517}
1518
1519static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName(IDebugSymbols3 *iface, const char *name,
1520 ULONG start_index, ULONG *index, ULONG64 *base)
1521{
1522 FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_a(name), start_index, index, base);
1523
1524 return E_NOTIMPL;
1525}
1526
1528 ULONG start_index, ULONG *index, ULONG64 *base)
1529{
1531 static struct target_process *target;
1532 const struct module_info *info;
1533
1534 TRACE("%p, %s, %u, %p, %p.\n", iface, wine_dbgstr_longlong(offset), start_index, index, base);
1535
1537 return E_UNEXPECTED;
1538
1539 while ((info = debug_target_get_module_info(target, start_index)))
1540 {
1541 if (offset >= info->params.Base && offset < info->params.Base + info->params.Size)
1542 {
1543 if (index)
1544 *index = start_index;
1545 if (base)
1546 *base = info->params.Base;
1547 return S_OK;
1548 }
1549
1550 start_index++;
1551 }
1552
1553 return E_INVALIDARG;
1554}
1555
1557 char *image_name, ULONG image_name_buffer_size, ULONG *image_name_size, char *module_name,
1558 ULONG module_name_buffer_size, ULONG *module_name_size, char *loaded_image_name,
1559 ULONG loaded_image_name_buffer_size, ULONG *loaded_image_size)
1560{
1561 FIXME("%p, %u, %s, %p, %u, %p, %p, %u, %p, %p, %u, %p stub.\n", iface, index, wine_dbgstr_longlong(base),
1562 image_name, image_name_buffer_size, image_name_size, module_name, module_name_buffer_size,
1563 module_name_size, loaded_image_name, loaded_image_name_buffer_size, loaded_image_size);
1564
1565 return E_NOTIMPL;
1566}
1567
1570{
1572 const struct module_info *info;
1573 struct target_process *target;
1574 unsigned int i;
1575
1576 TRACE("%p, %u, %p, %u, %p.\n", iface, count, bases, start, params);
1577
1579 return E_UNEXPECTED;
1580
1581 if (bases)
1582 {
1583 for (i = 0; i < count; ++i)
1584 {
1586 {
1587 params[i] = info->params;
1588 }
1589 else
1590 {
1591 memset(&params[i], 0, sizeof(*params));
1593 }
1594 }
1595 }
1596 else
1597 {
1598 for (i = start; i < start + count; ++i)
1599 {
1601 return E_INVALIDARG;
1602 params[i] = info->params;
1603 }
1604 }
1605
1606 return S_OK;
1607}
1608
1609static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModule(IDebugSymbols3 *iface, const char *symbol, ULONG64 *base)
1610{
1611 FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), base);
1612
1613 return E_NOTIMPL;
1614}
1615
1617 char *buffer, ULONG buffer_size, ULONG *name_size)
1618{
1619 FIXME("%p, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, buffer,
1620 buffer_size, name_size);
1621
1622 return E_NOTIMPL;
1623}
1624
1625static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeId(IDebugSymbols3 *iface, ULONG64 base, const char *name,
1626 ULONG *type_id)
1627{
1628 FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), debugstr_a(name), type_id);
1629
1630 return E_NOTIMPL;
1631}
1632
1634 ULONG *size)
1635{
1636 FIXME("%p, %s, %u, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, size);
1637
1638 return E_NOTIMPL;
1639}
1640
1642 const char *field, ULONG *offset)
1643{
1644 FIXME("%p, %s, %u, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id, debugstr_a(field), offset);
1645
1646 return E_NOTIMPL;
1647}
1648
1649static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeId(IDebugSymbols3 *iface, const char *symbol, ULONG *type_id,
1650 ULONG64 *base)
1651{
1652 FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_a(symbol), type_id, base);
1653
1654 return E_NOTIMPL;
1655}
1656
1658 ULONG64 *base)
1659{
1660 FIXME("%p, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), type_id, base);
1661
1662 return E_NOTIMPL;
1663}
1664
1666 ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
1667{
1668 FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1669 type_id, buffer, buffer_size, read_len);
1670
1671 return E_NOTIMPL;
1672}
1673
1675 ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
1676{
1677 FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1678 type_id, buffer, buffer_size, written);
1679
1680 return E_NOTIMPL;
1681}
1682
1683static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataVirtual(IDebugSymbols3 *iface, ULONG output_control,
1685{
1686 FIXME("%p, %#x, %s, %s, %u, %#x stub.\n", iface, output_control, wine_dbgstr_longlong(offset),
1688
1689 return E_NOTIMPL;
1690}
1691
1693 ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
1694{
1695 FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1696 type_id, buffer, buffer_size, read_len);
1697
1698 return E_NOTIMPL;
1699}
1700
1703{
1704 FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
1705 type_id, buffer, buffer_size, written);
1706
1707 return E_NOTIMPL;
1708}
1709
1710static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataPhysical(IDebugSymbols3 *iface, ULONG output_control,
1712{
1713 FIXME("%p, %#x, %s, %s, %u, %#x stub.\n", iface, output_control, wine_dbgstr_longlong(offset),
1715
1716 return E_NOTIMPL;
1717}
1718
1719static HRESULT STDMETHODCALLTYPE debugsymbols_GetScope(IDebugSymbols3 *iface, ULONG64 *instr_offset,
1720 DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
1721{
1722 FIXME("%p, %p, %p, %p, %u stub.\n", iface, instr_offset, frame, scope_context, scope_context_size);
1723
1724 return E_NOTIMPL;
1725}
1726
1727static HRESULT STDMETHODCALLTYPE debugsymbols_SetScope(IDebugSymbols3 *iface, ULONG64 instr_offset,
1728 DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
1729{
1730 FIXME("%p, %s, %p, %p, %u stub.\n", iface, wine_dbgstr_longlong(instr_offset), frame, scope_context,
1731 scope_context_size);
1732
1733 return E_NOTIMPL;
1734}
1735
1737{
1738 FIXME("%p stub.\n", iface);
1739
1740 return E_NOTIMPL;
1741}
1742
1744 IDebugSymbolGroup *update, IDebugSymbolGroup **symbols)
1745{
1746 FIXME("%p, %#x, %p, %p stub.\n", iface, flags, update, symbols);
1747
1748 return E_NOTIMPL;
1749}
1750
1751static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup(IDebugSymbols3 *iface, IDebugSymbolGroup **group)
1752{
1753 FIXME("%p, %p stub.\n", iface, group);
1754
1755 return E_NOTIMPL;
1756}
1757
1758static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatch(IDebugSymbols3 *iface, const char *pattern,
1759 ULONG64 *handle)
1760{
1761 FIXME("%p, %s, %p stub.\n", iface, pattern, handle);
1762
1763 return E_NOTIMPL;
1764}
1765
1767 ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
1768{
1769 FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
1770
1771 return E_NOTIMPL;
1772}
1773
1775{
1776 FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
1777
1778 return E_NOTIMPL;
1779}
1780
1781static HRESULT STDMETHODCALLTYPE debugsymbols_Reload(IDebugSymbols3 *iface, const char *path)
1782{
1783 FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1784
1785 return E_NOTIMPL;
1786}
1787
1789 ULONG *path_size)
1790{
1791 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
1792
1793 return E_NOTIMPL;
1794}
1795
1796static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPath(IDebugSymbols3 *iface, const char *path)
1797{
1798 FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1799
1800 return E_NOTIMPL;
1801}
1802
1803static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPath(IDebugSymbols3 *iface, const char *path)
1804{
1805 FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1806
1807 return E_NOTIMPL;
1808}
1809
1811 ULONG *path_size)
1812{
1813 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
1814
1815 return E_NOTIMPL;
1816}
1817
1818static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePath(IDebugSymbols3 *iface, const char *path)
1819{
1820 FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1821
1822 return E_NOTIMPL;
1823}
1824
1825static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePath(IDebugSymbols3 *iface, const char *path)
1826{
1827 FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1828
1829 return E_NOTIMPL;
1830}
1831
1833 ULONG *path_size)
1834{
1835 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
1836
1837 return E_NOTIMPL;
1838}
1839
1841 ULONG buffer_size, ULONG *element_size)
1842{
1843 FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, element_size);
1844
1845 return E_NOTIMPL;
1846}
1847
1848static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePath(IDebugSymbols3 *iface, const char *path)
1849{
1850 FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1851
1852 return E_NOTIMPL;
1853}
1854
1855static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePath(IDebugSymbols3 *iface, const char *path)
1856{
1857 FIXME("%p, %s stub.\n", iface, debugstr_a(path));
1858
1859 return E_NOTIMPL;
1860}
1861
1862static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFile(IDebugSymbols3 *iface, ULONG start, const char *file,
1863 ULONG flags, ULONG *found_element, char *buffer, ULONG buffer_size, ULONG *found_size)
1864{
1865 FIXME("%p, %u, %s, %#x, %p, %p, %u, %p stub.\n", iface, start, debugstr_a(file), flags, found_element, buffer,
1866 buffer_size, found_size);
1867
1868 return E_NOTIMPL;
1869}
1870
1872 ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
1873{
1874 FIXME("%p, %s, %p, %u, %p stub.\n", iface, debugstr_a(file), buffer, buffer_lines, file_lines);
1875
1876 return E_NOTIMPL;
1877}
1878
1880 ULONG64 base, const char *item, void *buffer, ULONG buffer_size, ULONG *info_size)
1881{
1883 const struct module_info *info;
1884 struct target_process *target;
1885 void *version_info, *ptr;
1886 HRESULT hr = E_FAIL;
1887 DWORD handle, size;
1888
1889 TRACE("%p, %u, %s, %s, %p, %u, %p.\n", iface, index, wine_dbgstr_longlong(base), debugstr_a(item), buffer,
1890 buffer_size, info_size);
1891
1893 return E_UNEXPECTED;
1894
1895 if (index == DEBUG_ANY_ID)
1897 else
1899
1900 if (!info)
1901 {
1902 WARN("Was unable to locate module.\n");
1903 return E_INVALIDARG;
1904 }
1905
1906 if (!(size = GetFileVersionInfoSizeA(info->image_name, &handle)))
1907 return E_FAIL;
1908
1909 if (!(version_info = heap_alloc(size)))
1910 return E_OUTOFMEMORY;
1911
1912 if (GetFileVersionInfoA(info->image_name, handle, size, version_info))
1913 {
1914#ifdef __REACTOS__
1915 if (VerQueryValueA(version_info, item, &ptr, (PUINT) &size))
1916#else
1917 if (VerQueryValueA(version_info, item, &ptr, &size))
1918#endif
1919 {
1920 if (info_size)
1921 *info_size = size;
1922
1923 if (buffer && buffer_size)
1924 {
1925 unsigned int dst_len = min(size, buffer_size);
1926 if (dst_len)
1927 memcpy(buffer, ptr, dst_len);
1928 }
1929
1930 hr = buffer && buffer_size < size ? S_FALSE : S_OK;
1931 }
1932 }
1933
1934 heap_free(version_info);
1935
1936 return hr;
1937}
1938
1940 ULONG64 base, char *buffer, ULONG buffer_size, ULONG *name_size)
1941{
1943 const struct module_info *info;
1944 struct target_process *target;
1945 HRESULT hr;
1946
1947 TRACE("%p, %u, %u, %s, %p, %u, %p.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
1948 name_size);
1949
1951 return E_UNEXPECTED;
1952
1953 if (index == DEBUG_ANY_ID)
1955 else
1957
1958 if (!info)
1959 {
1960 WARN("Was unable to locate module.\n");
1961 return E_INVALIDARG;
1962 }
1963
1964 switch (which)
1965 {
1967#ifdef __REACTOS__
1968 hr = debug_target_return_string(info->image_name, buffer, buffer_size, (UINT *) name_size);
1969#else
1970 hr = debug_target_return_string(info->image_name, buffer, buffer_size, name_size);
1971#endif
1972 break;
1977 FIXME("Unsupported name info %d.\n", which);
1978 return E_NOTIMPL;
1979 default:
1980 WARN("Unknown name info %d.\n", which);
1981 return E_INVALIDARG;
1982 }
1983
1984 return hr;
1985}
1986
1988 ULONG64 value, char *buffer, ULONG buffer_size, ULONG *name_size)
1989{
1990 FIXME("%p, %s, %u, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
1992
1993 return E_NOTIMPL;
1994}
1995
1997 ULONG field_index, char *buffer, ULONG buffer_size, ULONG *name_size)
1998{
1999 FIXME("%p, %s, %u, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
2000 buffer_size, name_size);
2001
2002 return E_NOTIMPL;
2003}
2004
2006{
2007 FIXME("%p, %p stub.\n", iface, options);
2008
2009 return E_NOTIMPL;
2010}
2011
2013{
2014 FIXME("%p, %#x stub.\n", iface, options);
2015
2016 return E_NOTIMPL;
2017}
2018
2020{
2021 FIXME("%p, %#x stub.\n", iface, options);
2022
2023 return E_NOTIMPL;
2024}
2025
2027{
2028 FIXME("%p, %#x stub.\n", iface, options);
2029
2030 return E_NOTIMPL;
2031}
2032
2034 ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
2035{
2036 FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), buffer, buffer_size, name_size,
2037 displacement);
2038
2039 return E_NOTIMPL;
2040}
2041
2042static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByNameWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2043 ULONG64 *offset)
2044{
2045 FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), offset);
2046
2047 return E_NOTIMPL;
2048}
2049
2051 LONG delta, WCHAR *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
2052{
2053 FIXME("%p, %s, %d, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
2054 name_size, displacement);
2055
2056 return E_NOTIMPL;
2057}
2058
2060 WCHAR *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
2061{
2062 FIXME("%p, %s, %p, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), line, buffer, buffer_size,
2063 file_size, displacement);
2064
2065 return E_NOTIMPL;
2066}
2067
2069 ULONG64 *offset)
2070{
2071 FIXME("%p, %u, %s, %p stub.\n", iface, line, debugstr_w(file), offset);
2072
2073 return E_NOTIMPL;
2074}
2075
2077 ULONG start_index, ULONG *index, ULONG64 *base)
2078{
2079 FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_w(name), start_index, index, base);
2080
2081 return E_NOTIMPL;
2082}
2083
2084static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModuleWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2085 ULONG64 *base)
2086{
2087 FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), base);
2088
2089 return E_NOTIMPL;
2090}
2091
2093 WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2094{
2095 FIXME("%p, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, buffer, buffer_size,
2096 name_size);
2097
2098 return E_NOTIMPL;
2099}
2100
2102 ULONG *type_id)
2103{
2104 FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), debugstr_w(name), type_id);
2105
2106 return E_NOTIMPL;
2107}
2108
2110 const WCHAR *field, ULONG *offset)
2111{
2112 FIXME("%p, %s, %u, %s, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, debugstr_w(field), offset);
2113
2114 return E_NOTIMPL;
2115}
2116
2117static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeIdWide(IDebugSymbols3 *iface, const WCHAR *symbol,
2119{
2120 FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_w(symbol), type_id, module);
2121
2122 return E_NOTIMPL;
2123}
2124
2127{
2128 FIXME("%p, %#x, %p, %p stub.\n", iface, flags, update, symbols);
2129
2130 return E_NOTIMPL;
2131}
2132
2134{
2135 FIXME("%p, %p stub.\n", iface, group);
2136
2137 return E_NOTIMPL;
2138}
2139
2141 ULONG64 *handle)
2142{
2143 FIXME("%p, %s, %p stub.\n", iface, debugstr_w(pattern), handle);
2144
2145 return E_NOTIMPL;
2146}
2147
2149 WCHAR *buffer, ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
2150{
2151 FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
2152
2153 return E_NOTIMPL;
2154}
2155
2156static HRESULT STDMETHODCALLTYPE debugsymbols_ReloadWide(IDebugSymbols3 *iface, const WCHAR *module)
2157{
2158 FIXME("%p, %s stub.\n", iface, debugstr_w(module));
2159
2160 return E_NOTIMPL;
2161}
2162
2164 ULONG *path_size)
2165{
2166 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
2167
2168 return E_NOTIMPL;
2169}
2170
2172{
2173 FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2174
2175 return E_NOTIMPL;
2176}
2177
2178static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2179{
2180 FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2181
2182 return E_NOTIMPL;
2183}
2184
2186 ULONG *path_size)
2187{
2188 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
2189
2190 return E_NOTIMPL;
2191}
2192
2194{
2195 FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2196
2197 return E_NOTIMPL;
2198}
2199
2200static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2201{
2202 FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2203
2204 return E_NOTIMPL;
2205}
2206
2208 ULONG *path_size)
2209{
2210 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
2211
2212 return E_NOTIMPL;
2213}
2214
2216 WCHAR *buffer, ULONG buffer_size, ULONG *element_size)
2217{
2218 FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, element_size);
2219
2220 return E_NOTIMPL;
2221}
2222
2224{
2225 FIXME("%p, %s stub.\n", iface, debugstr_w(path));
2226
2227 return E_NOTIMPL;
2228}
2229
2230static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePathWide(IDebugSymbols3 *iface, const WCHAR *addition)
2231{
2232 FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
2233
2234 return E_NOTIMPL;
2235}
2236
2237static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFileWide(IDebugSymbols3 *iface, ULONG start_element,
2238 const WCHAR *file, ULONG flags, ULONG *found_element, WCHAR *buffer, ULONG buffer_size, ULONG *found_size)
2239{
2240 FIXME("%p, %u, %s, %#x, %p, %p, %u, %p stub.\n", iface, start_element, debugstr_w(file), flags, found_element,
2241 buffer, buffer_size, found_size);
2242
2243 return E_NOTIMPL;
2244}
2245
2247 ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
2248{
2249 FIXME("%p, %s, %p, %u, %p stub.\n", iface, debugstr_w(file), buffer, buffer_lines, file_lines);
2250
2251 return E_NOTIMPL;
2252}
2253
2255 ULONG64 base, const WCHAR *item, void *buffer, ULONG buffer_size, ULONG *version_info_size)
2256{
2257 FIXME("%p, %u, %s, %s, %p, %u, %p stub.\n", iface, index, wine_dbgstr_longlong(base), debugstr_w(item), buffer,
2258 buffer_size, version_info_size);
2259
2260 return E_NOTIMPL;
2261}
2262
2265{
2266 FIXME("%p, %u, %u, %s, %p, %u, %p stub.\n", iface, which, index, wine_dbgstr_longlong(base), buffer, buffer_size,
2267 name_size);
2268
2269 return E_NOTIMPL;
2270}
2271
2274{
2275 FIXME("%p, %s, %u, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id,
2277
2278 return E_NOTIMPL;
2279}
2280
2282 ULONG field_index, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
2283{
2284 FIXME("%p, %s, %u, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(module), type_id, field_index, buffer,
2285 buffer_size, name_size);
2286
2287 return E_NOTIMPL;
2288}
2289
2291{
2292 FIXME("%p, %u, %s stub.\n", iface, index, wine_dbgstr_longlong(base));
2293
2294 return E_NOTIMPL;
2295}
2296
2297static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2(IDebugSymbols3 *iface, const char *name,
2298 ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2299{
2300 FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, debugstr_a(name), start_index, flags, index, base);
2301
2302 return E_NOTIMPL;
2303}
2304
2306 ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2307{
2308 FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, debugstr_w(name), start_index, flags, index, base);
2309
2310 return E_NOTIMPL;
2311}
2312
2314 ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
2315{
2316 FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), start_index, flags, index, base);
2317
2318 return E_NOTIMPL;
2319}
2320
2322 const char *image_path, const char *module_name, ULONG flags)
2323{
2324 FIXME("%p, %s, %u, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_a(image_path),
2326
2327 return E_NOTIMPL;
2328}
2329
2331 const WCHAR *image_path, const WCHAR *module_name, ULONG flags)
2332{
2333 FIXME("%p, %s, %u, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(base), size, debugstr_w(image_path),
2335
2336 return E_NOTIMPL;
2337}
2338
2340{
2341 FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(base));
2342
2343 return E_NOTIMPL;
2344}
2345
2347{
2348 FIXME("%p, %p stub.\n", iface, index);
2349
2350 return E_NOTIMPL;
2351}
2352
2354{
2355 FIXME("%p, %u stub.\n", iface, index);
2356
2357 return E_NOTIMPL;
2358}
2359
2360static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromJitDebugInfo(IDebugSymbols3 *iface, ULONG output_control,
2361 ULONG64 info_offset)
2362{
2363 FIXME("%p, %u, %s stub.\n", iface, output_control, wine_dbgstr_longlong(info_offset));
2364
2365 return E_NOTIMPL;
2366}
2367
2369{
2370 FIXME("%p stub.\n", iface);
2371
2372 return E_NOTIMPL;
2373}
2374
2375static HRESULT STDMETHODCALLTYPE debugsymbols_OutputSymbolByOffset(IDebugSymbols3 *iface, ULONG output_control,
2377{
2378 FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, flags, wine_dbgstr_longlong(offset));
2379
2380 return E_NOTIMPL;
2381}
2382
2384 ULONG flags, void *buffer, ULONG buffer_size, ULONG *needed_size)
2385{
2386 FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
2387 needed_size);
2388
2389 return E_NOTIMPL;
2390}
2391
2393 ULONG container_type_id, const char *field, ULONG *field_type_id, ULONG *offset)
2394{
2395 FIXME("%p, %s, %u, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_a(field),
2396 field_type_id, offset);
2397
2398 return E_NOTIMPL;
2399}
2400
2402 ULONG container_type_id, const WCHAR *field, ULONG *field_type_id, ULONG *offset)
2403{
2404 FIXME("%p, %s, %u, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(module), container_type_id, debugstr_w(field),
2405 field_type_id, offset);
2406
2407 return E_NOTIMPL;
2408}
2409
2411 const char *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
2412{
2413 FIXME("%p, %s, %u, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_a(name), flags, id);
2414
2415 return E_NOTIMPL;
2416}
2417
2420{
2421 FIXME("%p, %s, %u, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(offset), size, debugstr_w(name), flags, id);
2422
2423 return E_NOTIMPL;
2424}
2425
2427{
2428 FIXME("%p, %p stub.\n", iface, id);
2429
2430 return E_NOTIMPL;
2431}
2432
2434 ULONG flags, DEBUG_MODULE_AND_ID *ids, LONG64 *displacements, ULONG count, ULONG *entries)
2435{
2436 FIXME("%p, %s, %#x, %p, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, ids, displacements, count,
2437 entries);
2438
2439 return E_NOTIMPL;
2440}
2441
2442static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByName(IDebugSymbols3 *iface, const char *symbol,
2444{
2445 FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_a(symbol), flags, ids, count, entries);
2446
2447 return E_NOTIMPL;
2448}
2449
2452{
2453 FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_w(symbol), flags, ids, count, entries);
2454
2455 return E_NOTIMPL;
2456}
2457
2460{
2461 FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), id);
2462
2463 return E_NOTIMPL;
2464}
2465
2468{
2469 FIXME("%p, %p, %p stub.\n", iface, id, info);
2470
2471 return E_NOTIMPL;
2472}
2473
2475 ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
2476{
2477 FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
2478
2479 return E_NOTIMPL;
2480}
2481
2483 ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
2484{
2485 FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, id, which, buffer, buffer_size, string_size);
2486
2487 return E_NOTIMPL;
2488}
2489
2491 ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG regions_count, ULONG *regions_avail)
2492{
2493 FIXME("%p, %p, %#x, %p, %u, %p stub.\n", iface, id, flags, regions, regions_count, regions_avail);
2494
2495 return E_NOTIMPL;
2496}
2497
2500{
2501 FIXME("%p, %p, %#x, %p stub.\n", iface, from_id, flags, to_id);
2502
2503 return E_NOTIMPL;
2504}
2505
2507 ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2508{
2509 FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, entries, count, entries_avail);
2510
2511 return E_NOTIMPL;
2512}
2513
2515 const char *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2516{
2517 FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_a(file), flags, entries, count, entries_avail);
2518
2519 return E_NOTIMPL;
2520}
2521
2523 const WCHAR *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG *entries_avail)
2524{
2525 FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_w(file), flags, entries, count, entries_avail);
2526
2527 return E_NOTIMPL;
2528}
2529
2532{
2533 FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
2534
2535 return E_NOTIMPL;
2536}
2537
2540{
2541 FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, entry, which, buffer, buffer_size, string_size);
2542
2543 return E_NOTIMPL;
2544}
2545
2548{
2549 FIXME("%p, %p, %#x, %p, %u, %p stub.\n", iface, entry, flags, regions, count, regions_avail);
2550
2551 return E_NOTIMPL;
2552}
2553
2556{
2557 FIXME("%p, %p, %#x, %p stub.\n", iface, from_entry, flags, to_entry);
2558
2559 return E_NOTIMPL;
2560}
2561
2562static const IDebugSymbols3Vtbl debugsymbolsvtbl =
2563{
2616 /* IDebugSymbols2 */
2625 /* IDebugSymbols3 */
2692};
2693
2695{
2698 return IUnknown_QueryInterface(unk, riid, obj);
2699}
2700
2701static ULONG STDMETHODCALLTYPE debugcontrol_AddRef(IDebugControl2 *iface)
2702{
2705 return IUnknown_AddRef(unk);
2706}
2707
2708static ULONG STDMETHODCALLTYPE debugcontrol_Release(IDebugControl2 *iface)
2709{
2712 return IUnknown_Release(unk);
2713}
2714
2716{
2717 FIXME("%p stub.\n", iface);
2718
2719 return E_NOTIMPL;
2720}
2721
2723{
2724 FIXME("%p, %#x stub.\n", iface, flags);
2725
2726 return E_NOTIMPL;
2727}
2728
2730{
2731 FIXME("%p, %p stub.\n", iface, timeout);
2732
2733 return E_NOTIMPL;
2734}
2735
2737{
2738 FIXME("%p, %u stub.\n", iface, timeout);
2739
2740 return E_NOTIMPL;
2741}
2742
2745{
2746 FIXME("%p, %p, %u, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
2747
2748 return E_NOTIMPL;
2749}
2750
2751static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile(IDebugControl2 *iface, const char *file, BOOL append)
2752{
2753 FIXME("%p, %s, %d stub.\n", iface, debugstr_a(file), append);
2754
2755 return E_NOTIMPL;
2756}
2758{
2759 FIXME("%p stub.\n", iface);
2760
2761 return E_NOTIMPL;
2762}
2764{
2765 FIXME("%p, %p stub.\n", iface, mask);
2766
2767 return E_NOTIMPL;
2768}
2769
2771{
2772 FIXME("%p, %#x stub.\n", iface, mask);
2773
2774 return E_NOTIMPL;
2775}
2776
2778 ULONG *input_size)
2779{
2780 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, input_size);
2781
2782 return E_NOTIMPL;
2783}
2784
2785static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInput(IDebugControl2 *iface, const char *buffer)
2786{
2787 FIXME("%p, %s stub.\n", iface, debugstr_a(buffer));
2788
2789 return E_NOTIMPL;
2790}
2791
2792static HRESULT STDMETHODVCALLTYPE debugcontrol_Output(IDebugControl2 *iface, ULONG mask, const char *format, ...)
2793{
2794 FIXME("%p, %#x, %s stub.\n", iface, mask, debugstr_a(format));
2795
2796 return E_NOTIMPL;
2797}
2798
2799static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl2 *iface, ULONG mask, const char *format,
2801{
2802 FIXME("%p, %#x, %s stub.\n", iface, mask, debugstr_a(format));
2803
2804 return E_NOTIMPL;
2805}
2806
2807static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl2 *iface, ULONG output_control,
2808 ULONG mask, const char *format, ...)
2809{
2810 FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, mask, debugstr_a(format));
2811
2812 return E_NOTIMPL;
2813}
2814
2815static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugControl2 *iface, ULONG output_control,
2816 ULONG mask, const char *format, __ms_va_list args)
2817{
2818 FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, mask, debugstr_a(format));
2819
2820 return E_NOTIMPL;
2821}
2822
2823static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl2 *iface, ULONG output_control,
2824 const char *format, ...)
2825{
2826 FIXME("%p, %u, %s stub.\n", iface, output_control, debugstr_a(format));
2827
2828 return E_NOTIMPL;
2829}
2830
2831static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl2 *iface, ULONG output_control,
2832 const char *format, __ms_va_list args)
2833{
2834 FIXME("%p, %u, %s stub.\n", iface, output_control, debugstr_a(format));
2835
2836 return E_NOTIMPL;
2837}
2838
2840 ULONG *text_size)
2841{
2842 FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, text_size);
2843
2844 return E_NOTIMPL;
2845}
2846
2847static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl2 *iface, ULONG output_control,
2848 ULONG flags)
2849{
2850 FIXME("%p, %u, %#x stub.\n", iface, output_control, flags);
2851
2852 return E_NOTIMPL;
2853}
2854
2855static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVersionInformation(IDebugControl2 *iface, ULONG output_control)
2856{
2857 FIXME("%p, %u stub.\n", iface, output_control);
2858
2859 return E_NOTIMPL;
2860}
2861
2863{
2864 FIXME("%p, %p stub.\n", iface, handle);
2865
2866 return E_NOTIMPL;
2867}
2868
2870{
2871 FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
2872
2873 return E_NOTIMPL;
2874}
2875
2876static HRESULT STDMETHODCALLTYPE debugcontrol_Assemble(IDebugControl2 *iface, ULONG64 offset, const char *code,
2877 ULONG64 *end_offset)
2878{
2879 FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), debugstr_a(code), end_offset);
2880
2881 return E_NOTIMPL;
2882}
2883
2885 char *buffer, ULONG buffer_size, ULONG *disassm_size, ULONG64 *end_offset)
2886{
2887 FIXME("%p, %s, %#x, %p, %u, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
2888 disassm_size, end_offset);
2889
2890 return E_NOTIMPL;
2891}
2892
2894{
2895 FIXME("%p, %p stub.\n", iface, offset);
2896
2897 return E_NOTIMPL;
2898}
2899
2900static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl2 *iface, ULONG output_control,
2901 ULONG64 offset, ULONG flags, ULONG64 *end_offset)
2902{
2903 FIXME("%p, %u, %s, %#x, %p stub.\n", iface, output_control, wine_dbgstr_longlong(offset), flags, end_offset);
2904
2905 return E_NOTIMPL;
2906}
2907
2908static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugControl2 *iface, ULONG output_control,
2909 ULONG prev_lines, ULONG total_lines, ULONG64 offset, ULONG flags, ULONG *offset_line, ULONG64 *start_offset,
2910 ULONG64 *end_offset, ULONG64 *line_offsets)
2911{
2912 FIXME("%p, %u, %u, %u, %s, %#x, %p, %p, %p, %p stub.\n", iface, output_control, prev_lines, total_lines,
2913 wine_dbgstr_longlong(offset), flags, offset_line, start_offset, end_offset, line_offsets);
2914
2915 return E_NOTIMPL;
2916}
2917
2919 ULONG64 *instr_offset)
2920{
2921 FIXME("%p, %s, %d, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, instr_offset);
2922
2923 return E_NOTIMPL;
2924}
2925
2927 ULONG64 stack_offset, ULONG64 instr_offset, DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG *frames_filled)
2928{
2929 FIXME("%p, %s, %s, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(frame_offset),
2930 wine_dbgstr_longlong(stack_offset), wine_dbgstr_longlong(instr_offset), frames, frames_size, frames_filled);
2931
2932 return E_NOTIMPL;
2933}
2934
2936{
2937 FIXME("%p, %p stub.\n", iface, offset);
2938
2939 return E_NOTIMPL;
2940}
2941
2942static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl2 *iface, ULONG output_control,
2943 DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG flags)
2944{
2945 FIXME("%p, %u, %p, %u, %#x stub.\n", iface, output_control, frames, frames_size, flags);
2946
2947 return E_NOTIMPL;
2948}
2949
2950static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl2 *iface, ULONG *debug_class,
2952{
2954 static struct target_process *target;
2955
2956 FIXME("%p, %p, %p stub.\n", iface, debug_class, qualifier);
2957
2958 *debug_class = DEBUG_CLASS_UNINITIALIZED;
2959 *qualifier = 0;
2960
2962 return E_UNEXPECTED;
2963
2964 *debug_class = DEBUG_CLASS_USER_WINDOWS;
2966
2967 return S_OK;
2968}
2969
2971{
2972 FIXME("%p, %p stub.\n", iface, type);
2973
2974 return E_NOTIMPL;
2975}
2976
2978{
2980 static struct target_process *target;
2981 HRESULT hr;
2982
2983 TRACE("%p, %p.\n", iface, type);
2984
2986 return E_UNEXPECTED;
2987
2989 return hr;
2990
2991 *type = target->cpu_type;
2992
2993 return S_OK;
2994}
2995
2997 ULONG *count)
2998{
2999 FIXME("%p, %p stub.\n", iface, count);
3000
3001 return E_NOTIMPL;
3002}
3003
3006{
3007 FIXME("%p, %u, %u, %p stub.\n", iface, start, count, types);
3008
3009 return E_NOTIMPL;
3010}
3011
3013{
3014 FIXME("%p, %p stub.\n", iface, count);
3015
3016 return E_NOTIMPL;
3017}
3018
3019static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersion(IDebugControl2 *iface, ULONG *platform_id, ULONG *major,
3020 ULONG *minor, char *sp_string, ULONG sp_string_size, ULONG *sp_string_used, ULONG *sp_number,
3021 char *build_string, ULONG build_string_size, ULONG *build_string_used)
3022{
3023 FIXME("%p, %p, %p, %p, %p, %u, %p, %p, %p, %u, %p stub.\n", iface, platform_id, major, minor, sp_string,
3024 sp_string_size, sp_string_used, sp_number, build_string, build_string_size, build_string_used);
3025
3026 return E_NOTIMPL;
3027}
3028
3030{
3031 FIXME("%p, %p stub.\n", iface, size);
3032
3033 return E_NOTIMPL;
3034}
3035
3037{
3039 static struct target_process *target;
3040 HRESULT hr;
3041
3042 TRACE("%p.\n", iface);
3043
3045 return E_UNEXPECTED;
3046
3048 return hr;
3049
3050 switch (target->cpu_type)
3051 {
3054 hr = S_FALSE;
3055 break;
3059 hr = S_OK;
3060 break;
3061 default:
3062 FIXME("Unexpected cpu type %#x.\n", target->cpu_type);
3063 hr = E_UNEXPECTED;
3064 }
3065
3066 return hr;
3067}
3068
3070 ULONG64 *arg2, ULONG64 *arg3, ULONG64 *arg4)
3071{
3072 FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, code, arg1, arg2, arg3, arg4);
3073
3074 return E_NOTIMPL;
3075}
3076
3078{
3079 FIXME("%p, %p stub.\n", iface, count);
3080
3081 return E_NOTIMPL;
3082}
3083
3086{
3087 FIXME("%p, %u, %u, %p stub.\n", iface, start, count, types);
3088
3089 return E_NOTIMPL;
3090}
3091
3092static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugControl2 *iface, ULONG type, char *full_name,
3093 ULONG full_name_buffer_size, ULONG *full_name_size, char *abbrev_name, ULONG abbrev_name_buffer_size,
3094 ULONG *abbrev_name_size)
3095{
3096 FIXME("%p, %u, %p, %u, %p, %p, %u, %p stub.\n", iface, type, full_name, full_name_buffer_size, full_name_size,
3097 abbrev_name, abbrev_name_buffer_size, abbrev_name_size);
3098
3099 return E_NOTIMPL;
3100}
3101
3103{
3104 FIXME("%p, %p stub.\n", iface, type);
3105
3106 return E_NOTIMPL;
3107}
3108
3110{
3111 FIXME("%p, %u stub.\n", iface, type);
3112
3113 return E_NOTIMPL;
3114}
3115
3117{
3118 FIXME("%p, %p stub.\n", iface, status);
3119
3120 return E_NOTIMPL;
3121}
3122
3124{
3125 FIXME("%p, %u stub.\n", iface, status);
3126
3127 return E_NOTIMPL;
3128}
3129
3131{
3132 FIXME("%p, %p stub.\n", iface, level);
3133
3134 return E_NOTIMPL;
3135}
3136
3138{
3139 FIXME("%p, %u stub.\n", iface, level);
3140
3141 return E_NOTIMPL;
3142}
3143
3145{
3147
3148 TRACE("%p, %p.\n", iface, options);
3149
3151
3152 return S_OK;
3153}
3154
3156{
3158
3159 TRACE("%p, %#x.\n", iface, options);
3160
3162 return E_INVALIDARG;
3163
3165
3166 return S_OK;
3167}
3168
3170{
3172
3173 TRACE("%p, %#x.\n", iface, options);
3174
3176
3177 return S_OK;
3178}
3179
3181{
3183
3184 TRACE("%p, %#x.\n", iface, options);
3185
3187 return E_INVALIDARG;
3188
3190
3191 return S_OK;
3192}
3193
3194static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugControl2 *iface, ULONG *output_level,
3195 ULONG *break_level)
3196{
3197 FIXME("%p, %p, %p stub.\n", iface, output_level, break_level);
3198
3199 return E_NOTIMPL;
3200}
3201
3202static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugControl2 *iface, ULONG output_level,
3203 ULONG break_level)
3204{
3205 FIXME("%p, %u, %u stub.\n", iface, output_level, break_level);
3206
3207 return E_NOTIMPL;
3208}
3209
3211 ULONG buffer_size, ULONG *macro_size)
3212{
3213 FIXME("%p, %u, %p, %u, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
3214
3215 return E_NOTIMPL;
3216}
3217
3218static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacro(IDebugControl2 *iface, ULONG slot, const char *macro)
3219{
3220 FIXME("%p, %u, %s stub.\n", iface, slot, debugstr_a(macro));
3221
3222 return E_NOTIMPL;
3223}
3224
3225static HRESULT STDMETHODCALLTYPE debugcontrol_GetRadix(IDebugControl2 *iface, ULONG *radix)
3226{
3227 FIXME("%p, %p stub.\n", iface, radix);
3228
3229 return E_NOTIMPL;
3230}
3231
3232static HRESULT STDMETHODCALLTYPE debugcontrol_SetRadix(IDebugControl2 *iface, ULONG radix)
3233{
3234 FIXME("%p, %u stub.\n", iface, radix);
3235
3236 return E_NOTIMPL;
3237}
3238
3239static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl2 *iface, const char *expression,
3240 ULONG desired_type, DEBUG_VALUE *value, ULONG *remainder_index)
3241{
3242 FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_a(expression), desired_type, value, remainder_index);
3243
3244 return E_NOTIMPL;
3245}
3246
3248 DEBUG_VALUE *output)
3249{
3250 FIXME("%p, %u, %p stub.\n", iface, output_type, output);
3251
3252 return E_NOTIMPL;
3253}
3254
3256 ULONG *output_types, DEBUG_VALUE *output)
3257{
3258 FIXME("%p, %u, %p, %p, %p stub.\n", iface, count, input, output_types, output);
3259
3260 return E_NOTIMPL;
3261}
3262
3263static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl2 *iface, ULONG output_control, const char *command,
3264 ULONG flags)
3265{
3266 FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(command), flags);
3267
3268 return E_NOTIMPL;
3269}
3270
3271static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl2 *iface, ULONG output_control,
3272 const char *command_file, ULONG flags)
3273{
3274 FIXME("%p, %u, %s, %#x stub.\n", iface, output_control, debugstr_a(command_file), flags);
3275
3276 return E_NOTIMPL;
3277}
3278
3280{
3281 FIXME("%p, %p stub.\n", iface, count);
3282
3283 return E_NOTIMPL;
3284}
3285
3287 IDebugBreakpoint **bp)
3288{
3289 FIXME("%p, %u, %p stub.\n", iface, index, bp);
3290
3291 return E_NOTIMPL;
3292}
3293
3294static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById(IDebugControl2 *iface, ULONG id, IDebugBreakpoint **bp)
3295{
3296 FIXME("%p, %u, %p stub.\n", iface, id, bp);
3297
3298 return E_NOTIMPL;
3299}
3300
3303{
3304 FIXME("%p, %u, %p, %u, %p stub.\n", iface, count, ids, start, parameters);
3305
3306 return E_NOTIMPL;
3307}
3308
3309static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl2 *iface, ULONG type, ULONG desired_id,
3310 IDebugBreakpoint **bp)
3311{
3312 FIXME("%p, %u, %u, %p stub.\n", iface, type, desired_id, bp);
3313
3314 return E_NOTIMPL;
3315}
3316
3317static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint(IDebugControl2 *iface, IDebugBreakpoint *bp)
3318{
3319 FIXME("%p, %p stub.\n", iface, bp);
3320
3321 return E_NOTIMPL;
3322}
3323
3324static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtension(IDebugControl2 *iface, const char *path, ULONG flags,
3325 ULONG64 *handle)
3326{
3327 FIXME("%p, %s, %#x, %p stub.\n", iface, debugstr_a(path), flags, handle);
3328
3329 return E_NOTIMPL;
3330}
3331
3333{
3334 FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
3335
3336 return E_NOTIMPL;
3337}
3338
3339static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPath(IDebugControl2 *iface, const char *path,
3340 ULONG64 *handle)
3341{
3342 FIXME("%p, %s, %p stub.\n", iface, debugstr_a(path), handle);
3343
3344 return E_NOTIMPL;
3345}
3346
3348 const char *function, const char *args)
3349{
3350 FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(function), debugstr_a(args));
3351
3352 return E_NOTIMPL;
3353}
3354
3356 const char *name, void *function)
3357{
3358 FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(name), function);
3359
3360 return E_NOTIMPL;
3361}
3362
3365{
3366 FIXME("%p, %p stub.\n", iface, api);
3367
3368 return E_NOTIMPL;
3369}
3370
3373{
3374 FIXME("%p, %p stub.\n", iface, api);
3375
3376 return E_NOTIMPL;
3377}
3378
3379static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugControl2 *iface, ULONG *specific_events,
3380 ULONG *specific_exceptions, ULONG *arbitrary_exceptions)
3381{
3382 FIXME("%p, %p, %p, %p stub.\n", iface, specific_events, specific_exceptions, arbitrary_exceptions);
3383
3384 return E_NOTIMPL;
3385}
3386
3388 ULONG buffer_size, ULONG *text_size)
3389{
3390 FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, text_size);
3391
3392 return E_NOTIMPL;
3393}
3394
3396 ULONG buffer_size, ULONG *command_size)
3397{
3398 FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3399
3400 return E_NOTIMPL;
3401}
3402
3404 const char *command)
3405{
3406 FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(command));
3407
3408 return E_NOTIMPL;
3409}
3410
3413{
3414 FIXME("%p, %u, %u, %p stub.\n", iface, start, count, parameters);
3415
3416 return E_NOTIMPL;
3417}
3418
3421{
3422 FIXME("%p, %u, %u, %p stub.\n", iface, start, count, parameters);
3423
3424 return E_NOTIMPL;
3425}
3426
3428 char *buffer, ULONG buffer_size, ULONG *argument_size)
3429{
3430 FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
3431
3432 return E_NOTIMPL;
3433}
3434
3436 const char *argument)
3437{
3438 FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(argument));
3439
3440 return E_NOTIMPL;
3441}
3442
3445{
3446 FIXME("%p, %u, %p, %u, %p stub.\n", iface, count, codes, start, parameters);
3447
3448 return E_NOTIMPL;
3449}
3450
3453{
3454 FIXME("%p, %u, %p stub.\n", iface, count, parameters);
3455
3456 return E_NOTIMPL;
3457}
3458
3460 char *buffer, ULONG buffer_size, ULONG *command_size)
3461{
3462 FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size, command_size);
3463
3464 return E_NOTIMPL;
3465}
3466
3468 const char *command)
3469{
3470 FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(command));
3471
3472 return E_NOTIMPL;
3473}
3474
3476{
3478 struct target_process *target;
3479
3480 TRACE("%p, %#x, %u.\n", iface, flags, timeout);
3481
3482 /* FIXME: only one target is used currently */
3483
3485 return E_UNEXPECTED;
3486
3487 if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
3488 {
3489 BOOL suspend = !(target->attach_flags & DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
3492
3493 if (suspend)
3495
3496 target->handle = OpenProcess(access, FALSE, target->pid);
3497 if (!target->handle)
3498 {
3499 WARN("Failed to get process handle for pid %#x.\n", target->pid);
3500 return E_UNEXPECTED;
3501 }
3502
3503 if (suspend)
3504 {
3505 status = NtSuspendProcess(target->handle);
3506 if (status)
3507 WARN("Failed to suspend a process, status %#x.\n", status);
3508 }
3509
3510 return S_OK;
3511 }
3512 else
3513 {
3514 FIXME("Unsupported attach flags %#x.\n", target->attach_flags);
3515 }
3516
3517 return E_NOTIMPL;
3518}
3519
3521 ULONG *tid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, char *description,
3522 ULONG desc_size, ULONG *desc_used)
3523{
3524 FIXME("%p, %p, %p, %p, %p, %u, %p, %p, %u, %p stub.\n", iface, type, pid, tid, extra_info, extra_info_size,
3525 extra_info_used, description, desc_size, desc_used);
3526
3527 return E_NOTIMPL;
3528}
3529
3531{
3532 FIXME("%p, %u stub.\n", iface, timedate);
3533
3534 return E_NOTIMPL;
3535}
3536
3538{
3539 FIXME("%p, %u stub.\n", iface, uptime);
3540
3541 return E_NOTIMPL;
3542}
3543
3545{
3546 FIXME("%p, %p stub.\n", iface, flags);
3547
3548 return