[PATCH 1/4] include: Add IDebugControl4 definition.

[Nikolay Sivov]

Signed-off-by: Nikolay Sivov 
---

Unreal Engine crash handler is using this.

include/dbgeng.h | 361 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 361 insertions(+)

diff --git a/include/dbgeng.h b/include/dbgeng.h
index d916d2433a3..e417704915a 100644
--- a/include/dbgeng.h
+++ b/include/dbgeng.h
@@ -44,6 +44,8 @@ DEFINE_GUID(IID_IDebugSymbols2,           0x3a707211, 0xafdd, 0x4495, 0xad, 0x4f
 DEFINE_GUID(IID_IDebugSymbols3,           0xf02fbecc, 0x50ac, 0x4f36, 0x9a, 0xd9, 0xc9, 0x75, 0xe8, 0xf3, 0x2f, 0xf8);
 DEFINE_GUID(IID_IDebugControl,            0x5182e668, 0x105e, 0x416e, 0xad, 0x92, 0x24, 0xef, 0x80, 0x04, 0x24, 0xba);
 DEFINE_GUID(IID_IDebugControl2,           0xd4366723, 0x44df, 0x4bed, 0x8c, 0x7e, 0x4c, 0x05, 0x42, 0x4f, 0x45, 0x88);
+DEFINE_GUID(IID_IDebugControl3,           0x7df74a86, 0xb03f, 0x407f, 0x90, 0xab, 0xa2, 0x0d, 0xad, 0xce, 0xad, 0x08);
+DEFINE_GUID(IID_IDebugControl4,           0x94e60ce9, 0x9b41, 0x4b19, 0x9f, 0xc0, 0x6d, 0x9e, 0xb3, 0x52, 0x72, 0xb3);
 DEFINE_GUID(IID_IDebugAdvanced,           0xf2df5f53, 0x071f, 0x47bd, 0x9d, 0xe6, 0x57, 0x34, 0xc3, 0xfe, 0xd6, 0x89);
 DEFINE_GUID(IID_IDebugSystemObjects,      0x6b86fe2c, 0x2c4f, 0x4f0c, 0x9d, 0xa2, 0x17, 0x43, 0x11, 0xac, 0xc3, 0x27);
 DEFINE_GUID(IID_IDebugSystemObjects2,     0x0ae9f5ff, 0x1852, 0x4679, 0xb0, 0x55, 0x49, 0x4b, 0xee, 0x64, 0x07, 0xee);
@@ -501,6 +503,7 @@ DECLARE_INTERFACE_(IDebugSymbolGroup2, IUnknown)
 #undef INTERFACE

typedef IDebugBreakpoint *PDEBUG_BREAKPOINT;
+typedef IDebugBreakpoint2 *PDEBUG_BREAKPOINT2;
 typedef IDebugSymbolGroup2 *PDEBUG_SYMBOL_GROUP2;

#define INTERFACE IDebugInputCallbacks
@@ -1973,6 +1976,364 @@ DECLARE_INTERFACE_(IDebugControl2, IUnknown)
 };
 #undef INTERFACE

+#define INTERFACE IDebugControl3
+DECLARE_INTERFACE_(IDebugControl3, IUnknown)
+{
+    /* IUnknown */
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+    /* IDebugControl */
+    STDMETHOD(GetInterrupt)(THIS) PURE;
+    STDMETHOD(SetInterrupt)(THIS_ ULONG flags) PURE;
+    STDMETHOD(GetInterruptTimeout)(THIS_ ULONG *timeout) PURE;
+    STDMETHOD(SetInterruptTimeout)(THIS_ ULONG timeout) PURE;
+    STDMETHOD(GetLogFile)(THIS_ char *buffer, ULONG buffer_size, ULONG *file_size, BOOL *append) PURE;
+    STDMETHOD(OpenLogFile)(THIS_ const char *file, BOOL append) PURE;
+    STDMETHOD(CloseLogFile)(THIS) PURE;
+    STDMETHOD(GetLogMask)(THIS_ ULONG *mask) PURE;
+    STDMETHOD(SetLogMask)(THIS_ ULONG mask) PURE;
+    STDMETHOD(Input)(THIS_ char *buffer, ULONG buffer_size, ULONG *input_size) PURE;
+    STDMETHOD(ReturnInput)(THIS_ const char *buffer) PURE;
+    STDMETHODV(Output)(THIS_ ULONG mask, const char *format, ...) PURE;
+    STDMETHOD(OutputVaList)(THIS_ ULONG mask, const char *format, __ms_va_list args) PURE;
+    STDMETHODV(ControlledOutput)(THIS_ ULONG output_control, ULONG mask, const char *format, ...) PURE;
+    STDMETHOD(ControlledOutputVaList)(THIS_ ULONG output_control, ULONG mask, const char *format,
+            __ms_va_list args) PURE;
+    STDMETHODV(OutputPrompt)(THIS_ ULONG output_control, const char *format, ...) PURE;
+    STDMETHOD(OutputPromptVaList)(THIS_ ULONG output_control, const char *format, __ms_va_list args) PURE;
+    STDMETHOD(GetPromptText)(THIS_ char *buffer, ULONG buffer_size, ULONG *text_size) PURE;
+    STDMETHOD(OutputCurrentState)(THIS_ ULONG output_control, ULONG flags) PURE;
+    STDMETHOD(OutputVersionInformation)(THIS_ ULONG output_control) PURE;
+    STDMETHOD(GetNotifyEventHandle)(THIS_ ULONG64 *handle) PURE;
+    STDMETHOD(SetNotifyEventHandle)(THIS_ ULONG64 handle) PURE;
+    STDMETHOD(Assemble)(THIS_ ULONG64 offset, const char *code, ULONG64 *end_offset) PURE;
+    STDMETHOD(Disassemble)(THIS_ ULONG64 offset, ULONG flags, char *buffer, ULONG buffer_size, ULONG *disassm_size,
+            ULONG64 *end_offset) PURE;
+    STDMETHOD(GetDisassembleEffectiveOffset)(THIS_ ULONG64 *offset) PURE;
+    STDMETHOD(OutputDisassembly)(THIS_ ULONG output_control, ULONG64 offset, ULONG flags, ULONG64 *end_offset) PURE;
+    STDMETHOD(OutputDisassemblyLines)(THIS_ 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) PURE;
+    STDMETHOD(GetNearInstruction)(THIS_ ULONG64 offset, LONG delta, ULONG64 *instr_offset) PURE;
+    STDMETHOD(GetStackTrace)(THIS_ ULONG64 frame_offset, ULONG64 stack_offset, ULONG64 instr_offset,
+            DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG *frames_filled) PURE;
+    STDMETHOD(GetReturnOffset)(THIS_ ULONG64 *offset) PURE;
+    STDMETHOD(OutputStackTrace)(THIS_ ULONG output_control, DEBUG_STACK_FRAME *frames, ULONG frames_size,
+            ULONG flags) PURE;
+    STDMETHOD(GetDebuggeeType)(THIS_ ULONG *_class, ULONG *qualifier) PURE;
+    STDMETHOD(GetActualProcessorType)(THIS_ ULONG *type) PURE;
+    STDMETHOD(GetExecutingProcessorType)(THIS_ ULONG *type) PURE;
+    STDMETHOD(GetNumberPossibleExecutingProcessorTypes)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetPossibleExecutingProcessorTypes)(THIS_ ULONG start, ULONG count, ULONG *types) PURE;
+    STDMETHOD(GetNumberProcessors)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetSystemVersion)(THIS_ 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) PURE;
+    STDMETHOD(GetPageSize)(THIS_ ULONG *size) PURE;
+    STDMETHOD(IsPointer64Bit)(THIS) PURE;
+    STDMETHOD(ReadBugCheckData)(THIS_ ULONG *code, ULONG64 *arg1, ULONG64 *arg2, ULONG64 *arg3, ULONG64 *arg4) PURE;
+    STDMETHOD(GetNumberSupportedProcessorTypes)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetSupportedProcessorTypes)(THIS_ ULONG start, ULONG count, ULONG *types) PURE;
+    STDMETHOD(GetProcessorTypeNames)(THIS_ 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) PURE;
+    STDMETHOD(GetEffectiveProcessorType)(THIS_ ULONG *type) PURE;
+    STDMETHOD(SetEffectiveProcessorType)(THIS_ ULONG type) PURE;
+    STDMETHOD(GetExecutionStatus)(THIS_ ULONG *status) PURE;
+    STDMETHOD(SetExecutionStatus)(THIS_ ULONG status) PURE;
+    STDMETHOD(GetCodeLevel)(THIS_ ULONG *level) PURE;
+    STDMETHOD(SetCodeLevel)(THIS_ ULONG level) PURE;
+    STDMETHOD(GetEngineOptions)(THIS_ ULONG *options) PURE;
+    STDMETHOD(AddEngineOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(RemoveEngineOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(SetEngineOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(GetSystemErrorControl)(THIS_ ULONG *output_level, ULONG *break_level) PURE;
+    STDMETHOD(SetSystemErrorControl)(THIS_ ULONG output_level, ULONG break_level) PURE;
+    STDMETHOD(GetTextMacro)(THIS_ ULONG slot, char *buffer, ULONG buffer_size, ULONG *macro_size) PURE;
+    STDMETHOD(SetTextMacro)(THIS_ ULONG slot, const char *macro) PURE;
+    STDMETHOD(GetRadix)(THIS_ ULONG *radix) PURE;
+    STDMETHOD(SetRadix)(THIS_ ULONG radix) PURE;
+    STDMETHOD(Evaluate)(THIS_ const char *expression, ULONG desired_type, DEBUG_VALUE *value,
+            ULONG *remainder_index) PURE;
+    STDMETHOD(CoerceValue)(THIS_ DEBUG_VALUE input, ULONG output_type, DEBUG_VALUE *output) PURE;
+    STDMETHOD(CoerceValues)(THIS_ ULONG count, DEBUG_VALUE *input, ULONG *output_types, DEBUG_VALUE *output) PURE;
+    STDMETHOD(Execute)(THIS_ ULONG output_control, const char *command, ULONG flags) PURE;
+    STDMETHOD(ExecuteCommandFile)(THIS_ ULONG output_control, const char *command_file, ULONG flags) PURE;
+    STDMETHOD(GetNumberBreakpoints)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetBreakpointByIndex)(THIS_ ULONG index, IDebugBreakpoint **bp) PURE;
+    STDMETHOD(GetBreakpointById)(THIS_ ULONG id, IDebugBreakpoint **bp) PURE;
+    STDMETHOD(GetBreakpointParameters)(THIS_ ULONG count, ULONG *ids, ULONG start,
+            DEBUG_BREAKPOINT_PARAMETERS *parameters) PURE;
+    STDMETHOD(AddBreakpoint)(THIS_ ULONG type, ULONG desired_id, IDebugBreakpoint **bp) PURE;
+    STDMETHOD(RemoveBreakpoint)(THIS_ IDebugBreakpoint *bp) PURE;
+    STDMETHOD(AddExtension)(THIS_ const char *path, ULONG flags, ULONG64 *handle) PURE;
+    STDMETHOD(RemoveExtension)(THIS_ ULONG64 handle) PURE;
+    STDMETHOD(GetExtensionByPath)(THIS_ const char *path, ULONG64 *handle) PURE;
+    STDMETHOD(CallExtension)(THIS_ ULONG64 handle, const char *function, const char *args) PURE;
+    STDMETHOD(GetExtensionFunction)(THIS_ ULONG64 handle, const char *name, void *function) PURE;
+    STDMETHOD(GetWindbgExtensionApis32)(THIS_ PWINDBG_EXTENSION_APIS32 api) PURE;
+    STDMETHOD(GetWindbgExtensionApis64)(THIS_ PWINDBG_EXTENSION_APIS64 api) PURE;
+    STDMETHOD(GetNumberEventFilters)(THIS_ ULONG *specific_events, ULONG *specific_exceptions,
+            ULONG *arbitrary_exceptions) PURE;
+    STDMETHOD(GetEventFilterText)(THIS_ ULONG index, char *buffer, ULONG buffer_size, ULONG *text_size) PURE;
+    STDMETHOD(GetEventFilterCommand)(THIS_ ULONG index, char *buffer, ULONG buffer_size, ULONG *command_size) PURE;
+    STDMETHOD(SetEventFilterCommand)(THIS_ ULONG index, const char *command) PURE;
+    STDMETHOD(GetSpecificFilterParameters)(THIS_ ULONG start, ULONG count,
+            DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters) PURE;
+    STDMETHOD(SetSpecificFilterParameters)(THIS_ ULONG start, ULONG count,
+            DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters) PURE;
+    STDMETHOD(GetSpecificFilterArgument)(THIS_ ULONG index, char *buffer, ULONG buffer_size,
+            ULONG *argument_size) PURE;
+    STDMETHOD(SetSpecificFilterArgument)(THIS_ ULONG index, const char *argument) PURE;
+    STDMETHOD(GetExceptionFilterParameters)(THIS_ ULONG count, ULONG *codes, ULONG start,
+            DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters) PURE;
+    STDMETHOD(SetExceptionFilterParameters)(THIS_ ULONG count, DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters) PURE;
+    STDMETHOD(GetExceptionFilterSecondCommand)(THIS_ ULONG index, char *buffer, ULONG buffer_size,
+            ULONG *command_size) PURE;
+    STDMETHOD(SetExceptionFilterSecondCommand)(THIS_ ULONG index, const char *command) PURE;
+    STDMETHOD(WaitForEvent)(THIS_ ULONG flags, ULONG timeout) PURE;
+    STDMETHOD(GetLastEventInformation)(THIS_ 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) PURE;
+    /* IDebugControl2 */
+    STDMETHOD(GetCurrentTimeDate)(THIS_ ULONG timedate) PURE;
+    STDMETHOD(GetCurrentSystemUpTime)(THIS_ ULONG uptime) PURE;
+    STDMETHOD(GetDumpFormatFlags)(THIS_ ULONG *flags) PURE;
+    STDMETHOD(GetNumberTextPlacements)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetNumberTextReplacement)(THIS_ 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) PURE;
+    STDMETHOD(SetTextReplacement)(THIS_ const char *src_text, const char *dst_text) PURE;
+    STDMETHOD(RemoveTextReplacements)(THIS) PURE;
+    STDMETHOD(OutputTextReplacements)(THIS_ ULONG output_control, ULONG flags) PURE;
+    /* IDebugControl3 */
+    STDMETHOD(GetAssemblyOptions)(THIS_ ULONG *options) PURE;
+    STDMETHOD(AddAssemblyOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(RemoveAssemblyOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(SetAssemblyOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(GetExpressionSyntax)(THIS_ ULONG *flags) PURE;
+    STDMETHOD(SetExpressionSyntax)(THIS_ ULONG flags) PURE;
+    STDMETHOD(SetExpressionSyntaxByName)(THIS_ const char *name) PURE;
+    STDMETHOD(GetNumberExpressionSyntaxes)(THIS_ ULONG *number) PURE;
+    STDMETHOD(GetExpressionSyntaxNames)(THIS_ ULONG index, char *fullname, ULONG fullname_buffer_size,
+            ULONG *fullname_size, char *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size) PURE;
+    STDMETHOD(GetNumberEvents)(THIS_ ULONG *events) PURE;
+    STDMETHOD(GetEventIndexDescription)(THIS_ ULONG index, ULONG which, char *buffer, ULONG buffer_size,
+            ULONG *desc_size) PURE;
+    STDMETHOD(GetCurrentEventIndex)(THIS_ ULONG *index) PURE;
+    STDMETHOD(SetNextEventIndex)(THIS_ ULONG relation, ULONG value, ULONG *next_index) PURE;
+};
+#undef INTERFACE
+
+#define INTERFACE IDebugControl4
+DECLARE_INTERFACE_(IDebugControl4, IUnknown)
+{
+    /* IUnknown */
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+    /* IDebugControl */
+    STDMETHOD(GetInterrupt)(THIS) PURE;
+    STDMETHOD(SetInterrupt)(THIS_ ULONG flags) PURE;
+    STDMETHOD(GetInterruptTimeout)(THIS_ ULONG *timeout) PURE;
+    STDMETHOD(SetInterruptTimeout)(THIS_ ULONG timeout) PURE;
+    STDMETHOD(GetLogFile)(THIS_ char *buffer, ULONG buffer_size, ULONG *file_size, BOOL *append) PURE;
+    STDMETHOD(OpenLogFile)(THIS_ const char *file, BOOL append) PURE;
+    STDMETHOD(CloseLogFile)(THIS) PURE;
+    STDMETHOD(GetLogMask)(THIS_ ULONG *mask) PURE;
+    STDMETHOD(SetLogMask)(THIS_ ULONG mask) PURE;
+    STDMETHOD(Input)(THIS_ char *buffer, ULONG buffer_size, ULONG *input_size) PURE;
+    STDMETHOD(ReturnInput)(THIS_ const char *buffer) PURE;
+    STDMETHODV(Output)(THIS_ ULONG mask, const char *format, ...) PURE;
+    STDMETHOD(OutputVaList)(THIS_ ULONG mask, const char *format, __ms_va_list args) PURE;
+    STDMETHODV(ControlledOutput)(THIS_ ULONG output_control, ULONG mask, const char *format, ...) PURE;
+    STDMETHOD(ControlledOutputVaList)(THIS_ ULONG output_control, ULONG mask, const char *format,
+            __ms_va_list args) PURE;
+    STDMETHODV(OutputPrompt)(THIS_ ULONG output_control, const char *format, ...) PURE;
+    STDMETHOD(OutputPromptVaList)(THIS_ ULONG output_control, const char *format, __ms_va_list args) PURE;
+    STDMETHOD(GetPromptText)(THIS_ char *buffer, ULONG buffer_size, ULONG *text_size) PURE;
+    STDMETHOD(OutputCurrentState)(THIS_ ULONG output_control, ULONG flags) PURE;
+    STDMETHOD(OutputVersionInformation)(THIS_ ULONG output_control) PURE;
+    STDMETHOD(GetNotifyEventHandle)(THIS_ ULONG64 *handle) PURE;
+    STDMETHOD(SetNotifyEventHandle)(THIS_ ULONG64 handle) PURE;
+    STDMETHOD(Assemble)(THIS_ ULONG64 offset, const char *code, ULONG64 *end_offset) PURE;
+    STDMETHOD(Disassemble)(THIS_ ULONG64 offset, ULONG flags, char *buffer, ULONG buffer_size, ULONG *disassm_size,
+            ULONG64 *end_offset) PURE;
+    STDMETHOD(GetDisassembleEffectiveOffset)(THIS_ ULONG64 *offset) PURE;
+    STDMETHOD(OutputDisassembly)(THIS_ ULONG output_control, ULONG64 offset, ULONG flags, ULONG64 *end_offset) PURE;
+    STDMETHOD(OutputDisassemblyLines)(THIS_ 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) PURE;
+    STDMETHOD(GetNearInstruction)(THIS_ ULONG64 offset, LONG delta, ULONG64 *instr_offset) PURE;
+    STDMETHOD(GetStackTrace)(THIS_ ULONG64 frame_offset, ULONG64 stack_offset, ULONG64 instr_offset,
+            DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG *frames_filled) PURE;
+    STDMETHOD(GetReturnOffset)(THIS_ ULONG64 *offset) PURE;
+    STDMETHOD(OutputStackTrace)(THIS_ ULONG output_control, DEBUG_STACK_FRAME *frames, ULONG frames_size,
+            ULONG flags) PURE;
+    STDMETHOD(GetDebuggeeType)(THIS_ ULONG *_class, ULONG *qualifier) PURE;
+    STDMETHOD(GetActualProcessorType)(THIS_ ULONG *type) PURE;
+    STDMETHOD(GetExecutingProcessorType)(THIS_ ULONG *type) PURE;
+    STDMETHOD(GetNumberPossibleExecutingProcessorTypes)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetPossibleExecutingProcessorTypes)(THIS_ ULONG start, ULONG count, ULONG *types) PURE;
+    STDMETHOD(GetNumberProcessors)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetSystemVersion)(THIS_ 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) PURE;
+    STDMETHOD(GetPageSize)(THIS_ ULONG *size) PURE;
+    STDMETHOD(IsPointer64Bit)(THIS) PURE;
+    STDMETHOD(ReadBugCheckData)(THIS_ ULONG *code, ULONG64 *arg1, ULONG64 *arg2, ULONG64 *arg3, ULONG64 *arg4) PURE;
+    STDMETHOD(GetNumberSupportedProcessorTypes)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetSupportedProcessorTypes)(THIS_ ULONG start, ULONG count, ULONG *types) PURE;
+    STDMETHOD(GetProcessorTypeNames)(THIS_ 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) PURE;
+    STDMETHOD(GetEffectiveProcessorType)(THIS_ ULONG *type) PURE;
+    STDMETHOD(SetEffectiveProcessorType)(THIS_ ULONG type) PURE;
+    STDMETHOD(GetExecutionStatus)(THIS_ ULONG *status) PURE;
+    STDMETHOD(SetExecutionStatus)(THIS_ ULONG status) PURE;
+    STDMETHOD(GetCodeLevel)(THIS_ ULONG *level) PURE;
+    STDMETHOD(SetCodeLevel)(THIS_ ULONG level) PURE;
+    STDMETHOD(GetEngineOptions)(THIS_ ULONG *options) PURE;
+    STDMETHOD(AddEngineOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(RemoveEngineOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(SetEngineOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(GetSystemErrorControl)(THIS_ ULONG *output_level, ULONG *break_level) PURE;
+    STDMETHOD(SetSystemErrorControl)(THIS_ ULONG output_level, ULONG break_level) PURE;
+    STDMETHOD(GetTextMacro)(THIS_ ULONG slot, char *buffer, ULONG buffer_size, ULONG *macro_size) PURE;
+    STDMETHOD(SetTextMacro)(THIS_ ULONG slot, const char *macro) PURE;
+    STDMETHOD(GetRadix)(THIS_ ULONG *radix) PURE;
+    STDMETHOD(SetRadix)(THIS_ ULONG radix) PURE;
+    STDMETHOD(Evaluate)(THIS_ const char *expression, ULONG desired_type, DEBUG_VALUE *value,
+            ULONG *remainder_index) PURE;
+    STDMETHOD(CoerceValue)(THIS_ DEBUG_VALUE input, ULONG output_type, DEBUG_VALUE *output) PURE;
+    STDMETHOD(CoerceValues)(THIS_ ULONG count, DEBUG_VALUE *input, ULONG *output_types, DEBUG_VALUE *output) PURE;
+    STDMETHOD(Execute)(THIS_ ULONG output_control, const char *command, ULONG flags) PURE;
+    STDMETHOD(ExecuteCommandFile)(THIS_ ULONG output_control, const char *command_file, ULONG flags) PURE;
+    STDMETHOD(GetNumberBreakpoints)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetBreakpointByIndex)(THIS_ ULONG index, IDebugBreakpoint **bp) PURE;
+    STDMETHOD(GetBreakpointById)(THIS_ ULONG id, IDebugBreakpoint **bp) PURE;
+    STDMETHOD(GetBreakpointParameters)(THIS_ ULONG count, ULONG *ids, ULONG start,
+            DEBUG_BREAKPOINT_PARAMETERS *parameters) PURE;
+    STDMETHOD(AddBreakpoint)(THIS_ ULONG type, ULONG desired_id, IDebugBreakpoint **bp) PURE;
+    STDMETHOD(RemoveBreakpoint)(THIS_ IDebugBreakpoint *bp) PURE;
+    STDMETHOD(AddExtension)(THIS_ const char *path, ULONG flags, ULONG64 *handle) PURE;
+    STDMETHOD(RemoveExtension)(THIS_ ULONG64 handle) PURE;
+    STDMETHOD(GetExtensionByPath)(THIS_ const char *path, ULONG64 *handle) PURE;
+    STDMETHOD(CallExtension)(THIS_ ULONG64 handle, const char *function, const char *args) PURE;
+    STDMETHOD(GetExtensionFunction)(THIS_ ULONG64 handle, const char *name, void *function) PURE;
+    STDMETHOD(GetWindbgExtensionApis32)(THIS_ PWINDBG_EXTENSION_APIS32 api) PURE;
+    STDMETHOD(GetWindbgExtensionApis64)(THIS_ PWINDBG_EXTENSION_APIS64 api) PURE;
+    STDMETHOD(GetNumberEventFilters)(THIS_ ULONG *specific_events, ULONG *specific_exceptions,
+            ULONG *arbitrary_exceptions) PURE;
+    STDMETHOD(GetEventFilterText)(THIS_ ULONG index, char *buffer, ULONG buffer_size, ULONG *text_size) PURE;
+    STDMETHOD(GetEventFilterCommand)(THIS_ ULONG index, char *buffer, ULONG buffer_size, ULONG *command_size) PURE;
+    STDMETHOD(SetEventFilterCommand)(THIS_ ULONG index, const char *command) PURE;
+    STDMETHOD(GetSpecificFilterParameters)(THIS_ ULONG start, ULONG count,
+            DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters) PURE;
+    STDMETHOD(SetSpecificFilterParameters)(THIS_ ULONG start, ULONG count,
+            DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters) PURE;
+    STDMETHOD(GetSpecificFilterArgument)(THIS_ ULONG index, char *buffer, ULONG buffer_size,
+            ULONG *argument_size) PURE;
+    STDMETHOD(SetSpecificFilterArgument)(THIS_ ULONG index, const char *argument) PURE;
+    STDMETHOD(GetExceptionFilterParameters)(THIS_ ULONG count, ULONG *codes, ULONG start,
+            DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters) PURE;
+    STDMETHOD(SetExceptionFilterParameters)(THIS_ ULONG count, DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters) PURE;
+    STDMETHOD(GetExceptionFilterSecondCommand)(THIS_ ULONG index, char *buffer, ULONG buffer_size,
+            ULONG *command_size) PURE;
+    STDMETHOD(SetExceptionFilterSecondCommand)(THIS_ ULONG index, const char *command) PURE;
+    STDMETHOD(WaitForEvent)(THIS_ ULONG flags, ULONG timeout) PURE;
+    STDMETHOD(GetLastEventInformation)(THIS_ 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) PURE;
+    /* IDebugControl2 */
+    STDMETHOD(GetCurrentTimeDate)(THIS_ ULONG timedate) PURE;
+    STDMETHOD(GetCurrentSystemUpTime)(THIS_ ULONG uptime) PURE;
+    STDMETHOD(GetDumpFormatFlags)(THIS_ ULONG *flags) PURE;
+    STDMETHOD(GetNumberTextPlacements)(THIS_ ULONG *count) PURE;
+    STDMETHOD(GetNumberTextReplacement)(THIS_ 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) PURE;
+    STDMETHOD(SetTextReplacement)(THIS_ const char *src_text, const char *dst_text) PURE;
+    STDMETHOD(RemoveTextReplacements)(THIS) PURE;
+    STDMETHOD(OutputTextReplacements)(THIS_ ULONG output_control, ULONG flags) PURE;
+    /* IDebugControl3 */
+    STDMETHOD(GetAssemblyOptions)(THIS_ ULONG *options) PURE;
+    STDMETHOD(AddAssemblyOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(RemoveAssemblyOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(SetAssemblyOptions)(THIS_ ULONG options) PURE;
+    STDMETHOD(GetExpressionSyntax)(THIS_ ULONG *flags) PURE;
+    STDMETHOD(SetExpressionSyntax)(THIS_ ULONG flags) PURE;
+    STDMETHOD(SetExpressionSyntaxByName)(THIS_ const char *name) PURE;
+    STDMETHOD(GetNumberExpressionSyntaxes)(THIS_ ULONG *number) PURE;
+    STDMETHOD(GetExpressionSyntaxNames)(THIS_ ULONG index, char *fullname, ULONG fullname_buffer_size,
+            ULONG *fullname_size, char *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size) PURE;
+    STDMETHOD(GetNumberEvents)(THIS_ ULONG *events) PURE;
+    STDMETHOD(GetEventIndexDescription)(THIS_ ULONG index, ULONG which, char *buffer, ULONG buffer_size,
+            ULONG *desc_size) PURE;
+    STDMETHOD(GetCurrentEventIndex)(THIS_ ULONG *index) PURE;
+    STDMETHOD(SetNextEventIndex)(THIS_ ULONG relation, ULONG value, ULONG *next_index) PURE;
+    /* IDebugControl4 */
+    STDMETHOD(GetLogFileWide)(THIS_ WCHAR *buffer, ULONG buffer_size, ULONG *file_size, BOOL *append) PURE;
+    STDMETHOD(OpenLogFileWide)(THIS_ const WCHAR *filename, BOOL append) PURE;
+    STDMETHOD(InputWide)(THIS_ WCHAR *buffer, ULONG buffer_size, ULONG *input_size) PURE;
+    STDMETHOD(ReturnInputWide)(THIS_ const WCHAR *buffer) PURE;
+    STDMETHODV(OutputWide)(THIS_ ULONG mask, const WCHAR *format, ...) PURE;
+    STDMETHOD(OutputVaListWide)(THIS_ ULONG mask, const WCHAR *format, __ms_va_list args) PURE;
+    STDMETHODV(ControlledOutputWide)(THIS_ ULONG output_control, ULONG mask, const WCHAR *format, ...) PURE;
+    STDMETHOD(ControlledOutputVaListWide)(THIS_ ULONG output_control, ULONG mask, const WCHAR *format, __ms_va_list args) PURE;
+    STDMETHODV(OutputPromptWide)(THIS_ ULONG output_control, const WCHAR *format, ...) PURE;
+    STDMETHOD(OutputPromptVaListWide)(THIS_ ULONG output_control, const WCHAR *format, __ms_va_list args) PURE;
+    STDMETHOD(GetPromptTextWide)(THIS_ WCHAR *buffer, ULONG buffer_size, ULONG *text_size) PURE;
+    STDMETHOD(AssembleWide)(THIS_ ULONG64 offset, const WCHAR *instr, ULONG64 *end_offset) PURE;
+    STDMETHOD(DisassembleWide)(THIS_ ULONG64 offset, ULONG flags, WCHAR *buffer, ULONG buffer_size, ULONG *size,
+            ULONG64 *end_offset) PURE;
+    STDMETHOD(GetProcessorTypeNamesWide)(THIS_ ULONG type, WCHAR *fullename, ULONG fullname_buffer_size,
+            ULONG *fullname_size, WCHAR *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size) PURE;
+    STDMETHOD(GetTextMacroWide)(THIS_ ULONG slot, WCHAR *buffer, ULONG buffer_size, ULONG *macro_size) PURE;
+    STDMETHOD(SetTextMacroWide)(THIS_ ULONG slot, const WCHAR *macro) PURE;
+    STDMETHOD(EvaluateWide)(THIS_ const WCHAR *expression, ULONG desired_type, DEBUG_VALUE *value, ULONG *remainder_index) PURE;
+    STDMETHOD(ExecuteWide)(THIS_ ULONG output_control, const WCHAR *command, ULONG flags) PURE;
+    STDMETHOD(ExecuteCommandFileWide)(THIS_ ULONG output_control, const WCHAR *commandfile, ULONG flags) PURE;
+    STDMETHOD(GetBreakpointByIndex2)(THIS_ ULONG index, PDEBUG_BREAKPOINT2 *bp) PURE;
+    STDMETHOD(GetBreakpointById2)(THIS_ ULONG id, PDEBUG_BREAKPOINT2 *bp) PURE;
+    STDMETHOD(AddBreakpoint2)(THIS_ ULONG type, ULONG desired_id, PDEBUG_BREAKPOINT2 *bp) PURE;
+    STDMETHOD(RemoveBreakpoint2)(THIS_ PDEBUG_BREAKPOINT2 bp) PURE;
+    STDMETHOD(AddExtensionWide)(THIS_ const WCHAR *path, ULONG flags, ULONG64 *handle) PURE;
+    STDMETHOD(GetExtensionByPathWide)(THIS_ const WCHAR *path, ULONG64 *handle) PURE;
+    STDMETHOD(CallExtensionWide)(THIS_ ULONG64 handle, const WCHAR *function, const WCHAR *arguments) PURE;
+    STDMETHOD(GetExtensionFunctionWide)(THIS_ ULONG64 handle, const WCHAR *function, FARPROC *func) PURE;
+    STDMETHOD(GetEventFilterTextWide)(THIS_ ULONG index, WCHAR *buffer, ULONG buffer_size, ULONG *text_size) PURE;
+    STDMETHOD(GetEventFilterCommandWide)(THIS_ ULONG index, WCHAR *buffer, ULONG buffer_size, ULONG *command_size) PURE;
+    STDMETHOD(SetEventFilterCommandWide)(THIS_ ULONG index, const WCHAR *command) PURE;
+    STDMETHOD(GetSpecificFilterArgumentWide)(THIS_ ULONG index, WCHAR *buffer, ULONG buffer_size, ULONG *argument_size) PURE;
+    STDMETHOD(SetSpecificFilterArgumentWide)(THIS_ ULONG index, const WCHAR *argument) PURE;
+    STDMETHOD(GetSpecificFilterSecondCommandWide)(THIS_ ULONG index, WCHAR *buffer, ULONG buffer_size, ULONG *command_size) PURE;
+    STDMETHOD(SetSpecificFilterSecondCommandWide)(THIS_ ULONG index, const WCHAR *command) PURE;
+    STDMETHOD(GetLastEventInformationWide)(THIS_ ULONG *type, ULONG *processid, ULONG *threadid, void *extra_info,
+            ULONG extra_info_size, ULONG *extra_info_used, WCHAR *desc, ULONG desc_size, ULONG *desc_used) PURE;
+    STDMETHOD(GetTextReplacementWide)(THIS_ const WCHAR *src_text, ULONG index, WCHAR *src_buffer, ULONG src_buffer_size,
+            ULONG *src_size, WCHAR *dst_buffer, ULONG dest_buffer_size, ULONG *dst_size) PURE;
+    STDMETHOD(SetTextReplacementWide)(THIS_ const WCHAR *src_text, const WCHAR *dst_text) PURE;
+    STDMETHOD(SetExpressionSyntaxByNameWide)(THIS_ const WCHAR *abbrevname) PURE;
+    STDMETHOD(GetExpressionSyntaxNamesWide)(THIS_ ULONG index, WCHAR *fullname_buffer, ULONG fullname_buffer_size,
+            ULONG *fullname_size, WCHAR *abbrevname_buffer, ULONG abbrevname_buffer_size, ULONG *abbrev_size) PURE;
+    STDMETHOD(GetEventIndexDescriptionWide)(THIS_ ULONG index, ULONG which, WCHAR *buffer, ULONG buffer_size,
+            ULONG *desc_size) PURE;
+    STDMETHOD(GetLogFile2)(THIS_ char *buffer, ULONG buffer_size, ULONG *file_size, ULONG *flags) PURE;
+    STDMETHOD(OpenLogFile2)(THIS_ const char *filename, ULONG flags) PURE;
+    STDMETHOD(GetLogFile2Wide)(THIS_ WCHAR *buffer, ULONG buffer_size, ULONG *file_size, ULONG *flags) PURE;
+    STDMETHOD(OpenLogFile2Wide)(THIS_ const WCHAR *filename, ULONG flags) PURE;
+    STDMETHOD(GetSystemVersionValues)(THIS_ ULONG *platformid, ULONG *win32major, ULONG *win32minor,
+            ULONG *kdmajor, ULONG *kdminor) PURE;
+    STDMETHOD(GetSystemVersionString)(THIS_ ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size) PURE;
+    STDMETHOD(GetSystemVersionStringWide)(THIS_ ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size) PURE;
+    STDMETHOD(GetContextStackTrace)(THIS_ void *start_context, ULONG start_context_size, PDEBUG_STACK_FRAME frames,
+            ULONG frames_size, void *frame_contexts, ULONG frame_contexts_size, ULONG frame_contexts_entry_size,
+            ULONG *frames_filled) PURE;
+    STDMETHOD(OutputContextStackTrace)(THIS_ ULONG output_control, PDEBUG_STACK_FRAME frames, ULONG frames_size,
+            void *frame_contexts, ULONG frame_contexts_size, ULONG frame_contexts_entry_size, ULONG flags) PURE;
+    STDMETHOD(GetStoredEventInformation)(THIS_ ULONG *type, ULONG *processid, ULONG *threadid, void *context,
+            ULONG context_size, ULONG *context_used, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used) PURE;
+    STDMETHOD(GetManagedStatus)(THIS_ ULONG *flags, ULONG which_string, char *string, ULONG string_size, ULONG string_needed) PURE;
+    STDMETHOD(GetManagedStatusWide)(THIS_ ULONG *flags, ULONG which_string, WCHAR *string, ULONG string_size,
+            ULONG string_needed) PURE;
+    STDMETHOD(ResetManagedStatus)(THIS_ ULONG flags) PURE;
+};
+#undef INTERFACE
+
 #define INTERFACE IDebugAdvanced
 DECLARE_INTERFACE_(IDebugAdvanced, IUnknown)
 {

[PATCH 2/4] dbgeng: Update to IDebugControl4 stub.

[Nikolay Sivov]

Signed-off-by: Nikolay Sivov 
---
 dlls/dbgeng/dbgeng.c | 828 ++++++++++++++++++++++++++++++++++++-------
 1 file changed, 707 insertions(+), 121 deletions(-)

diff --git a/dlls/dbgeng/dbgeng.c b/dlls/dbgeng/dbgeng.c
index 1439cedfeb3..e0e7c3ff98e 100644
--- a/dlls/dbgeng/dbgeng.c
+++ b/dlls/dbgeng/dbgeng.c
@@ -62,7 +62,7 @@ struct debug_client
     IDebugClient7 IDebugClient_iface;
     IDebugDataSpaces IDebugDataSpaces_iface;
     IDebugSymbols3 IDebugSymbols3_iface;
-    IDebugControl2 IDebugControl2_iface;
+    IDebugControl4 IDebugControl4_iface;
     IDebugAdvanced IDebugAdvanced_iface;
     IDebugSystemObjects IDebugSystemObjects_iface;
     LONG refcount;
@@ -252,9 +252,9 @@ 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)
+static struct debug_client *impl_from_IDebugControl4(IDebugControl4 *iface)
 {
-    return CONTAINING_RECORD(iface, struct debug_client, IDebugControl2_iface);
+    return CONTAINING_RECORD(iface, struct debug_client, IDebugControl4_iface);
 }

static struct debug_client *impl_from_IDebugAdvanced(IDebugAdvanced *iface)
@@ -294,10 +294,12 @@ static HRESULT STDMETHODCALLTYPE debugclient_QueryInterface(IDebugClient7 *iface
     {
         *obj = &debug_client->IDebugSymbols3_iface;
     }
-    else if (IsEqualIID(riid, &IID_IDebugControl2)
+    else if (IsEqualIID(riid, &IID_IDebugControl4)
+            || IsEqualIID(riid, &IID_IDebugControl3)
+            || IsEqualIID(riid, &IID_IDebugControl2)
             || IsEqualIID(riid, &IID_IDebugControl))
     {
-        *obj = &debug_client->IDebugControl2_iface;
+        *obj = &debug_client->IDebugControl4_iface;
     }
     else if (IsEqualIID(riid, &IID_IDebugAdvanced))
     {
@@ -2676,56 +2678,56 @@ static const IDebugSymbols3Vtbl debugsymbolsvtbl =
     debugsymbols_GetSourceEntryBySourceEntry,
 };

-static HRESULT STDMETHODCALLTYPE debugcontrol_QueryInterface(IDebugControl2 *iface, REFIID riid, void **obj)
+static HRESULT STDMETHODCALLTYPE debugcontrol_QueryInterface(IDebugControl4 *iface, REFIID riid, void **obj)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);
     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
     return IUnknown_QueryInterface(unk, riid, obj);
 }

-static ULONG STDMETHODCALLTYPE debugcontrol_AddRef(IDebugControl2 *iface)
+static ULONG STDMETHODCALLTYPE debugcontrol_AddRef(IDebugControl4 *iface)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);
     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
     return IUnknown_AddRef(unk);
 }

-static ULONG STDMETHODCALLTYPE debugcontrol_Release(IDebugControl2 *iface)
+static ULONG STDMETHODCALLTYPE debugcontrol_Release(IDebugControl4 *iface)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);
     IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
     return IUnknown_Release(unk);
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterrupt(IDebugControl2 *iface)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterrupt(IDebugControl4 *iface)
 {
     FIXME("%p stub.\n", iface);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterrupt(IDebugControl2 *iface, ULONG flags)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterrupt(IDebugControl4 *iface, ULONG flags)
 {
     FIXME("%p, %#lx stub.\n", iface, flags);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterruptTimeout(IDebugControl2 *iface, ULONG *timeout)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterruptTimeout(IDebugControl4 *iface, ULONG *timeout)
 {
     FIXME("%p, %p stub.\n", iface, timeout);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterruptTimeout(IDebugControl2 *iface, ULONG timeout)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterruptTimeout(IDebugControl4 *iface, ULONG timeout)
 {
     FIXME("%p, %lu stub.\n", iface, timeout);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
         ULONG *file_size, BOOL *append)
 {
     FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
@@ -2733,33 +2735,33 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile(IDebugControl2 *iface,
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile(IDebugControl2 *iface, const char *file, BOOL append)
+static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile(IDebugControl4 *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)
+static HRESULT STDMETHODCALLTYPE debugcontrol_CloseLogFile(IDebugControl4 *iface)
 {
     FIXME("%p stub.\n", iface);

return E_NOTIMPL;
 }
-static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogMask(IDebugControl2 *iface, ULONG *mask)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogMask(IDebugControl4 *iface, ULONG *mask)
 {
     FIXME("%p, %p stub.\n", iface, mask);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetLogMask(IDebugControl2 *iface, ULONG mask)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetLogMask(IDebugControl4 *iface, ULONG mask)
 {
     FIXME("%p, %#lx stub.\n", iface, mask);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_Input(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
+static HRESULT STDMETHODCALLTYPE debugcontrol_Input(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
         ULONG *input_size)
 {
     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, input_size);
@@ -2767,21 +2769,21 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_Input(IDebugControl2 *iface, char
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInput(IDebugControl2 *iface, const char *buffer)
+static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInput(IDebugControl4 *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, ...)
+static HRESULT STDMETHODVCALLTYPE debugcontrol_Output(IDebugControl4 *iface, ULONG mask, const char *format, ...)
 {
     FIXME("%p, %#lx, %s stub.\n", iface, mask, debugstr_a(format));

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl2 *iface, ULONG mask, const char *format,
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl4 *iface, ULONG mask, const char *format,
         va_list args)
 {
     FIXME("%p, %#lx, %s stub.\n", iface, mask, debugstr_a(format));
@@ -2789,7 +2791,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl2 *iface
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl4 *iface, ULONG output_control,
         ULONG mask, const char *format, ...)
 {
     FIXME("%p, %lu, %#lx, %s stub.\n", iface, output_control, mask, debugstr_a(format));
@@ -2797,7 +2799,7 @@ static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl2 *
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugControl4 *iface, ULONG output_control,
         ULONG mask, const char *format, va_list args)
 {
     FIXME("%p, %lu, %#lx, %s stub.\n", iface, output_control, mask, debugstr_a(format));
@@ -2805,7 +2807,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugContr
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl4 *iface, ULONG output_control,
         const char *format, ...)
 {
     FIXME("%p, %lu, %s stub.\n", iface, output_control, debugstr_a(format));
@@ -2813,7 +2815,7 @@ static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl2 *ifac
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl4 *iface, ULONG output_control,
         const char *format, va_list args)
 {
     FIXME("%p, %lu, %s stub.\n", iface, output_control, debugstr_a(format));
@@ -2821,7 +2823,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl2
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptText(IDebugControl2 *iface, char *buffer, ULONG buffer_size,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptText(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
         ULONG *text_size)
 {
     FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, text_size);
@@ -2829,7 +2831,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptText(IDebugControl2 *ifac
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl4 *iface, ULONG output_control,
         ULONG flags)
 {
     FIXME("%p, %lu, %#lx stub.\n", iface, output_control, flags);
@@ -2837,28 +2839,28 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl2
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVersionInformation(IDebugControl2 *iface, ULONG output_control)
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVersionInformation(IDebugControl4 *iface, ULONG output_control)
 {
     FIXME("%p, %lu stub.\n", iface, output_control);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNotifyEventHandle(IDebugControl2 *iface, ULONG64 *handle)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNotifyEventHandle(IDebugControl4 *iface, ULONG64 *handle)
 {
     FIXME("%p, %p stub.\n", iface, handle);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetNotifyEventHandle(IDebugControl2 *iface, ULONG64 handle)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetNotifyEventHandle(IDebugControl4 *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,
+static HRESULT STDMETHODCALLTYPE debugcontrol_Assemble(IDebugControl4 *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);
@@ -2866,7 +2868,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_Assemble(IDebugControl2 *iface, UL
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_Disassemble(IDebugControl2 *iface, ULONG64 offset, ULONG flags,
+static HRESULT STDMETHODCALLTYPE debugcontrol_Disassemble(IDebugControl4 *iface, ULONG64 offset, ULONG flags,
         char *buffer, ULONG buffer_size, ULONG *disassm_size, ULONG64 *end_offset)
 {
     FIXME("%p, %s, %#lx, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
@@ -2875,14 +2877,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_Disassemble(IDebugControl2 *iface,
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetDisassembleEffectiveOffset(IDebugControl2 *iface, ULONG64 *offset)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetDisassembleEffectiveOffset(IDebugControl4 *iface, ULONG64 *offset)
 {
     FIXME("%p, %p stub.\n", iface, offset);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl4 *iface, ULONG output_control,
         ULONG64 offset, ULONG flags, ULONG64 *end_offset)
 {
     FIXME("%p, %lu, %s, %#lx, %p stub.\n", iface, output_control, wine_dbgstr_longlong(offset), flags, end_offset);
@@ -2890,7 +2892,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl2 *
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugControl4 *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)
 {
@@ -2900,7 +2902,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugContr
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNearInstruction(IDebugControl2 *iface, ULONG64 offset, LONG delta,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNearInstruction(IDebugControl4 *iface, ULONG64 offset, LONG delta,
         ULONG64 *instr_offset)
 {
     FIXME("%p, %s, %ld, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta, instr_offset);
@@ -2908,7 +2910,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetNearInstruction(IDebugControl2
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetStackTrace(IDebugControl2 *iface, ULONG64 frame_offset,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetStackTrace(IDebugControl4 *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, %lu, %p stub.\n", iface, wine_dbgstr_longlong(frame_offset),
@@ -2917,14 +2919,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetStackTrace(IDebugControl2 *ifac
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetReturnOffset(IDebugControl2 *iface, ULONG64 *offset)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetReturnOffset(IDebugControl4 *iface, ULONG64 *offset)
 {
     FIXME("%p, %p stub.\n", iface, offset);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl4 *iface, ULONG output_control,
         DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG flags)
 {
     FIXME("%p, %lu, %p, %lu, %#lx stub.\n", iface, output_control, frames, frames_size, flags);
@@ -2932,10 +2934,10 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl2 *i
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl2 *iface, ULONG *debug_class,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl4 *iface, ULONG *debug_class,
         ULONG *qualifier)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);
     static struct target_process *target;

FIXME("%p, %p, %p stub.\n", iface, debug_class, qualifier);
@@ -2952,16 +2954,16 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl2 *if
     return S_OK;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetActualProcessorType(IDebugControl2 *iface, ULONG *type)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetActualProcessorType(IDebugControl4 *iface, ULONG *type)
 {
     FIXME("%p, %p stub.\n", iface, type);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutingProcessorType(IDebugControl2 *iface, ULONG *type)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutingProcessorType(IDebugControl4 *iface, ULONG *type)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);
     static struct target_process *target;
     HRESULT hr;

@@ -2978,7 +2980,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutingProcessorType(IDebugCo
     return S_OK;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberPossibleExecutingProcessorTypes(IDebugControl2 *iface,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberPossibleExecutingProcessorTypes(IDebugControl4 *iface,
         ULONG *count)
 {
     FIXME("%p, %p stub.\n", iface, count);
@@ -2986,7 +2988,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberPossibleExecutingProcesso
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetPossibleExecutingProcessorTypes(IDebugControl2 *iface, ULONG start,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetPossibleExecutingProcessorTypes(IDebugControl4 *iface, ULONG start,
         ULONG count, ULONG *types)
 {
     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, types);
@@ -2994,14 +2996,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetPossibleExecutingProcessorTypes
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberProcessors(IDebugControl2 *iface, ULONG *count)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberProcessors(IDebugControl4 *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,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersion(IDebugControl4 *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)
 {
@@ -3011,16 +3013,16 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersion(IDebugControl2 *i
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetPageSize(IDebugControl2 *iface, ULONG *size)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetPageSize(IDebugControl4 *iface, ULONG *size)
 {
     FIXME("%p, %p stub.\n", iface, size);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_IsPointer64Bit(IDebugControl2 *iface)
+static HRESULT STDMETHODCALLTYPE debugcontrol_IsPointer64Bit(IDebugControl4 *iface)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);
     static struct target_process *target;
     HRESULT hr;

@@ -3051,7 +3053,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_IsPointer64Bit(IDebugControl2 *ifa
     return hr;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_ReadBugCheckData(IDebugControl2 *iface, ULONG *code, ULONG64 *arg1,
+static HRESULT STDMETHODCALLTYPE debugcontrol_ReadBugCheckData(IDebugControl4 *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);
@@ -3059,14 +3061,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_ReadBugCheckData(IDebugControl2 *i
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberSupportedProcessorTypes(IDebugControl2 *iface, ULONG *count)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberSupportedProcessorTypes(IDebugControl4 *iface, ULONG *count)
 {
     FIXME("%p, %p stub.\n", iface, count);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetSupportedProcessorTypes(IDebugControl2 *iface, ULONG start,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSupportedProcessorTypes(IDebugControl4 *iface, ULONG start,
         ULONG count, ULONG *types)
 {
     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, types);
@@ -3074,7 +3076,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetSupportedProcessorTypes(IDebugC
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugControl2 *iface, ULONG type, char *full_name,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugControl4 *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)
 {
@@ -3084,51 +3086,51 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugContro
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetEffectiveProcessorType(IDebugControl2 *iface, ULONG *type)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEffectiveProcessorType(IDebugControl4 *iface, ULONG *type)
 {
     FIXME("%p, %p stub.\n", iface, type);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetEffectiveProcessorType(IDebugControl2 *iface, ULONG type)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetEffectiveProcessorType(IDebugControl4 *iface, ULONG type)
 {
     FIXME("%p, %lu stub.\n", iface, type);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutionStatus(IDebugControl2 *iface, ULONG *status)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutionStatus(IDebugControl4 *iface, ULONG *status)
 {
     FIXME("%p, %p stub.\n", iface, status);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetExecutionStatus(IDebugControl2 *iface, ULONG status)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetExecutionStatus(IDebugControl4 *iface, ULONG status)
 {
     FIXME("%p, %lu stub.\n", iface, status);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetCodeLevel(IDebugControl2 *iface, ULONG *level)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetCodeLevel(IDebugControl4 *iface, ULONG *level)
 {
     FIXME("%p, %p stub.\n", iface, level);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetCodeLevel(IDebugControl2 *iface, ULONG level)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetCodeLevel(IDebugControl4 *iface, ULONG level)
 {
     FIXME("%p, %lu stub.\n", iface, level);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetEngineOptions(IDebugControl2 *iface, ULONG *options)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEngineOptions(IDebugControl4 *iface, ULONG *options)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);

TRACE("%p, %p.\n", iface, options);

@@ -3137,9 +3139,9 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetEngineOptions(IDebugControl2 *i
     return S_OK;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_AddEngineOptions(IDebugControl2 *iface, ULONG options)
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddEngineOptions(IDebugControl4 *iface, ULONG options)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);

TRACE("%p, %#lx.\n", iface, options);

@@ -3151,9 +3153,9 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_AddEngineOptions(IDebugControl2 *i
     return S_OK;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveEngineOptions(IDebugControl2 *iface, ULONG options)
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveEngineOptions(IDebugControl4 *iface, ULONG options)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);

TRACE("%p, %#lx.\n", iface, options);

@@ -3162,9 +3164,9 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveEngineOptions(IDebugControl2
     return S_OK;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetEngineOptions(IDebugControl2 *iface, ULONG options)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetEngineOptions(IDebugControl4 *iface, ULONG options)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);

TRACE("%p, %#lx.\n", iface, options);

@@ -3176,7 +3178,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_SetEngineOptions(IDebugControl2 *i
     return S_OK;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugControl2 *iface, ULONG *output_level,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugControl4 *iface, ULONG *output_level,
         ULONG *break_level)
 {
     FIXME("%p, %p, %p stub.\n", iface, output_level, break_level);
@@ -3184,7 +3186,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugContro
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugControl2 *iface, ULONG output_level,
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugControl4 *iface, ULONG output_level,
         ULONG break_level)
 {
     FIXME("%p, %lu, %lu stub.\n", iface, output_level, break_level);
@@ -3192,7 +3194,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugContro
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacro(IDebugControl2 *iface, ULONG slot, char *buffer,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacro(IDebugControl4 *iface, ULONG slot, char *buffer,
         ULONG buffer_size, ULONG *macro_size)
 {
     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
@@ -3200,28 +3202,28 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacro(IDebugControl2 *iface
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacro(IDebugControl2 *iface, ULONG slot, const char *macro)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacro(IDebugControl4 *iface, ULONG slot, const char *macro)
 {
     FIXME("%p, %lu, %s stub.\n", iface, slot, debugstr_a(macro));

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetRadix(IDebugControl2 *iface, ULONG *radix)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetRadix(IDebugControl4 *iface, ULONG *radix)
 {
     FIXME("%p, %p stub.\n", iface, radix);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetRadix(IDebugControl2 *iface, ULONG radix)
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetRadix(IDebugControl4 *iface, ULONG radix)
 {
     FIXME("%p, %lu stub.\n", iface, radix);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl2 *iface, const char *expression,
+static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl4 *iface, const char *expression,
         ULONG desired_type, DEBUG_VALUE *value, ULONG *remainder_index)
 {
     FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_a(expression), desired_type, value, remainder_index);
@@ -3229,7 +3231,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl2 *iface, co
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValue(IDebugControl2 *iface, DEBUG_VALUE input, ULONG output_type,
+static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValue(IDebugControl4 *iface, DEBUG_VALUE input, ULONG output_type,
         DEBUG_VALUE *output)
 {
     FIXME("%p, %lu, %p stub.\n", iface, output_type, output);
@@ -3237,7 +3239,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValue(IDebugControl2 *iface,
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValues(IDebugControl2 *iface, ULONG count, DEBUG_VALUE *input,
+static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValues(IDebugControl4 *iface, ULONG count, DEBUG_VALUE *input,
         ULONG *output_types, DEBUG_VALUE *output)
 {
     FIXME("%p, %lu, %p, %p, %p stub.\n", iface, count, input, output_types, output);
@@ -3245,7 +3247,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValues(IDebugControl2 *iface
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl2 *iface, ULONG output_control, const char *command,
+static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl4 *iface, ULONG output_control, const char *command,
         ULONG flags)
 {
     FIXME("%p, %lu, %s, %#lx stub.\n", iface, output_control, debugstr_a(command), flags);
@@ -3253,7 +3255,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl2 *iface, ULO
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl4 *iface, ULONG output_control,
         const char *command_file, ULONG flags)
 {
     FIXME("%p, %lu, %s, %#lx stub.\n", iface, output_control, debugstr_a(command_file), flags);
@@ -3261,14 +3263,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl2
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberBreakpoints(IDebugControl2 *iface, ULONG *count)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberBreakpoints(IDebugControl4 *iface, ULONG *count)
 {
     FIXME("%p, %p stub.\n", iface, count);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex(IDebugControl2 *iface, ULONG index,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex(IDebugControl4 *iface, ULONG index,
         IDebugBreakpoint **bp)
 {
     FIXME("%p, %lu, %p stub.\n", iface, index, bp);
@@ -3276,14 +3278,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex(IDebugControl
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById(IDebugControl2 *iface, ULONG id, IDebugBreakpoint **bp)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById(IDebugControl4 *iface, ULONG id, IDebugBreakpoint **bp)
 {
     FIXME("%p, %lu, %p stub.\n", iface, id, bp);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointParameters(IDebugControl2 *iface, ULONG count, ULONG *ids,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointParameters(IDebugControl4 *iface, ULONG count, ULONG *ids,
         ULONG start, DEBUG_BREAKPOINT_PARAMETERS *parameters)
 {
     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, count, ids, start, parameters);
@@ -3291,7 +3293,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointParameters(IDebugCont
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl2 *iface, ULONG type, ULONG desired_id,
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl4 *iface, ULONG type, ULONG desired_id,
         IDebugBreakpoint **bp)
 {
     FIXME("%p, %lu, %lu, %p stub.\n", iface, type, desired_id, bp);
@@ -3299,14 +3301,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl2 *ifac
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint(IDebugControl2 *iface, IDebugBreakpoint *bp)
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint(IDebugControl4 *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,
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtension(IDebugControl4 *iface, const char *path, ULONG flags,
         ULONG64 *handle)
 {
     FIXME("%p, %s, %#lx, %p stub.\n", iface, debugstr_a(path), flags, handle);
@@ -3314,14 +3316,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtension(IDebugControl2 *iface
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveExtension(IDebugControl2 *iface, ULONG64 handle)
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveExtension(IDebugControl4 *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,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPath(IDebugControl4 *iface, const char *path,
         ULONG64 *handle)
 {
     FIXME("%p, %s, %p stub.\n", iface, debugstr_a(path), handle);
@@ -3329,7 +3331,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPath(IDebugControl2
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtension(IDebugControl2 *iface, ULONG64 handle,
+static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtension(IDebugControl4 *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));
@@ -3337,7 +3339,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtension(IDebugControl2 *ifac
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunction(IDebugControl2 *iface, ULONG64 handle,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunction(IDebugControl4 *iface, ULONG64 handle,
         const char *name, void *function)
 {
     FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_a(name), function);
@@ -3345,7 +3347,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunction(IDebugControl
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis32(IDebugControl2 *iface,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis32(IDebugControl4 *iface,
         PWINDBG_EXTENSION_APIS32 api)
 {
     FIXME("%p, %p stub.\n", iface, api);
@@ -3353,7 +3355,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis32(IDebugCon
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis64(IDebugControl2 *iface,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis64(IDebugControl4 *iface,
         PWINDBG_EXTENSION_APIS64 api)
 {
     FIXME("%p, %p stub.\n", iface, api);
@@ -3361,7 +3363,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis64(IDebugCon
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugControl2 *iface, ULONG *specific_events,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugControl4 *iface, ULONG *specific_events,
         ULONG *specific_exceptions, ULONG *arbitrary_exceptions)
 {
     FIXME("%p, %p, %p, %p stub.\n", iface, specific_events, specific_exceptions, arbitrary_exceptions);
@@ -3369,7 +3371,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugContro
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterText(IDebugControl2 *iface, ULONG index, char *buffer,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterText(IDebugControl4 *iface, ULONG index, char *buffer,
         ULONG buffer_size, ULONG *text_size)
 {
     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, text_size);
@@ -3377,7 +3379,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterText(IDebugControl2
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommand(IDebugControl2 *iface, ULONG index, char *buffer,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommand(IDebugControl4 *iface, ULONG index, char *buffer,
         ULONG buffer_size, ULONG *command_size)
 {
     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
@@ -3385,7 +3387,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommand(IDebugContro
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommand(IDebugControl2 *iface, ULONG index,
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommand(IDebugControl4 *iface, ULONG index,
         const char *command)
 {
     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(command));
@@ -3393,7 +3395,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommand(IDebugContro
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterParameters(IDebugControl2 *iface, ULONG start,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterParameters(IDebugControl4 *iface, ULONG start,
         ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
 {
     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, parameters);
@@ -3401,7 +3403,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterParameters(IDebug
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterParameters(IDebugControl2 *iface, ULONG start,
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterParameters(IDebugControl4 *iface, ULONG start,
         ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
 {
     FIXME("%p, %lu, %lu, %p stub.\n", iface, start, count, parameters);
@@ -3409,7 +3411,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterParameters(IDebug
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgument(IDebugControl2 *iface, ULONG index,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgument(IDebugControl4 *iface, ULONG index,
         char *buffer, ULONG buffer_size, ULONG *argument_size)
 {
     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
@@ -3417,7 +3419,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgument(IDebugCo
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgument(IDebugControl2 *iface, ULONG index,
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgument(IDebugControl4 *iface, ULONG index,
         const char *argument)
 {
     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(argument));
@@ -3425,7 +3427,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgument(IDebugCo
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterParameters(IDebugControl2 *iface, ULONG count,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterParameters(IDebugControl4 *iface, ULONG count,
         ULONG *codes, ULONG start, DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
 {
     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, count, codes, start, parameters);
@@ -3433,7 +3435,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterParameters(IDebu
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterParameters(IDebugControl2 *iface, ULONG count,
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterParameters(IDebugControl4 *iface, ULONG count,
         DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
 {
     FIXME("%p, %lu, %p stub.\n", iface, count, parameters);
@@ -3441,7 +3443,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterParameters(IDebu
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterSecondCommand(IDebugControl2 *iface, ULONG index,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterSecondCommand(IDebugControl4 *iface, ULONG index,
         char *buffer, ULONG buffer_size, ULONG *command_size)
 {
     FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
@@ -3449,7 +3451,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterSecondCommand(ID
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterSecondCommand(IDebugControl2 *iface, ULONG index,
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterSecondCommand(IDebugControl4 *iface, ULONG index,
         const char *command)
 {
     FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_a(command));
@@ -3457,9 +3459,9 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterSecondCommand(ID
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_WaitForEvent(IDebugControl2 *iface, ULONG flags, ULONG timeout)
+static HRESULT STDMETHODCALLTYPE debugcontrol_WaitForEvent(IDebugControl4 *iface, ULONG flags, ULONG timeout)
 {
-    struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+    struct debug_client *debug_client = impl_from_IDebugControl4(iface);
     struct target_process *target;

TRACE("%p, %#lx, %lu.\n", iface, flags, timeout);
@@ -3502,7 +3504,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_WaitForEvent(IDebugControl2 *iface
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformation(IDebugControl2 *iface, ULONG *type, ULONG *pid,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformation(IDebugControl4 *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)
 {
@@ -3512,35 +3514,35 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformation(IDebugCont
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentTimeDate(IDebugControl2 *iface, ULONG timedate)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentTimeDate(IDebugControl4 *iface, ULONG timedate)
 {
     FIXME("%p, %lu stub.\n", iface, timedate);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentSystemUpTime(IDebugControl2 *iface, ULONG uptime)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentSystemUpTime(IDebugControl4 *iface, ULONG uptime)
 {
     FIXME("%p, %lu stub.\n", iface, uptime);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetDumpFormatFlags(IDebugControl2 *iface, ULONG *flags)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetDumpFormatFlags(IDebugControl4 *iface, ULONG *flags)
 {
     FIXME("%p, %p stub.\n", iface, flags);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextPlacements(IDebugControl2 *iface, ULONG *count)
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextPlacements(IDebugControl4 *iface, ULONG *count)
 {
     FIXME("%p, %p stub.\n", iface, count);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextReplacement(IDebugControl2 *iface, const char *src_text,
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextReplacement(IDebugControl4 *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)
 {
@@ -3550,7 +3552,7 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextReplacement(IDebugCon
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacement(IDebugControl2 *iface, const char *src_text,
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacement(IDebugControl4 *iface, const char *src_text,
         const char *dst_text)
 {
     FIXME("%p, %s, %s stub.\n", iface, debugstr_a(src_text), debugstr_a(dst_text));
@@ -3558,14 +3560,14 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacement(IDebugControl2
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveTextReplacements(IDebugControl2 *iface)
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveTextReplacements(IDebugControl4 *iface)
 {
     FIXME("%p stub.\n", iface);

return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugcontrol_OutputTextReplacements(IDebugControl2 *iface, ULONG output_control,
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputTextReplacements(IDebugControl4 *iface, ULONG output_control,
         ULONG flags)
 {
     FIXME("%p, %lu, %#lx stub.\n", iface, output_control, flags);
@@ -3573,7 +3575,525 @@ static HRESULT STDMETHODCALLTYPE debugcontrol_OutputTextReplacements(IDebugContr
     return E_NOTIMPL;
 }

-static const IDebugControl2Vtbl debugcontrolvtbl =
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetAssemblyOptions(IDebugControl4 *iface, ULONG *options)
+{
+    FIXME("%p, %p stub.\n", iface, options);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddAssemblyOptions(IDebugControl4 *iface, ULONG options)
+{
+    FIXME("%p, %#lx stub.\n", iface, options);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveAssemblyOptions(IDebugControl4 *iface, ULONG options)
+{
+    FIXME("%p, %#lx stub.\n", iface, options);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetAssemblyOptions(IDebugControl4 *iface, ULONG options)
+{
+    FIXME("%p, %#lx stub.\n", iface, options);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntax(IDebugControl4 *iface, ULONG *flags)
+{
+    FIXME("%p, %p stub.\n", iface, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntax(IDebugControl4 *iface, ULONG flags)
+{
+    FIXME("%p, %#lx stub.\n", iface, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntaxByName(IDebugControl4 *iface, const char *name)
+{
+    FIXME("%p, %s stub.\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberExpressionSyntaxes(IDebugControl4 *iface, ULONG *number)
+{
+    FIXME("%p, %p stub.\n", iface, number);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntaxNames(IDebugControl4 *iface, ULONG index, char *fullname,
+        ULONG fullname_buffer_size, ULONG *fullname_size, char *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, index, fullname, fullname_buffer_size, fullname_size, abbrevname,
+            abbrevname_buffer_size, abbrevname_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEvents(IDebugControl4 *iface, ULONG *events)
+{
+    FIXME("%p, %p stub.\n", iface, events);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventIndexDescription(IDebugControl4 *iface, ULONG index, ULONG which,
+        char *buffer, ULONG buffer_size, ULONG *desc_size)
+{
+    FIXME("%p, %lu, %lu, %p, %lu, %p stub.\n", iface, index, which, buffer, buffer_size, desc_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentEventIndex(IDebugControl4 *iface, ULONG *index)
+{
+    FIXME("%p, %p stub.\n", iface, index);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetNextEventIndex(IDebugControl4 *iface, ULONG relation, ULONG value,
+        ULONG *next_index)
+{
+    FIXME("%p, %lu, %lu, %p stub.\n", iface, relation, value, next_index);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFileWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
+        ULONG *file_size, BOOL *append)
+{
+    FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, append);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFileWide(IDebugControl4 *iface, const WCHAR *filename, BOOL append)
+{
+    FIXME("%p, %s, %d stub.\n", iface, debugstr_w(filename), append);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_InputWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
+       ULONG *input_size)
+{
+    FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, input_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInputWide(IDebugControl4 *iface, const WCHAR *buffer)
+{
+    FIXME("%p, %p stub.\n", iface, buffer);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputWide(IDebugControl4 *iface, ULONG mask, const WCHAR *format, ...)
+{
+    FIXME("%p, %lx, %s stub.\n", iface, mask, debugstr_w(format));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaListWide(IDebugControl4 *iface, ULONG mask, const WCHAR *format,
+        va_list args)
+{
+    FIXME("%p, %lx, %s stub.\n", iface, mask, debugstr_w(format));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutputWide(IDebugControl4 *iface, ULONG output_control, ULONG mask,
+        const WCHAR *format, ...)
+{
+    FIXME("%p, %lx, %lx, %s stub.\n", iface, output_control, mask, debugstr_w(format));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaListWide(IDebugControl4 *iface, ULONG output_control,
+        ULONG mask, const WCHAR *format, va_list args)
+{
+    FIXME("%p, %lx, %lx, %s stub.\n", iface, output_control, mask, debugstr_w(format));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPromptWide(IDebugControl4 *iface, ULONG output_control,
+        const WCHAR *format, ...)
+{
+    FIXME("%p, %lx, %s stub.\n", iface, output_control, debugstr_w(format));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaListWide(IDebugControl4 *iface, ULONG output_control,
+        const WCHAR *format, va_list args)
+{
+    FIXME("%p, %lx, %s stub.\n", iface, output_control, debugstr_w(format));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptTextWide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
+        ULONG *text_size)
+{
+    FIXME("%p, %p, %lu, %p stub.\n", iface, buffer, buffer_size, text_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_AssembleWide(IDebugControl4 *iface, ULONG64 offset, const WCHAR *instr,
+        ULONG64 *end_offset)
+{
+    FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), debugstr_w(instr), end_offset);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_DisassembleWide(IDebugControl4 *iface, ULONG64 offset, ULONG flags, WCHAR *buffer,
+        ULONG buffer_size, ULONG *size, ULONG64 *end_offset)
+{
+    FIXME("%p, %s, %#lx, %p, %lu, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset), flags, buffer, buffer_size, size, end_offset);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNamesWide(IDebugControl4 *iface, ULONG type, WCHAR *fullname,
+        ULONG fullname_buffer_size, ULONG *fullname_size, WCHAR *abbrevname, ULONG abbrevname_buffer_size, ULONG *abbrevname_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, fullname, fullname_buffer_size, fullname_size, abbrevname,
+            abbrevname_buffer_size, abbrevname_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacroWide(IDebugControl4 *iface, ULONG slot, WCHAR *buffer,
+        ULONG buffer_size, ULONG *macro_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, slot, buffer, buffer_size, macro_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacroWide(IDebugControl4 *iface, ULONG slot, const WCHAR *macro)
+{
+    FIXME("%p, %lu, %s stub.\n", iface, slot, debugstr_w(macro));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_EvaluateWide(IDebugControl4 *iface, const WCHAR *expression, ULONG desired_type,
+        DEBUG_VALUE *value, ULONG *remainder_index)
+{
+    FIXME("%p, %s, %lu, %p, %p stub.\n", iface, debugstr_w(expression), desired_type, value, remainder_index);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteWide(IDebugControl4 *iface, ULONG output_control, const WCHAR *command,
+        ULONG flags)
+{
+    FIXME("%p, %lx, %s, %lx stub.\n", iface, output_control, debugstr_w(command), flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFileWide(IDebugControl4 *iface, ULONG output_control,
+        const WCHAR *commandfile, ULONG flags)
+{
+    FIXME("%p, %lx, %s, %lx stub.\n", iface, output_control, debugstr_w(commandfile), flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex2(IDebugControl4 *iface, ULONG index, PDEBUG_BREAKPOINT2 *bp)
+{
+    FIXME("%p, %lu, %p stub.\n", iface, index, bp);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById2(IDebugControl4 *iface, ULONG id, PDEBUG_BREAKPOINT2 *bp)
+{
+    FIXME("%p, %lu, %p stub.\n", iface, id, bp);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint2(IDebugControl4 *iface, ULONG type, ULONG desired_id,
+        PDEBUG_BREAKPOINT2 *bp)
+{
+    FIXME("%p, %lu, %lu, %p stub.\n", iface, type, desired_id, bp);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint2(IDebugControl4 *iface, PDEBUG_BREAKPOINT2 bp)
+{
+    FIXME("%p, %p stub.\n", iface, bp);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtensionWide(IDebugControl4 *iface, const WCHAR *path, ULONG flags,
+        ULONG64 *handle)
+{
+    FIXME("%p, %s, %#lx, %p stub.\n", iface, debugstr_w(path), flags, handle);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPathWide(IDebugControl4 *iface, const WCHAR *path, ULONG64 *handle)
+{
+    FIXME("%p, %s, %p stub.\n", iface, debugstr_w(path), handle);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtensionWide(IDebugControl4 *iface, ULONG64 handle, const WCHAR *function,
+        const WCHAR *arguments)
+{
+    FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_w(function), debugstr_w(arguments));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunctionWide(IDebugControl4 *iface, ULONG64 handle,
+        const WCHAR *function, FARPROC *func)
+{
+    FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), debugstr_w(function), func);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterTextWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
+        ULONG buffer_size, ULONG *text_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, text_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommandWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
+        ULONG buffer_size, ULONG *command_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommandWide(IDebugControl4 *iface, ULONG index, const WCHAR *command)
+{
+    FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(command));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgumentWide(IDebugControl4 *iface, ULONG index, WCHAR *buffer,
+        ULONG buffer_size, ULONG *argument_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, argument_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgumentWide(IDebugControl4 *iface, ULONG index,
+        const WCHAR *argument)
+{
+    FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(argument));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterSecondCommandWide(IDebugControl4 *iface, ULONG index,
+        WCHAR *buffer, ULONG buffer_size, ULONG *command_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, index, buffer, buffer_size, command_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterSecondCommandWide(IDebugControl4 *iface, ULONG index,
+        const WCHAR *command)
+{
+    FIXME("%p, %lu, %s stub.\n", iface, index, debugstr_w(command));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformationWide(IDebugControl4 *iface, ULONG *type, ULONG *processid,
+        ULONG *threadid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, WCHAR *desc, ULONG desc_size,
+        ULONG *desc_used)
+{
+    FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, processid, threadid, extra_info, extra_info_size,
+            extra_info_used, desc, desc_size, desc_used);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextReplacementWide(IDebugControl4 *iface, const WCHAR *src_text, ULONG index,
+        WCHAR *src_buffer, ULONG src_buffer_size, ULONG *src_size, WCHAR *dst_buffer, ULONG dest_buffer_size, ULONG *dst_size)
+{
+    FIXME("%p, %s, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, debugstr_w(src_text), index, src_buffer, src_buffer_size,
+            src_size, dst_buffer, dest_buffer_size, dst_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacementWide(IDebugControl4 *iface, const WCHAR *src_text,
+        const WCHAR *dst_text)
+{
+    FIXME("%p, %s, %s stub.\n", iface, debugstr_w(src_text), debugstr_w(dst_text));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetExpressionSyntaxByNameWide(IDebugControl4 *iface, const WCHAR *abbrevname)
+{
+    FIXME("%p, %s stub.\n", iface, debugstr_w(abbrevname));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExpressionSyntaxNamesWide(IDebugControl4 *iface, ULONG index,
+        WCHAR *fullname_buffer, ULONG fullname_buffer_size, ULONG *fullname_size, WCHAR *abbrevname_buffer,
+        ULONG abbrevname_buffer_size, ULONG *abbrev_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p, %p, %lu, %p stub.\n", iface, index, fullname_buffer, fullname_buffer_size, fullname_size,
+            abbrevname_buffer, abbrevname_buffer_size, abbrev_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventIndexDescriptionWide(IDebugControl4 *iface, ULONG index, ULONG which,
+        WCHAR *buffer, ULONG buffer_size, ULONG *desc_size)
+{
+    FIXME("%p, %lu, %lu, %p, %lu, %p stub.\n", iface, index, which, buffer, buffer_size, desc_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile2(IDebugControl4 *iface, char *buffer, ULONG buffer_size,
+        ULONG *file_size, ULONG *flags)
+{
+    FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile2(IDebugControl4 *iface, const char *filename, ULONG flags)
+{
+    FIXME("%p, %s, %#lx stub.\n", iface, debugstr_a(filename), flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile2Wide(IDebugControl4 *iface, WCHAR *buffer, ULONG buffer_size,
+        ULONG *file_size, ULONG *flags)
+{
+    FIXME("%p, %p, %lu, %p, %p stub.\n", iface, buffer, buffer_size, file_size, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile2Wide(IDebugControl4 *iface, const WCHAR *filename, ULONG flags)
+{
+    FIXME("%p, %s, %#lx stub.\n", iface, debugstr_w(filename), flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionValues(IDebugControl4 *iface, ULONG *platformid,
+        ULONG *win32major, ULONG *win32minor, ULONG *kdmajor, ULONG *kdminor)
+{
+    FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, platformid, win32major, win32minor, kdmajor, kdminor);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionString(IDebugControl4 *iface, ULONG which, char *buffer,
+        ULONG buffer_size, ULONG *string_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, which, buffer, buffer_size, string_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersionStringWide(IDebugControl4 *iface, ULONG which, WCHAR *buffer,
+        ULONG buffer_size, ULONG *string_size)
+{
+    FIXME("%p, %lu, %p, %lu, %p stub.\n", iface, which, buffer, buffer_size, string_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetContextStackTrace(IDebugControl4 *iface, void *start_context,
+        ULONG start_context_size, PDEBUG_STACK_FRAME frames, ULONG frames_size, void *frame_contexts, ULONG frame_contexts_size,
+        ULONG frame_contexts_entry_size, ULONG *frames_filled)
+{
+    FIXME("%p, %p, %lu, %p, %lu, %p, %lu, %lu, %p stub.\n", iface, start_context, start_context_size, frames, frames_size,
+            frame_contexts, frame_contexts_size, frame_contexts_entry_size, frames_filled);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputContextStackTrace(IDebugControl4 *iface, ULONG output_control,
+        PDEBUG_STACK_FRAME frames, ULONG frames_size, void *frame_contexts, ULONG frame_contexts_size,
+        ULONG frame_contexts_entry_size, ULONG flags)
+{
+    FIXME("%p, %#lx, %p, %lu, %p, %lu, %lu, %#lx stub.\n", iface, output_control, frames, frames_size, frame_contexts,
+            frame_contexts_size, frame_contexts_entry_size, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetStoredEventInformation(IDebugControl4 *iface, ULONG *type, ULONG *processid,
+        ULONG *threadid, void *context, ULONG context_size, ULONG *context_used, void *extra_info, ULONG extra_info_size,
+        ULONG *extra_info_used)
+{
+    FIXME("%p, %p, %p, %p, %p, %lu, %p, %p, %lu, %p stub.\n", iface, type, processid, threadid, context, context_size,
+            context_used, extra_info, extra_info_size, extra_info_used);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetManagedStatus(IDebugControl4 *iface, ULONG *flags, ULONG which_string,
+        char *string, ULONG string_size, ULONG string_needed)
+{
+    FIXME("%p, %p, %lu, %p, %lu, %lu stub.\n", iface, flags, which_string, string, string_size, string_needed);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetManagedStatusWide(IDebugControl4 *iface, ULONG *flags, ULONG which_string,
+        WCHAR *string, ULONG string_size, ULONG string_needed)
+{
+    FIXME("%p, %p, %lu, %p, %lu, %lu stub.\n", iface, flags, which_string, string, string_size, string_needed);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ResetManagedStatus(IDebugControl4 *iface, ULONG flags)
+{
+    FIXME("%p, %#lx stub.\n", iface, flags);
+
+    return E_NOTIMPL;
+}
+
+static const IDebugControl4Vtbl debugcontrolvtbl =
 {
     debugcontrol_QueryInterface,
     debugcontrol_AddRef,
@@ -3678,6 +4198,72 @@ static const IDebugControl2Vtbl debugcontrolvtbl =
     debugcontrol_SetTextReplacement,
     debugcontrol_RemoveTextReplacements,
     debugcontrol_OutputTextReplacements,
+    debugcontrol_GetAssemblyOptions,
+    debugcontrol_AddAssemblyOptions,
+    debugcontrol_RemoveAssemblyOptions,
+    debugcontrol_SetAssemblyOptions,
+    debugcontrol_GetExpressionSyntax,
+    debugcontrol_SetExpressionSyntax,
+    debugcontrol_SetExpressionSyntaxByName,
+    debugcontrol_GetNumberExpressionSyntaxes,
+    debugcontrol_GetExpressionSyntaxNames,
+    debugcontrol_GetNumberEvents,
+    debugcontrol_GetEventIndexDescription,
+    debugcontrol_GetCurrentEventIndex,
+    debugcontrol_SetNextEventIndex,
+    debugcontrol_GetLogFileWide,
+    debugcontrol_OpenLogFileWide,
+    debugcontrol_InputWide,
+    debugcontrol_ReturnInputWide,
+    debugcontrol_OutputWide,
+    debugcontrol_OutputVaListWide,
+    debugcontrol_ControlledOutputWide,
+    debugcontrol_ControlledOutputVaListWide,
+    debugcontrol_OutputPromptWide,
+    debugcontrol_OutputPromptVaListWide,
+    debugcontrol_GetPromptTextWide,
+    debugcontrol_AssembleWide,
+    debugcontrol_DisassembleWide,
+    debugcontrol_GetProcessorTypeNamesWide,
+    debugcontrol_GetTextMacroWide,
+    debugcontrol_SetTextMacroWide,
+    debugcontrol_EvaluateWide,
+    debugcontrol_ExecuteWide,
+    debugcontrol_ExecuteCommandFileWide,
+    debugcontrol_GetBreakpointByIndex2,
+    debugcontrol_GetBreakpointById2,
+    debugcontrol_AddBreakpoint2,
+    debugcontrol_RemoveBreakpoint2,
+    debugcontrol_AddExtensionWide,
+    debugcontrol_GetExtensionByPathWide,
+    debugcontrol_CallExtensionWide,
+    debugcontrol_GetExtensionFunctionWide,
+    debugcontrol_GetEventFilterTextWide,
+    debugcontrol_GetEventFilterCommandWide,
+    debugcontrol_SetEventFilterCommandWide,
+    debugcontrol_GetSpecificFilterArgumentWide,
+    debugcontrol_SetSpecificFilterArgumentWide,
+    debugcontrol_GetSpecificFilterSecondCommandWide,
+    debugcontrol_SetSpecificFilterSecondCommandWide,
+    debugcontrol_GetLastEventInformationWide,
+    debugcontrol_GetTextReplacementWide,
+    debugcontrol_SetTextReplacementWide,
+    debugcontrol_SetExpressionSyntaxByNameWide,
+    debugcontrol_GetExpressionSyntaxNamesWide,
+    debugcontrol_GetEventIndexDescriptionWide,
+    debugcontrol_GetLogFile2,
+    debugcontrol_OpenLogFile2,
+    debugcontrol_GetLogFile2Wide,
+    debugcontrol_OpenLogFile2Wide,
+    debugcontrol_GetSystemVersionValues,
+    debugcontrol_GetSystemVersionString,
+    debugcontrol_GetSystemVersionStringWide,
+    debugcontrol_GetContextStackTrace,
+    debugcontrol_OutputContextStackTrace,
+    debugcontrol_GetStoredEventInformation,
+    debugcontrol_GetManagedStatus,
+    debugcontrol_GetManagedStatusWide,
+    debugcontrol_ResetManagedStatus,
 };

static HRESULT STDMETHODCALLTYPE debugadvanced_QueryInterface(IDebugAdvanced *iface, REFIID riid, void **obj)
@@ -4038,7 +4624,7 @@ HRESULT WINAPI DebugCreate(REFIID riid, void **obj)
     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->IDebugControl4_iface.lpVtbl = &debugcontrolvtbl;
     debug_client->IDebugAdvanced_iface.lpVtbl = &debugadvancedvtbl;
     debug_client->IDebugSystemObjects_iface.lpVtbl = &debugsystemobjectsvtbl;
     debug_client->refcount = 1;

[PATCH 3/4] include: Add IDebugAdvanced3 definition.

[Nikolay Sivov]

Signed-off-by: Nikolay Sivov 
---
 include/dbgeng.h | 63 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/include/dbgeng.h b/include/dbgeng.h
index e417704915a..4322eff5302 100644
--- a/include/dbgeng.h
+++ b/include/dbgeng.h
@@ -47,6 +47,8 @@ DEFINE_GUID(IID_IDebugControl2,           0xd4366723, 0x44df, 0x4bed, 0x8c, 0x7e
 DEFINE_GUID(IID_IDebugControl3,           0x7df74a86, 0xb03f, 0x407f, 0x90, 0xab, 0xa2, 0x0d, 0xad, 0xce, 0xad, 0x08);
 DEFINE_GUID(IID_IDebugControl4,           0x94e60ce9, 0x9b41, 0x4b19, 0x9f, 0xc0, 0x6d, 0x9e, 0xb3, 0x52, 0x72, 0xb3);
 DEFINE_GUID(IID_IDebugAdvanced,           0xf2df5f53, 0x071f, 0x47bd, 0x9d, 0xe6, 0x57, 0x34, 0xc3, 0xfe, 0xd6, 0x89);
+DEFINE_GUID(IID_IDebugAdvanced2,          0x716d14c9, 0x119b, 0x4ba5, 0xaf, 0x1f, 0x08, 0x90, 0xe6, 0x72, 0x41, 0x6a);
+DEFINE_GUID(IID_IDebugAdvanced3,          0xcba4abb4, 0x84c4, 0x444d, 0x87, 0xca, 0xa0, 0x4e, 0x13, 0x28, 0x67, 0x39);
 DEFINE_GUID(IID_IDebugSystemObjects,      0x6b86fe2c, 0x2c4f, 0x4f0c, 0x9d, 0xa2, 0x17, 0x43, 0x11, 0xac, 0xc3, 0x27);
 DEFINE_GUID(IID_IDebugSystemObjects2,     0x0ae9f5ff, 0x1852, 0x4679, 0xb0, 0x55, 0x49, 0x4b, 0xee, 0x64, 0x07, 0xee);
 DEFINE_GUID(IID_IDebugSystemObjects3,     0xe9676e2f, 0xe286, 0x4ea3, 0xb0, 0xf9, 0xdf, 0xe5, 0xd9, 0xfc, 0x33, 0x0e);
@@ -2347,6 +2349,67 @@ DECLARE_INTERFACE_(IDebugAdvanced, IUnknown)
 };
 #undef INTERFACE

+#define INTERFACE IDebugAdvanced2
+DECLARE_INTERFACE_(IDebugAdvanced2, IUnknown)
+{
+    /* IUnknown */
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+    /* IDebugAdvanced */
+    STDMETHOD(GetThreadContext)(THIS_ void *context, ULONG context_size) PURE;
+    STDMETHOD(SetThreadContext)(THIS_ void *context, ULONG context_size) PURE;
+    /* IDebugAdvanced2 */
+    STDMETHOD(Request)(THIS_ ULONG request, void *inbuffer, ULONG inbuffer_size,
+            void *outbuffer, ULONG outbuffer_size, ULONG *outsize) PURE;
+    STDMETHOD(GetSourceFileInformation)(THIS_ ULONG which, char *sourcefile,
+            ULONG64 arg64, ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size) PURE;
+    STDMETHOD(FindSourceFileAndToken)(THIS_ ULONG start_element, ULONG64 modaddr, const char *filename,
+            ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element, char *buffer,
+            ULONG buffer_size, ULONG *found_size) PURE;
+    STDMETHOD(GetSymbolInformation)(THIS_ ULONG which, ULONG64 arg64, ULONG arg32, void *buffer,
+            ULONG buffer_size, ULONG *info_size, char *string_buffer, ULONG string_buffer_size,
+            ULONG *string_size) PURE;
+    STDMETHOD(GetSystemObjectInformation)(THIS_ ULONG which, ULONG64 arg64, ULONG arg32,
+            void *buffer, ULONG buffer_size, ULONG *info_size) PURE;
+};
+#undef INTERFACE
+
+#define INTERFACE IDebugAdvanced3
+DECLARE_INTERFACE_(IDebugAdvanced3, IUnknown)
+{
+    /* IUnknown */
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+    /* IDebugAdvanced */
+    STDMETHOD(GetThreadContext)(THIS_ void *context, ULONG context_size) PURE;
+    STDMETHOD(SetThreadContext)(THIS_ void *context, ULONG context_size) PURE;
+    /* IDebugAdvanced2 */
+    STDMETHOD(Request)(THIS_ ULONG request, void *inbuffer, ULONG inbuffer_size,
+            void *outbuffer, ULONG outbuffer_size, ULONG *outsize) PURE;
+    STDMETHOD(GetSourceFileInformation)(THIS_ ULONG which, char *sourcefile,
+            ULONG64 arg64, ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size) PURE;
+    STDMETHOD(FindSourceFileAndToken)(THIS_ ULONG start_element, ULONG64 modaddr, const char *filename,
+            ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element, char *buffer,
+            ULONG buffer_size, ULONG *found_size) PURE;
+    STDMETHOD(GetSymbolInformation)(THIS_ ULONG which, ULONG64 arg64, ULONG arg32, void *buffer,
+            ULONG buffer_size, ULONG *info_size, char *string_buffer, ULONG string_buffer_size,
+            ULONG *string_size) PURE;
+    STDMETHOD(GetSystemObjectInformation)(THIS_ ULONG which, ULONG64 arg64, ULONG arg32,
+            void *buffer, ULONG buffer_size, ULONG *info_size) PURE;
+    /* IDebugAdvanced3 */
+    STDMETHOD(GetSourceFileInformationWide)(THIS_ ULONG which, WCHAR *source_file, ULONG64 arg64,
+            ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size) PURE;
+    STDMETHOD(FindSourceFileAndTokenWide)(THIS_ ULONG start_element, ULONG64 modaddr, const WCHAR *filename,
+            ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element, WCHAR *buffer,
+            ULONG buffer_size, ULONG *found_size) PURE;
+    STDMETHOD(GetSymbolInformationWide)(THIS_ ULONG which, ULONG64 arg64, ULONG arg32, void *buffer,
+            ULONG buffer_size, ULONG *info_size, WCHAR *string_buffer, ULONG string_buffer_size,
+            ULONG *string_size) PURE;
+};
+#undef INTERFACE
+
 #define INTERFACE IDebugSystemObjects
 DECLARE_INTERFACE_(IDebugSystemObjects, IUnknown)
 {

[PATCH 4/4] dbgeng: Update to IDebugAdvanced3 stub.

[Nikolay Sivov]

Signed-off-by: Nikolay Sivov 
---
 dlls/dbgeng/dbgeng.c | 126 +++++++++++++++++++++++++++++++++++--------
 1 file changed, 103 insertions(+), 23 deletions(-)

diff --git a/dlls/dbgeng/dbgeng.c b/dlls/dbgeng/dbgeng.c
index e0e7c3ff98e..3ec510ef296 100644
--- a/dlls/dbgeng/dbgeng.c
+++ b/dlls/dbgeng/dbgeng.c
@@ -63,7 +63,7 @@ struct debug_client
     IDebugDataSpaces IDebugDataSpaces_iface;
     IDebugSymbols3 IDebugSymbols3_iface;
     IDebugControl4 IDebugControl4_iface;
-    IDebugAdvanced IDebugAdvanced_iface;
+    IDebugAdvanced3 IDebugAdvanced3_iface;
     IDebugSystemObjects IDebugSystemObjects_iface;
     LONG refcount;
     ULONG engine_options;
@@ -257,9 +257,9 @@ static struct debug_client *impl_from_IDebugControl4(IDebugControl4 *iface)
     return CONTAINING_RECORD(iface, struct debug_client, IDebugControl4_iface);
 }

-static struct debug_client *impl_from_IDebugAdvanced(IDebugAdvanced *iface)
+static struct debug_client *impl_from_IDebugAdvanced3(IDebugAdvanced3 *iface)
 {
-    return CONTAINING_RECORD(iface, struct debug_client, IDebugAdvanced_iface);
+    return CONTAINING_RECORD(iface, struct debug_client, IDebugAdvanced3_iface);
 }

static struct debug_client *impl_from_IDebugSystemObjects(IDebugSystemObjects *iface)
@@ -301,9 +301,11 @@ static HRESULT STDMETHODCALLTYPE debugclient_QueryInterface(IDebugClient7 *iface
     {
         *obj = &debug_client->IDebugControl4_iface;
     }
-    else if (IsEqualIID(riid, &IID_IDebugAdvanced))
+    else if (IsEqualIID(riid, &IID_IDebugAdvanced3)
+            || IsEqualIID(riid, &IID_IDebugAdvanced2)
+            || IsEqualIID(riid, &IID_IDebugAdvanced))
     {
-        *obj = &debug_client->IDebugAdvanced_iface;
+        *obj = &debug_client->IDebugAdvanced3_iface;
     }
     else if (IsEqualIID(riid, &IID_IDebugSystemObjects))
     {
@@ -4266,28 +4268,25 @@ static const IDebugControl4Vtbl debugcontrolvtbl =
     debugcontrol_ResetManagedStatus,
 };

-static HRESULT STDMETHODCALLTYPE debugadvanced_QueryInterface(IDebugAdvanced *iface, REFIID riid, void **obj)
+static HRESULT STDMETHODCALLTYPE debugadvanced_QueryInterface(IDebugAdvanced3 *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);
+    struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
+    return IUnknown_QueryInterface((IUnknown *)&debug_client->IDebugClient_iface, riid, obj);
 }

-static ULONG STDMETHODCALLTYPE debugadvanced_AddRef(IDebugAdvanced *iface)
+static ULONG STDMETHODCALLTYPE debugadvanced_AddRef(IDebugAdvanced3 *iface)
 {
-    struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
-    IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
-    return IUnknown_AddRef(unk);
+    struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
+    return IUnknown_AddRef((IUnknown *)&debug_client->IDebugClient_iface);
 }

-static ULONG STDMETHODCALLTYPE debugadvanced_Release(IDebugAdvanced *iface)
+static ULONG STDMETHODCALLTYPE debugadvanced_Release(IDebugAdvanced3 *iface)
 {
-    struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
-    IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
-    return IUnknown_Release(unk);
+    struct debug_client *debug_client = impl_from_IDebugAdvanced3(iface);
+    return IUnknown_Release((IUnknown *)&debug_client->IDebugClient_iface);
 }

-static HRESULT STDMETHODCALLTYPE debugadvanced_GetThreadContext(IDebugAdvanced *iface, void *context,
+static HRESULT STDMETHODCALLTYPE debugadvanced_GetThreadContext(IDebugAdvanced3 *iface, void *context,
         ULONG context_size)
 {
     FIXME("%p, %p, %lu stub.\n", iface, context, context_size);
@@ -4295,7 +4294,7 @@ static HRESULT STDMETHODCALLTYPE debugadvanced_GetThreadContext(IDebugAdvanced *
     return E_NOTIMPL;
 }

-static HRESULT STDMETHODCALLTYPE debugadvanced_SetThreadContext(IDebugAdvanced *iface, void *context,
+static HRESULT STDMETHODCALLTYPE debugadvanced_SetThreadContext(IDebugAdvanced3 *iface, void *context,
         ULONG context_size)
 {
     FIXME("%p, %p, %lu stub.\n", iface, context, context_size);
@@ -4303,17 +4302,98 @@ static HRESULT STDMETHODCALLTYPE debugadvanced_SetThreadContext(IDebugAdvanced *
     return E_NOTIMPL;
 }

-static const IDebugAdvancedVtbl debugadvancedvtbl =
+static HRESULT STDMETHODCALLTYPE debugadvanced_Request(IDebugAdvanced3 *iface, ULONG request, void *inbuffer,
+        ULONG inbuffer_size, void *outbuffer, ULONG outbuffer_size, ULONG *outsize)
+{
+    FIXME("%p, %lu, %p, %lu, %p, %lu, %p stub.\n", iface, request, inbuffer, inbuffer_size, outbuffer, outbuffer_size, outsize);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_GetSourceFileInformation(IDebugAdvanced3 *iface, ULONG which, char *sourcefile,
+        ULONG64 arg64, ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
+{
+    FIXME("%p, %lu, %p, %s, %#lx, %p, %lu, %p stub.\n", iface, which, sourcefile, wine_dbgstr_longlong(arg64),
+            arg32, buffer, buffer_size, info_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_FindSourceFileAndToken(IDebugAdvanced3 *iface, ULONG start_element,
+        ULONG64 modaddr, const char *filename, ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element,
+        char *buffer, ULONG buffer_size, ULONG *found_size)
+{
+    FIXME("%p, %lu, %s, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, start_element, wine_dbgstr_longlong(modaddr),
+            debugstr_a(filename), flags, filetoken, filetokensize, found_element, buffer, buffer_size, found_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_GetSymbolInformation(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
+        ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size, char *string_buffer, ULONG string_buffer_size,
+        ULONG *string_size)
+{
+    FIXME("%p, %lu, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64),
+            arg32, buffer, buffer_size, info_size, string_buffer, string_buffer_size, string_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_GetSystemObjectInformation(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
+        ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
+{
+    FIXME("%p, %lu, %s, %#lx, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64), arg32, buffer,
+            buffer_size, info_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_GetSourceFileInformationWide(IDebugAdvanced3 *iface, ULONG which,
+        WCHAR *source_file, ULONG64 arg64, ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size)
+{
+    FIXME("%p, %lu, %p, %s, %#lx, %p, %lu, %p stub.\n", iface, which, source_file, wine_dbgstr_longlong(arg64),
+            arg32, buffer, buffer_size, info_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_FindSourceFileAndTokenWide(IDebugAdvanced3 *iface, ULONG start_element,
+        ULONG64 modaddr, const WCHAR *filename, ULONG flags, void *filetoken, ULONG filetokensize, ULONG *found_element,
+        WCHAR *buffer, ULONG buffer_size, ULONG *found_size)
+{
+    FIXME("%p, %lu, %s, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, start_element, wine_dbgstr_longlong(modaddr),
+            debugstr_w(filename), flags, filetoken, filetokensize, found_element, buffer, buffer_size, found_size);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_GetSymbolInformationWide(IDebugAdvanced3 *iface, ULONG which, ULONG64 arg64,
+        ULONG arg32, void *buffer, ULONG buffer_size, ULONG *info_size, WCHAR *string_buffer, ULONG string_buffer_size,
+        ULONG *string_size)
+{
+    FIXME("%p, %lu, %s, %#lx, %p, %lu, %p, %p, %lu, %p stub.\n", iface, which, wine_dbgstr_longlong(arg64),
+            arg32, buffer, buffer_size, info_size, string_buffer, string_buffer_size, string_size);
+
+    return E_NOTIMPL;
+}
+
+static const IDebugAdvanced3Vtbl debugadvancedvtbl =
 {
     debugadvanced_QueryInterface,
     debugadvanced_AddRef,
     debugadvanced_Release,
-    /* IDebugAdvanced */
     debugadvanced_GetThreadContext,
     debugadvanced_SetThreadContext,
+    debugadvanced_Request,
+    debugadvanced_GetSourceFileInformation,
+    debugadvanced_FindSourceFileAndToken,
+    debugadvanced_GetSymbolInformation,
+    debugadvanced_GetSystemObjectInformation,
+    debugadvanced_GetSourceFileInformationWide,
+    debugadvanced_FindSourceFileAndTokenWide,
+    debugadvanced_GetSymbolInformationWide,
 };

-
 static HRESULT STDMETHODCALLTYPE debugsystemobjects_QueryInterface(IDebugSystemObjects *iface, REFIID riid, void **obj)
 {
     struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
@@ -4625,7 +4705,7 @@ HRESULT WINAPI DebugCreate(REFIID riid, void **obj)
     debug_client->IDebugDataSpaces_iface.lpVtbl = &debugdataspacesvtbl;
     debug_client->IDebugSymbols3_iface.lpVtbl = &debugsymbolsvtbl;
     debug_client->IDebugControl4_iface.lpVtbl = &debugcontrolvtbl;
-    debug_client->IDebugAdvanced_iface.lpVtbl = &debugadvancedvtbl;
+    debug_client->IDebugAdvanced3_iface.lpVtbl = &debugadvancedvtbl;
     debug_client->IDebugSystemObjects_iface.lpVtbl = &debugsystemobjectsvtbl;
     debug_client->refcount = 1;
     list_init(&debug_client->targets);