Debugger.Interop assembly removed

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@367 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj

@@ -8,16 +8,15 @@
     <OutputType>Library</OutputType>
     <RootNamespace>Debugger.Core</RootNamespace>
     <AssemblyName>Debugger.Core</AssemblyName>
-    <WarningLevel>4</WarningLevel>
     <AssemblyOriginatorKeyMode>File</AssemblyOriginatorKeyMode>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
+    <NoWarn>108</NoWarn>
     <OutputPath>..\..\..\..\..\..\AddIns\AddIns\Misc\Debugger\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -27,10 +26,6 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Debugger.Interop, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\RequiredLibraries\Debugger.Interop.dll</HintPath>
-      <SpecificVersion>False</SpecificVersion>
-    </Reference>
     <Reference Include="ISymWrapper" />
     <Reference Include="System" />
     <Reference Include="System.Data" />
@@ -101,6 +96,101 @@
     <Compile Include="Src\RemotingSinks\PrivateEventHandlersSink\EventForwarder.cs" />
     <Compile Include="Src\RemotingSinks\PrivateEventHandlersSink\PrivateEventHandlersClientChannelSink.cs" />
     <Compile Include="Src\Debugger\NDebugger-StateControl.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebug.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugChainReason.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugClass.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugCreateProcessFlags.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugExceptionCallbackType.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugExceptionUnwindCallbackType.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugHandleType.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugIntercept.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugInternalFrameType.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugMappingResult.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugMDAFlags.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugRegister.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugStepReason.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugThreadState.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugUnmappedStop.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\CorDebugUserState.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\COR_DEBUG_STEP_RANGE.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\EmbeddedCLRCorDebug.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\EmbeddedCLRCorDebugClass.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebug.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugAppDomain.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugAppDomain2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugAppDomainEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugArrayValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugAssembly.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugAssemblyEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugBoxValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugBreakpoint.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugBreakpointEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugChain.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugChainEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugClass.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugClass2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugCode.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugCodeEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugContext.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugController.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugEditAndContinueSnapshot.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugErrorInfoEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugEval.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugEval2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugFrame.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugFrameEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugFunction.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugFunction2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugFunctionBreakpoint.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugGenericValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugHandleValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugHeapValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugHeapValue2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugILFrame.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugILFrame2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugInternalFrame.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugManagedCallback.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugManagedCallback2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugMDA.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugModule.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugModule2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugModuleBreakpoint.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugModuleEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugNativeFrame.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugObjectEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugObjectValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugObjectValue2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugProcess.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugProcess2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugProcessEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugReferenceValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugRegisterSet.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugStepper.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugStepper2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugStepperEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugStringValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugThread.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugThread2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugThreadEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugType.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugTypeEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugUnmanagedCallback.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugValue.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugValue2.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugValueBreakpoint.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ICorDebugValueEnum.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\ISequentialStream.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\IStream.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\tagSTATSTG.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\_COR_IL_MAP.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\_COR_VERSION.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\_FILETIME.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\_LARGE_INTEGER.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\_SECURITY_ATTRIBUTES.cs" />
+    <Compile Include="Src\DebuggerInterop\Core\_ULARGE_INTEGER.cs" />
+    <Compile Include="Src\DebuggerInterop\MetaData\COR_FIELD_OFFSET.cs" />
+    <Compile Include="Src\DebuggerInterop\MetaData\IMetaDataImport.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="README.TXT" />

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/COR_DEBUG_STEP_RANGE.cs

@@ -0,0 +1,13 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=4)]
+    public struct COR_DEBUG_STEP_RANGE
+    {
+        public uint startOffset;
+        public uint endOffset;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebug.cs

@@ -0,0 +1,10 @@
+namespace DebuggerInterop.Core
+{
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("3D6F5F61-7538-11D3-8D5B-00104B35E7EF"), CoClass(typeof(CorDebugClass))]
+    public interface CorDebug : ICorDebug
+    {
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugChainReason.cs

@@ -0,0 +1,23 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugChainReason
+    {
+        // Fields
+        CHAIN_CLASS_INIT = 1,
+        CHAIN_CONTEXT_POLICY = 8,
+        CHAIN_CONTEXT_SWITCH = 0x400,
+        CHAIN_DEBUGGER_EVAL = 0x200,
+        CHAIN_ENTER_MANAGED = 0x80,
+        CHAIN_ENTER_UNMANAGED = 0x100,
+        CHAIN_EXCEPTION_FILTER = 2,
+        CHAIN_FUNC_EVAL = 0x800,
+        CHAIN_INTERCEPTION = 0x10,
+        CHAIN_NONE = 0,
+        CHAIN_PROCESS_START = 0x20,
+        CHAIN_SECURITY = 4,
+        CHAIN_THREAD_START = 0x40
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugClass.cs

@@ -0,0 +1,40 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    //[ComImport]
+    public class CorDebugClass : ICorDebug, CorDebug
+    {
+        // Methods
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CanLaunchOrAttach([In] uint dwProcessId, [In] int win32DebuggingEnabled);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CreateProcess([In, MarshalAs(UnmanagedType.LPWStr)] string lpApplicationName, [In, MarshalAs(UnmanagedType.LPWStr)] string lpCommandLine, [In] ref _SECURITY_ATTRIBUTES lpProcessAttributes, [In] ref _SECURITY_ATTRIBUTES lpThreadAttributes, [In] int bInheritHandles, [In] uint dwCreationFlags, [In] IntPtr lpEnvironment, [In, MarshalAs(UnmanagedType.LPWStr)] string lpCurrentDirectory, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint lpStartupInfo, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint lpProcessInformation, [In] CorDebugCreateProcessFlags debuggingFlags, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DebugActiveProcess([In] uint id, [In] int win32Attach, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void EnumerateProcesses([MarshalAs(UnmanagedType.Interface)] out ICorDebugProcessEnum ppProcess);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetProcess([In] uint dwProcessId, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Initialize();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetManagedHandler([In, MarshalAs(UnmanagedType.Interface)] ICorDebugManagedCallback pCallback);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetUnmanagedHandler([In, MarshalAs(UnmanagedType.Interface)] ICorDebugUnmanagedCallback pCallback);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Terminate();
+
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugCreateProcessFlags.cs

@@ -0,0 +1,11 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugCreateProcessFlags
+    {
+        // Fields
+        DEBUG_NO_SPECIAL_OPTIONS = 0
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugExceptionCallbackType.cs

@@ -0,0 +1,14 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugExceptionCallbackType
+    {
+        // Fields
+        DEBUG_EXCEPTION_CATCH_HANDLER_FOUND = 3,
+        DEBUG_EXCEPTION_FIRST_CHANCE = 1,
+        DEBUG_EXCEPTION_UNHANDLED = 4,
+        DEBUG_EXCEPTION_USER_FIRST_CHANCE = 2
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugExceptionUnwindCallbackType.cs

@@ -0,0 +1,12 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugExceptionUnwindCallbackType
+    {
+        // Fields
+        DEBUG_EXCEPTION_INTERCEPTED = 2,
+        DEBUG_EXCEPTION_UNWIND_BEGIN = 1
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugHandleType.cs

@@ -0,0 +1,12 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugHandleType
+    {
+        // Fields
+        HANDLE_STRONG = 1,
+        HANDLE_WEAK_TRACK_RESURRECTION = 2
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugIntercept.cs

@@ -0,0 +1,17 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugIntercept
+    {
+        // Fields
+        INTERCEPT_ALL = 0xffff,
+        INTERCEPT_CLASS_INIT = 1,
+        INTERCEPT_CONTEXT_POLICY = 8,
+        INTERCEPT_EXCEPTION_FILTER = 2,
+        INTERCEPT_INTERCEPTION = 0x10,
+        INTERCEPT_NONE = 0,
+        INTERCEPT_SECURITY = 4
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugInternalFrameType.cs

@@ -0,0 +1,17 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugInternalFrameType
+    {
+        // Fields
+        STUBFRAME_APPDOMAIN_TRANSITION = 3,
+        STUBFRAME_FUNC_EVAL = 5,
+        STUBFRAME_INTERNALCALL = 6,
+        STUBFRAME_LIGHTWEIGHT_FUNCTION = 4,
+        STUBFRAME_M2U = 1,
+        STUBFRAME_NONE = 0,
+        STUBFRAME_U2M = 2
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugMDAFlags.cs

@@ -0,0 +1,11 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugMDAFlags
+    {
+        // Fields
+        MDA_FLAG_SLIP = 2
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugMappingResult.cs

@@ -0,0 +1,16 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugMappingResult
+    {
+        // Fields
+        MAPPING_APPROXIMATE = 0x20,
+        MAPPING_EPILOG = 2,
+        MAPPING_EXACT = 0x10,
+        MAPPING_NO_INFO = 4,
+        MAPPING_PROLOG = 1,
+        MAPPING_UNMAPPED_ADDRESS = 8
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugRegister.cs

@@ -0,0 +1,66 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugRegister
+    {
+        // Fields
+        REGISTER_AMD64_R10 = 11,
+        REGISTER_AMD64_R11 = 12,
+        REGISTER_AMD64_R12 = 13,
+        REGISTER_AMD64_R13 = 14,
+        REGISTER_AMD64_R14 = 15,
+        REGISTER_AMD64_R15 = 0x10,
+        REGISTER_AMD64_R8 = 9,
+        REGISTER_AMD64_R9 = 10,
+        REGISTER_AMD64_RAX = 3,
+        REGISTER_AMD64_RBP = 2,
+        REGISTER_AMD64_RBX = 6,
+        REGISTER_AMD64_RCX = 4,
+        REGISTER_AMD64_RDI = 8,
+        REGISTER_AMD64_RDX = 5,
+        REGISTER_AMD64_RIP = 0,
+        REGISTER_AMD64_RSI = 7,
+        REGISTER_AMD64_RSP = 1,
+        REGISTER_AMD64_XMM0 = 0x11,
+        REGISTER_AMD64_XMM1 = 0x12,
+        REGISTER_AMD64_XMM10 = 0x1b,
+        REGISTER_AMD64_XMM11 = 0x1c,
+        REGISTER_AMD64_XMM12 = 0x1d,
+        REGISTER_AMD64_XMM13 = 30,
+        REGISTER_AMD64_XMM14 = 0x1f,
+        REGISTER_AMD64_XMM15 = 0x20,
+        REGISTER_AMD64_XMM2 = 0x13,
+        REGISTER_AMD64_XMM3 = 20,
+        REGISTER_AMD64_XMM4 = 0x15,
+        REGISTER_AMD64_XMM5 = 0x16,
+        REGISTER_AMD64_XMM6 = 0x17,
+        REGISTER_AMD64_XMM7 = 0x18,
+        REGISTER_AMD64_XMM8 = 0x19,
+        REGISTER_AMD64_XMM9 = 0x1a,
+        REGISTER_FRAME_POINTER = 2,
+        REGISTER_IA64_BSP = 2,
+        REGISTER_IA64_F0 = 0x83,
+        REGISTER_IA64_R0 = 3,
+        REGISTER_INSTRUCTION_POINTER = 0,
+        REGISTER_STACK_POINTER = 1,
+        REGISTER_X86_EAX = 3,
+        REGISTER_X86_EBP = 2,
+        REGISTER_X86_EBX = 6,
+        REGISTER_X86_ECX = 4,
+        REGISTER_X86_EDI = 8,
+        REGISTER_X86_EDX = 5,
+        REGISTER_X86_EIP = 0,
+        REGISTER_X86_ESI = 7,
+        REGISTER_X86_ESP = 1,
+        REGISTER_X86_FPSTACK_0 = 9,
+        REGISTER_X86_FPSTACK_1 = 10,
+        REGISTER_X86_FPSTACK_2 = 11,
+        REGISTER_X86_FPSTACK_3 = 12,
+        REGISTER_X86_FPSTACK_4 = 13,
+        REGISTER_X86_FPSTACK_5 = 14,
+        REGISTER_X86_FPSTACK_6 = 15,
+        REGISTER_X86_FPSTACK_7 = 0x10
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugStepReason.cs

@@ -0,0 +1,17 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugStepReason
+    {
+        // Fields
+        STEP_CALL = 2,
+        STEP_EXCEPTION_FILTER = 3,
+        STEP_EXCEPTION_HANDLER = 4,
+        STEP_EXIT = 6,
+        STEP_INTERCEPT = 5,
+        STEP_NORMAL = 0,
+        STEP_RETURN = 1
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugThreadState.cs

@@ -0,0 +1,12 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugThreadState
+    {
+        // Fields
+        THREAD_RUN = 0,
+        THREAD_SUSPEND = 1
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugUnmappedStop.cs

@@ -0,0 +1,17 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugUnmappedStop
+    {
+        // Fields
+        STOP_ALL = 0xffff,
+        STOP_EPILOG = 2,
+        STOP_NO_MAPPING_INFO = 4,
+        STOP_NONE = 0,
+        STOP_OTHER_UNMAPPED = 8,
+        STOP_PROLOG = 1,
+        STOP_UNMANAGED = 0x10
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/CorDebugUserState.cs

@@ -0,0 +1,18 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+
+    public enum CorDebugUserState
+    {
+        // Fields
+        USER_BACKGROUND = 4,
+        USER_STOP_REQUESTED = 1,
+        USER_STOPPED = 0x10,
+        USER_SUSPEND_REQUESTED = 2,
+        USER_SUSPENDED = 0x40,
+        USER_UNSAFE_POINT = 0x80,
+        USER_UNSTARTED = 8,
+        USER_WAIT_SLEEP_JOIN = 0x20
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/EmbeddedCLRCorDebug.cs

@@ -0,0 +1,10 @@
+namespace DebuggerInterop.Core
+{
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("3D6F5F61-7538-11D3-8D5B-00104B35E7EF"), CoClass(typeof(EmbeddedCLRCorDebugClass))]
+    public interface EmbeddedCLRCorDebug : ICorDebug
+    {
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/EmbeddedCLRCorDebugClass.cs

@@ -0,0 +1,40 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ClassInterface((short) 0), TypeLibType((short) 2), Guid("211F1254-BC7E-4AF5-B9AA-067308D83DD1")]
+    public class EmbeddedCLRCorDebugClass : ICorDebug, EmbeddedCLRCorDebug
+    {
+        // Methods
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CanLaunchOrAttach([In] uint dwProcessId, [In] int win32DebuggingEnabled);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CreateProcess([In, MarshalAs(UnmanagedType.LPWStr)] string lpApplicationName, [In, MarshalAs(UnmanagedType.LPWStr)] string lpCommandLine, [In] ref _SECURITY_ATTRIBUTES lpProcessAttributes, [In] ref _SECURITY_ATTRIBUTES lpThreadAttributes, [In] int bInheritHandles, [In] uint dwCreationFlags, [In] IntPtr lpEnvironment, [In, MarshalAs(UnmanagedType.LPWStr)] string lpCurrentDirectory, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint lpStartupInfo, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint lpProcessInformation, [In] CorDebugCreateProcessFlags debuggingFlags, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DebugActiveProcess([In] uint id, [In] int win32Attach, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void EnumerateProcesses([MarshalAs(UnmanagedType.Interface)] out ICorDebugProcessEnum ppProcess);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetProcess([In] uint dwProcessId, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Initialize();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetManagedHandler([In, MarshalAs(UnmanagedType.Interface)] ICorDebugManagedCallback pCallback);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetUnmanagedHandler([In, MarshalAs(UnmanagedType.Interface)] ICorDebugUnmanagedCallback pCallback);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Terminate();
+
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebug.cs

@@ -0,0 +1,30 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("3D6F5F61-7538-11D3-8D5B-00104B35E7EF"), InterfaceType((short) 1)]
+    public interface ICorDebug
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Initialize();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Terminate();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetManagedHandler([In, MarshalAs(UnmanagedType.Interface)] ICorDebugManagedCallback pCallback);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetUnmanagedHandler([In, MarshalAs(UnmanagedType.Interface)] ICorDebugUnmanagedCallback pCallback);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateProcess([In, MarshalAs(UnmanagedType.LPWStr)] string lpApplicationName, [In, MarshalAs(UnmanagedType.LPWStr)] string lpCommandLine, [In] ref _SECURITY_ATTRIBUTES lpProcessAttributes, [In] ref _SECURITY_ATTRIBUTES lpThreadAttributes, [In] int bInheritHandles, [In] uint dwCreationFlags, [In] IntPtr lpEnvironment, [In, MarshalAs(UnmanagedType.LPWStr)] string lpCurrentDirectory, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint lpStartupInfo, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint lpProcessInformation, [In] CorDebugCreateProcessFlags debuggingFlags, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DebugActiveProcess([In] uint id, [In] int win32Attach, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateProcesses([MarshalAs(UnmanagedType.Interface)] out ICorDebugProcessEnum ppProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetProcess([In] uint dwProcessId, [MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CanLaunchOrAttach([In] uint dwProcessId, [In] int win32DebuggingEnabled);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugAppDomain.cs

@@ -0,0 +1,52 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("3D6F5F63-7538-11D3-8D5B-00104B35E7EF"), ComConversionLoss, InterfaceType((short) 1)]
+    public interface ICorDebugAppDomain : ICorDebugController
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Stop([In] uint dwTimeoutIgnored);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Continue([In] int fIsOutOfBand);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsRunning(out int pbRunning);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void HasQueuedCallbacks([In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pThread, out int pbQueued);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateThreads([MarshalAs(UnmanagedType.Interface)] out ICorDebugThreadEnum ppThreads);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetAllThreadsDebugState([In] CorDebugThreadState state, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pExceptThisThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Detach();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Terminate([In] uint exitCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CanCommitChanges([In] uint cSnapshots, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugEditAndContinueSnapshot pSnapshots, [MarshalAs(UnmanagedType.Interface)] out ICorDebugErrorInfoEnum pError);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CommitChanges([In] uint cSnapshots, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugEditAndContinueSnapshot pSnapshots, [MarshalAs(UnmanagedType.Interface)] out ICorDebugErrorInfoEnum pError);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetProcess([MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateAssemblies([MarshalAs(UnmanagedType.Interface)] out ICorDebugAssemblyEnum ppAssemblies);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetModuleFromMetaDataInterface([In, MarshalAs(UnmanagedType.IUnknown)] object pIMetaData, [MarshalAs(UnmanagedType.Interface)] out ICorDebugModule ppModule);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateBreakpoints([MarshalAs(UnmanagedType.Interface)] out ICorDebugBreakpointEnum ppBreakpoints);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateSteppers([MarshalAs(UnmanagedType.Interface)] out ICorDebugStepperEnum ppSteppers);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsAttached(out int pbAttached);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetObject([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppObject);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Attach();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetID(out uint pId);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugAppDomain2.cs

@@ -0,0 +1,16 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("096E81D5-ECDA-4202-83F5-C65980A9EF75"), InterfaceType((short) 1)]
+    public interface ICorDebugAppDomain2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetArrayOrPointerType([In] uint elementType, [In] uint nRank, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugType pTypeArg, [MarshalAs(UnmanagedType.Interface)] out ICorDebugType ppType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunctionPointerType([In] uint nTypeArgs, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugType ppTypeArgs, [MarshalAs(UnmanagedType.Interface)] out ICorDebugType ppType);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugAppDomainEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("63CA1B24-4359-4883-BD57-13F815F58744"), InterfaceType((short) 1), ComConversionLoss]
+    public interface ICorDebugAppDomainEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr values, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugArrayValue.cs

@@ -0,0 +1,40 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ComConversionLoss, Guid("0405B0DF-A660-11D2-BD02-0000F80849BD"), InterfaceType((short) 1)]
+    public interface ICorDebugArrayValue : ICorDebugHeapValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsValid(out int pbValid);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateRelocBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetElementType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRank(out uint pnRank);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pnCount);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetDimensions([In] uint cdim, [Out] IntPtr dims);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void HasBaseIndicies(out int pbHasBaseIndicies);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetBaseIndicies([In] uint cdim, [Out] IntPtr indicies);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetElement([In] uint cdim, [In] IntPtr indices, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetElementAtPosition([In] uint nPosition, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugAssembly.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("DF59507C-D47A-459E-BCE2-6427EAC8FD06"), ComConversionLoss, InterfaceType((short) 1)]
+    public interface ICorDebugAssembly
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetProcess([MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAppDomain([MarshalAs(UnmanagedType.Interface)] out ICorDebugAppDomain ppAppDomain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateModules([MarshalAs(UnmanagedType.Interface)] out ICorDebugModuleEnum ppModules);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCodeBase([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugAssemblyEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), ComConversionLoss, Guid("4A2A1EC9-85EC-4BFB-9F15-A89FDFE0FE83")]
+    public interface ICorDebugAssemblyEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr values, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugBoxValue.cs

@@ -0,0 +1,26 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCAFC-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugBoxValue : ICorDebugHeapValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsValid(out int pbValid);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateRelocBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetObject([MarshalAs(UnmanagedType.Interface)] out ICorDebugObjectValue ppObject);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugBreakpoint.cs

@@ -0,0 +1,16 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAE8-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugBreakpoint
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Activate([In] int bActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsActive(out int pbActive);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugBreakpointEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCB03-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1), ComConversionLoss]
+    public interface ICorDebugBreakpointEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr breakpoints, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugChain.cs

@@ -0,0 +1,36 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCAEE-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugChain
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetThread([MarshalAs(UnmanagedType.Interface)] out ICorDebugThread ppThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStackRange(out ulong pStart, out ulong pEnd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetContext([MarshalAs(UnmanagedType.Interface)] out ICorDebugContext ppContext);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCaller([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCallee([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetPrevious([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNext([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsManaged(out int pManaged);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateFrames([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrameEnum ppFrames);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetActiveFrame([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRegisterSet([MarshalAs(UnmanagedType.Interface)] out ICorDebugRegisterSet ppRegisters);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetReason(out CorDebugChainReason pReason);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugChainEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCB08-8A68-11D2-983C-0000F808342D"), ComConversionLoss]
+    public interface ICorDebugChainEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out, MarshalAs(UnmanagedType.LPArray)] ICorDebugChain[] chains, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugClass.cs

@@ -0,0 +1,18 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAF5-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugClass
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetModule([MarshalAs(UnmanagedType.Interface)] out ICorDebugModule pModule);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetToken(out uint pTypeDef);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStaticFieldValue([In] uint fieldDef, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugFrame pFrame, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugClass2.cs

@@ -0,0 +1,16 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("B008EA8D-7AB1-43F7-BB20-FBB5A04038AE"), InterfaceType((short) 1)]
+    public interface ICorDebugClass2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetParameterizedType([In] uint elementType, [In] uint nTypeArgs, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugType ppTypeArgs, [MarshalAs(UnmanagedType.Interface)] out ICorDebugType ppType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetJMCStatus([In] int bIsJustMyCode);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugCode.cs

@@ -0,0 +1,30 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAF4-8A68-11D2-983C-0000F808342D"), ComConversionLoss]
+    public interface ICorDebugCode
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsIL(out int pbIL);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunction([MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pStart);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pcBytes);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([In] uint offset, [MarshalAs(UnmanagedType.Interface)] out ICorDebugFunctionBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCode([In] uint startOffset, [In] uint endOffset, [In] uint cBufferAlloc, [Out] IntPtr buffer, out uint pcBufferSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVersionNumber(out uint nVersion);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetILToNativeMapping([In] uint cMap, out uint pcMap, [Out] IntPtr map);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetEnCRemapSequencePoints([In] uint cMap, out uint pcMap, [Out] IntPtr offsets);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugCodeEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ComConversionLoss, InterfaceType((short) 1), Guid("55E96461-9645-45E4-A2FF-0367877ABCDE")]
+    public interface ICorDebugCodeEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr values, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugContext.cs

@@ -0,0 +1,34 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCB00-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugContext : ICorDebugObjectValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetClass([MarshalAs(UnmanagedType.Interface)] out ICorDebugClass ppClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFieldValue([In, MarshalAs(UnmanagedType.Interface)] ICorDebugClass pClass, [In] uint fieldDef, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVirtualMethod([In] uint memberRef, [MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetContext([MarshalAs(UnmanagedType.Interface)] out ICorDebugContext ppContext);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsValueClass(out int pbIsValueClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetManagedCopy([MarshalAs(UnmanagedType.IUnknown)] out object ppObject);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetFromManagedCopy([In, MarshalAs(UnmanagedType.IUnknown)] object pObject);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugController.cs

@@ -0,0 +1,32 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("3D6F5F62-7538-11D3-8D5B-00104B35E7EF"), InterfaceType((short) 1)]
+    public interface ICorDebugController
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Stop([In] uint dwTimeoutIgnored);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Continue([In] int fIsOutOfBand);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsRunning(out int pbRunning);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void HasQueuedCallbacks([In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pThread, out int pbQueued);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateThreads([MarshalAs(UnmanagedType.Interface)] out ICorDebugThreadEnum ppThreads);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetAllThreadsDebugState([In] CorDebugThreadState state, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pExceptThisThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Detach();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Terminate([In] uint exitCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CanCommitChanges([In] uint cSnapshots, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugEditAndContinueSnapshot pSnapshots, [MarshalAs(UnmanagedType.Interface)] out ICorDebugErrorInfoEnum pError);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CommitChanges([In] uint cSnapshots, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugEditAndContinueSnapshot pSnapshots, [MarshalAs(UnmanagedType.Interface)] out ICorDebugErrorInfoEnum pError);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugEditAndContinueSnapshot.cs

@@ -0,0 +1,26 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("6DC3FA01-D7CB-11D2-8A95-0080C792E5D8"), InterfaceType((short) 1)]
+    public interface ICorDebugEditAndContinueSnapshot
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CopyMetaData([In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, out Guid pMvid);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetMvid(out Guid pMvid);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRoDataRVA(out uint pRoDataRVA);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRwDataRVA(out uint pRwDataRVA);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetPEBytes([In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetILMap([In] uint mdFunction, [In] uint cMapSize, [In] ref _COR_IL_MAP map);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetPESymbolBytes([In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugEnum.cs

@@ -0,0 +1,20 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCB01-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugErrorInfoEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ComConversionLoss, Guid("F0E18809-72B5-11D2-976F-00A0C9B4D50C"), InterfaceType((short) 1)]
+    public interface ICorDebugErrorInfoEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr errors, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugEval.cs

@@ -0,0 +1,32 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCAF6-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugEval
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CallFunction([In, MarshalAs(UnmanagedType.Interface)] ICorDebugFunction pFunction, [In] uint nArgs, [In, MarshalAs(UnmanagedType.LPArray)] ICorDebugValue[] ppArgs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NewObject([In, MarshalAs(UnmanagedType.Interface)] ICorDebugFunction pConstructor, [In] uint nArgs, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugValue ppArgs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NewObjectNoConstructor([In, MarshalAs(UnmanagedType.Interface)] ICorDebugClass pClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NewString([In, MarshalAs(UnmanagedType.LPWStr)] string @string);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NewArray([In] uint elementType, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugClass pElementClass, [In] uint rank, [In] ref uint dims, [In] ref uint lowBounds);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsActive(out int pbActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Abort();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetResult([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppResult);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetThread([MarshalAs(UnmanagedType.Interface)] out ICorDebugThread ppThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateValue([In] uint elementType, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugClass pElementClass, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugEval2.cs

@@ -0,0 +1,26 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("FB0D9CE7-BE66-4683-9D32-A42A04E2FD91"), InterfaceType((short) 1)]
+    public interface ICorDebugEval2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CallParameterizedFunction([In, MarshalAs(UnmanagedType.Interface)] ICorDebugFunction pFunction, [In] uint nTypeArgs, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugType ppTypeArgs, [In] uint nArgs, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugValue ppArgs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateValueForType([In, MarshalAs(UnmanagedType.Interface)] ICorDebugType pType, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NewParameterizedObject([In, MarshalAs(UnmanagedType.Interface)] ICorDebugFunction pConstructor, [In] uint nTypeArgs, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugType ppTypeArgs, [In] uint nArgs, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugValue ppArgs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NewParameterizedObjectNoConstructor([In, MarshalAs(UnmanagedType.Interface)] ICorDebugClass pClass, [In] uint nTypeArgs, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugType ppTypeArgs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NewParameterizedArray([In, MarshalAs(UnmanagedType.Interface)] ICorDebugType pElementType, [In] uint rank, [In] ref uint dims, [In] ref uint lowBounds);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NewStringWithLength([In, MarshalAs(UnmanagedType.LPWStr)] string @string, [In] uint uiLength);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RudeAbort();
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugFrame.cs

@@ -0,0 +1,28 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAEF-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugFrame
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetChain([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCode([MarshalAs(UnmanagedType.Interface)] out ICorDebugCode ppCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunction([MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunctionToken(out uint pToken);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStackRange(out ulong pStart, out ulong pEnd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCaller([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCallee([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateStepper([MarshalAs(UnmanagedType.Interface)] out ICorDebugStepper ppStepper);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugFrameEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), ComConversionLoss, Guid("CC7BCB07-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugFrameEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out, MarshalAs(UnmanagedType.LPArray)] ICorDebugFrame[] frames, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugFunction.cs

@@ -0,0 +1,28 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAF3-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugFunction
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetModule([MarshalAs(UnmanagedType.Interface)] out ICorDebugModule ppModule);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetClass([MarshalAs(UnmanagedType.Interface)] out ICorDebugClass ppClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetToken(out uint pMethodDef);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetILCode([MarshalAs(UnmanagedType.Interface)] out ICorDebugCode ppCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNativeCode([MarshalAs(UnmanagedType.Interface)] out ICorDebugCode ppCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugFunctionBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLocalVarSigToken(out uint pmdSig);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCurrentVersionNumber(out uint pnCurrentVersion);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugFunction2.cs

@@ -0,0 +1,20 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("EF0C490B-94C3-4E4D-B629-DDC134C532D8")]
+    public interface ICorDebugFunction2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetJMCStatus([In] int bIsJustMyCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetJMCStatus(out int pbIsJustMyCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateNativeCode([MarshalAs(UnmanagedType.Interface)] out ICorDebugCodeEnum ppCodeEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVersionNumber(out uint pnVersion);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugFunctionBreakpoint.cs

@@ -0,0 +1,20 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAE9-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugFunctionBreakpoint : ICorDebugBreakpoint
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Activate([In] int bActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsActive(out int pbActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunction([MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetOffset(out uint pnOffset);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugGenericValue.cs

@@ -0,0 +1,24 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCAF8-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugGenericValue : ICorDebugValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetValue([Out] IntPtr pTo);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetValue([In] IntPtr pFrom);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugHandleValue.cs

@@ -0,0 +1,34 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("029596E8-276B-46A1-9821-732E96BBB00B"), InterfaceType((short) 1)]
+    public interface ICorDebugHandleValue : ICorDebugReferenceValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsNull(out int pbNull);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetValue(out ulong pValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetValue([In] ulong value);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Dereference([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DereferenceStrong([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetHandleType(out CorDebugHandleType pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Dispose();
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugHeapValue.cs

@@ -0,0 +1,24 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCAFA-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugHeapValue : ICorDebugValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsValid(out int pbValid);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateRelocBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugHeapValue2.cs

@@ -0,0 +1,14 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("E3AC4D6C-9CB7-43E6-96CC-B21540E5083C"), InterfaceType((short) 1)]
+    public interface ICorDebugHeapValue2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateHandle([In] CorDebugHandleType type, [MarshalAs(UnmanagedType.Interface)] out ICorDebugHandleValue ppHandle);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugILFrame.cs

@@ -0,0 +1,46 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("03E26311-4F76-11D3-88C6-006097945418"), InterfaceType((short) 1)]
+    public interface ICorDebugILFrame : ICorDebugFrame
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetChain([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCode([MarshalAs(UnmanagedType.Interface)] out ICorDebugCode ppCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunction([MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunctionToken(out uint pToken);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStackRange(out ulong pStart, out ulong pEnd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCaller([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCallee([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateStepper([MarshalAs(UnmanagedType.Interface)] out ICorDebugStepper ppStepper);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetIP(out uint pnOffset, out CorDebugMappingResult pMappingResult);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetIP([In] uint nOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateLocalVariables([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueEnum ppValueEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLocalVariable([In] uint dwIndex, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateArguments([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueEnum ppValueEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetArgument([In] uint dwIndex, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStackDepth(out uint pDepth);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStackValue([In] uint dwIndex, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CanSetIP([In] uint nOffset);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugILFrame2.cs

@@ -0,0 +1,16 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("5D88A994-6C30-479B-890F-BCEF88B129A5"), InterfaceType((short) 1)]
+    public interface ICorDebugILFrame2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemapFunction([In] uint newILOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateTypeParameters([MarshalAs(UnmanagedType.Interface)] out ICorDebugTypeEnum ppTyParEnum);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugInternalFrame.cs

@@ -0,0 +1,30 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("B92CC7F7-9D2D-45C4-BC2B-621FCC9DFBF4"), InterfaceType((short) 1)]
+    public interface ICorDebugInternalFrame : ICorDebugFrame
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetChain([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCode([MarshalAs(UnmanagedType.Interface)] out ICorDebugCode ppCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunction([MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunctionToken(out uint pToken);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStackRange(out ulong pStart, out ulong pEnd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCaller([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCallee([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateStepper([MarshalAs(UnmanagedType.Interface)] out ICorDebugStepper ppStepper);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFrameType(out CorDebugInternalFrameType pType);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugMDA.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ComConversionLoss, InterfaceType((short) 1), Guid("CC726F2F-1DB7-459B-B0EC-05F01D841B42")]
+    public interface ICorDebugMDA
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetDescription([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetXML([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFlags([In] ref CorDebugMDAFlags pFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetOSThreadId(out uint pOsTid);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugManagedCallback.cs

@@ -0,0 +1,64 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("3D6F5F60-7538-11D3-8D5B-00104B35E7EF")]
+    public interface ICorDebugManagedCallback
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Breakpoint([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void StepComplete([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pStepper, [In] CorDebugStepReason reason);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Break([In] IntPtr pAppDomain, [In] IntPtr thread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Exception([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] int unhandled);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EvalComplete([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pEval);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EvalException([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pEval);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateProcess([In] IntPtr pProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ExitProcess([In] IntPtr pProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateThread([In] IntPtr pAppDomain, [In] IntPtr thread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ExitThread([In] IntPtr pAppDomain, [In] IntPtr thread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void LoadModule([In] IntPtr pAppDomain, [In] IntPtr pModule);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UnloadModule([In] IntPtr pAppDomain, [In] IntPtr pModule);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void LoadClass([In] IntPtr pAppDomain, [In] IntPtr c);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UnloadClass([In] IntPtr pAppDomain, [In] IntPtr c);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DebuggerError([In] IntPtr pProcess, [In, MarshalAs(UnmanagedType.Error)] int errorHR, [In] uint errorCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void LogMessage([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] int lLevel, [In] IntPtr pLogSwitchName, [In] IntPtr pMessage);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void LogSwitch([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] int lLevel, [In] uint ulReason, [In] IntPtr pLogSwitchName, [In] IntPtr pParentName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateAppDomain([In] IntPtr pProcess, [In] IntPtr pAppDomain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ExitAppDomain([In] IntPtr pProcess, [In] IntPtr pAppDomain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void LoadAssembly([In] IntPtr pAppDomain, [In] IntPtr pAssembly);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UnloadAssembly([In] IntPtr pAppDomain, [In] IntPtr pAssembly);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ControlCTrap([In] IntPtr pProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void NameChange([In] IntPtr pAppDomain, [In] IntPtr pThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UpdateModuleSymbols([In] IntPtr pAppDomain, [In] IntPtr pModule, [In] IntPtr pSymbolStream);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EditAndContinueRemap([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pFunction, [In] int fAccurate);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void BreakpointSetError([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pBreakpoint, [In] uint dwError);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugManagedCallback2.cs

@@ -0,0 +1,28 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("250E5EEA-DB5C-4C76-B6F3-8C46F12E3203"), InterfaceType((short) 1)]
+    public interface ICorDebugManagedCallback2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void FunctionRemapOpportunity([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pOldFunction, [In] IntPtr pNewFunction, [In] uint oldILOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateConnection([In] IntPtr pProcess, [In] uint dwConnectionId, [In] ref ushort pConnName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ChangeConnection([In] IntPtr pProcess, [In] uint dwConnectionId);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DestroyConnection([In] IntPtr pProcess, [In] uint dwConnectionId);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Exception([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pFrame, [In] uint nOffset, [In] CorDebugExceptionCallbackType dwEventType, [In] uint dwFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ExceptionUnwind([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] CorDebugExceptionUnwindCallbackType dwEventType, [In] uint dwFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void FunctionRemapComplete([In] IntPtr pAppDomain, [In] IntPtr pThread, [In] IntPtr pFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void MDANotification([In] IntPtr pController, [In] IntPtr pThread, [In] IntPtr pMDA);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugModule.cs

@@ -0,0 +1,46 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("DBA2D8C1-E5C5-4069-8C13-10A7C6ABF43D"), InterfaceType((short) 1), ComConversionLoss]
+    public interface ICorDebugModule
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetProcess([MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetBaseAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAssembly([MarshalAs(UnmanagedType.Interface)] out ICorDebugAssembly ppAssembly);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnableJITDebugging([In] int bTrackJITInfo, [In] int bAllowJitOpts);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnableClassLoadCallbacks([In] int bClassLoadCallbacks);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunctionFromToken([In] uint methodDef, [MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunctionFromRVA([In] ulong rva, [MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetClassFromToken([In] uint typeDef, [MarshalAs(UnmanagedType.Interface)] out ICorDebugClass ppClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugModuleBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetEditAndContinueSnapshot([MarshalAs(UnmanagedType.Interface)] out ICorDebugEditAndContinueSnapshot ppEditAndContinueSnapshot);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetMetaDataInterface([In] ref Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppObj);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetToken(out uint pToken);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsDynamic(out int pDynamic);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetGlobalVariableValue([In] uint fieldDef, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pcBytes);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsInMemory(out int pInMemory);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugModule2.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("7FCC5FB5-49C0-41DE-9938-3B88B5B9ADD7"), InterfaceType((short) 1)]
+    public interface ICorDebugModule2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetJMCStatus([In] int bIsJustMyCode, [In] uint cTokens, [In] ref uint pTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ApplyChanges([In] uint cbMetadata, [In, MarshalAs(UnmanagedType.LPArray)] byte[] pbMetadata, [In] uint cbIL, [In, MarshalAs(UnmanagedType.LPArray)] byte[] pbIL);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetJITCompilerFlags([In] uint dwFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetJITCompilerFlags(out uint pdwFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ResolveAssembly([In] uint tkAssemblyRef, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugAssembly ppAssembly);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugModuleBreakpoint.cs

@@ -0,0 +1,18 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAEA-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugModuleBreakpoint : ICorDebugBreakpoint
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Activate([In] int bActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsActive(out int pbActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetModule([MarshalAs(UnmanagedType.Interface)] out ICorDebugModule ppModule);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugModuleEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), ComConversionLoss, Guid("CC7BCB09-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugModuleEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr modules, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugNativeFrame.cs

@@ -0,0 +1,46 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("03E26314-4F76-11D3-88C6-006097945418"), InterfaceType((short) 1)]
+    public interface ICorDebugNativeFrame : ICorDebugFrame
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetChain([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCode([MarshalAs(UnmanagedType.Interface)] out ICorDebugCode ppCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunction([MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFunctionToken(out uint pToken);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStackRange(out ulong pStart, out ulong pEnd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCaller([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCallee([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateStepper([MarshalAs(UnmanagedType.Interface)] out ICorDebugStepper ppStepper);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetIP(out uint pnOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetIP([In] uint nOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRegisterSet([MarshalAs(UnmanagedType.Interface)] out ICorDebugRegisterSet ppRegisters);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLocalRegisterValue([In] CorDebugRegister reg, [In] uint cbSigBlob, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint pvSigBlob, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLocalDoubleRegisterValue([In] CorDebugRegister highWordReg, [In] CorDebugRegister lowWordReg, [In] uint cbSigBlob, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint pvSigBlob, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLocalMemoryValue([In] ulong address, [In] uint cbSigBlob, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint pvSigBlob, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLocalRegisterMemoryValue([In] CorDebugRegister highWordReg, [In] ulong lowWordAddress, [In] uint cbSigBlob, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint pvSigBlob, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLocalMemoryRegisterValue([In] ulong highWordAddress, [In] CorDebugRegister lowWordRegister, [In] uint cbSigBlob, [In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint pvSigBlob, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CanSetIP([In] uint nOffset);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugObjectEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCB02-8A68-11D2-983C-0000F808342D"), ComConversionLoss]
+    public interface ICorDebugObjectEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr objects, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugObjectValue.cs

@@ -0,0 +1,34 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("18AD3D6E-B7D2-11D2-BD04-0000F80849BD"), InterfaceType((short) 1)]
+    public interface ICorDebugObjectValue : ICorDebugValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetClass([MarshalAs(UnmanagedType.Interface)] out ICorDebugClass ppClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFieldValue([In, MarshalAs(UnmanagedType.Interface)] ICorDebugClass pClass, [In] uint fieldDef, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVirtualMethod([In] uint memberRef, [MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetContext([MarshalAs(UnmanagedType.Interface)] out ICorDebugContext ppContext);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsValueClass(out int pbIsValueClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetManagedCopy([MarshalAs(UnmanagedType.IUnknown)] out object ppObject);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetFromManagedCopy([In, MarshalAs(UnmanagedType.IUnknown)] object pObject);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugObjectValue2.cs

@@ -0,0 +1,14 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("49E4A320-4A9B-4ECA-B105-229FB7D5009F"), InterfaceType((short) 1)]
+    public interface ICorDebugObjectValue2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVirtualMethodAndType([In] uint memberRef, [MarshalAs(UnmanagedType.Interface)] out ICorDebugFunction ppFunction, [MarshalAs(UnmanagedType.Interface)] out ICorDebugType ppType);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugProcess.cs

@@ -0,0 +1,66 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("3D6F5F64-7538-11D3-8D5B-00104B35E7EF"), ComConversionLoss]
+    public interface ICorDebugProcess : ICorDebugController
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Stop([In] uint dwTimeoutIgnored);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Continue([In] int fIsOutOfBand);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsRunning(out int pbRunning);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void HasQueuedCallbacks([In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pThread, out int pbQueued);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateThreads([MarshalAs(UnmanagedType.Interface)] out ICorDebugThreadEnum ppThreads);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetAllThreadsDebugState([In] CorDebugThreadState state, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pExceptThisThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Detach();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Terminate([In] uint exitCode);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CanCommitChanges([In] uint cSnapshots, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugEditAndContinueSnapshot pSnapshots, [MarshalAs(UnmanagedType.Interface)] out ICorDebugErrorInfoEnum pError);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CommitChanges([In] uint cSnapshots, [In, MarshalAs(UnmanagedType.Interface)] ref ICorDebugEditAndContinueSnapshot pSnapshots, [MarshalAs(UnmanagedType.Interface)] out ICorDebugErrorInfoEnum pError);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetID(out uint pdwProcessId);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetHandle([ComAliasName("DebuggerInterop.Core.long")] out uint phProcessHandle);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetThread([In] uint dwThreadId, [MarshalAs(UnmanagedType.Interface)] out ICorDebugThread ppThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateObjects([MarshalAs(UnmanagedType.Interface)] out ICorDebugObjectEnum ppObjects);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsTransitionStub([In] ulong address, out int pbTransitionStub);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsOSSuspended([In] uint threadID, out int pbSuspended);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetThreadContext([In] uint threadID, [In] uint contextSize, [In, Out] IntPtr context);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetThreadContext([In] uint threadID, [In] uint contextSize, [In] IntPtr context);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ReadMemory([In] ulong address, [In] uint size, [Out] IntPtr buffer, [ComAliasName("DebuggerInterop.Core.ULONG_PTR")] out uint read);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void WriteMemory([In] ulong address, [In] uint size, [In] ref byte buffer, [ComAliasName("DebuggerInterop.Core.ULONG_PTR")] out uint written);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ClearCurrentException([In] uint threadID);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnableLogMessages([In] int fOnOff);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ModifyLogSwitch([In] ref ushort pLogSwitchName, [In] int lLevel);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateAppDomains([MarshalAs(UnmanagedType.Interface)] out ICorDebugAppDomainEnum ppAppDomains);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetObject([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppObject);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ThreadForFiberCookie([In] uint fiberCookie, [MarshalAs(UnmanagedType.Interface)] out ICorDebugThread ppThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetHelperThreadID(out uint pThreadID);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugProcess2.cs

@@ -0,0 +1,26 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("AD1B3588-0EF0-4744-A496-AA09A9F80371"), ComConversionLoss]
+    public interface ICorDebugProcess2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetThreadForTaskID([In] ulong taskid, [MarshalAs(UnmanagedType.Interface)] out ICorDebugThread2 ppThread);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVersion(out _COR_VERSION version);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetUnmanagedBreakpoint([In] ulong address, [In] uint bufsize, [Out] IntPtr buffer, out uint bufLen);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ClearUnmanagedBreakpoint([In] ulong address);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetDesiredNGENCompilerFlags([In] uint pdwFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetDesiredNGENCompilerFlags(out uint pdwFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetReferenceValueFromGCHandle([In, ComAliasName("DebuggerInterop.Core.UINT_PTR")] uint handle, [MarshalAs(UnmanagedType.Interface)] out ICorDebugReferenceValue pOutValue);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugProcessEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCB05-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1), ComConversionLoss]
+    public interface ICorDebugProcessEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr processes, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugReferenceValue.cs

@@ -0,0 +1,30 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAF9-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugReferenceValue : ICorDebugValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsNull(out int pbNull);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetValue(out ulong pValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetValue([In] ulong value);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Dereference([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DereferenceStrong([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugRegisterSet.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCB0B-8A68-11D2-983C-0000F808342D"), ComConversionLoss, InterfaceType((short) 1)]
+    public interface ICorDebugRegisterSet
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRegistersAvailable(out ulong pAvailable);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRegisters([In] ulong mask, [In] uint regCount, [Out] IntPtr regBuffer);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetRegisters([In] ulong mask, [In] uint regCount, [In] ref ulong regBuffer);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetThreadContext([In] uint contextSize, [In, Out] IntPtr context);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetThreadContext([In] uint contextSize, [In] IntPtr context);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugStepper.cs

@@ -0,0 +1,28 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCAEC-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugStepper
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsActive(out int pbActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Deactivate();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetInterceptMask([In] CorDebugIntercept mask);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetUnmappedStopMask([In] CorDebugUnmappedStop mask);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Step([In] int bStepIn);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void StepRange([In] int bStepIn, [In] IntPtr ranges, [In] uint cRangeCount);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void StepOut();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetRangeIL([In] int bIL);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugStepper2.cs

@@ -0,0 +1,14 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("C5B6E9C3-E7D1-4A8E-873B-7F047F0706F7")]
+    public interface ICorDebugStepper2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetJMC([In] int fIsJMCStepper);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugStepperEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), ComConversionLoss, Guid("CC7BCB04-8A68-11D2-983C-0000F808342D")]
+    public interface ICorDebugStepperEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr steppers, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugStringValue.cs

@@ -0,0 +1,28 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("CC7BCAFD-8A68-11D2-983C-0000F808342D"), ComConversionLoss]
+    public interface ICorDebugStringValue : ICorDebugHeapValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsValid(out int pbValid);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateRelocBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLength(out uint pcchString);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetString([In] uint cchString, out uint pcchString, [Out] IntPtr szString);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugThread.cs

@@ -0,0 +1,44 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("938C6D66-7FB6-4F69-B389-425B8987329B")]
+    public interface ICorDebugThread
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetProcess([MarshalAs(UnmanagedType.Interface)] out ICorDebugProcess ppProcess);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetID(out uint pdwThreadId);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetHandle([ComAliasName("DebuggerInterop.Core.long")] out uint phThreadHandle);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAppDomain([MarshalAs(UnmanagedType.Interface)] out ICorDebugAppDomain ppAppDomain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetDebugState([In] CorDebugThreadState state);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetDebugState(out CorDebugThreadState pState);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetUserState(out CorDebugUserState pState);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCurrentException([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppExceptionObject);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ClearCurrentException();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateStepper([MarshalAs(UnmanagedType.Interface)] out ICorDebugStepper ppStepper);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateChains([MarshalAs(UnmanagedType.Interface)] out ICorDebugChainEnum ppChains);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetActiveChain([MarshalAs(UnmanagedType.Interface)] out ICorDebugChain ppChain);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetActiveFrame([MarshalAs(UnmanagedType.Interface)] out ICorDebugFrame ppFrame);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRegisterSet([MarshalAs(UnmanagedType.Interface)] out ICorDebugRegisterSet ppRegisters);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateEval([MarshalAs(UnmanagedType.Interface)] out ICorDebugEval ppEval);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetObject([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppObject);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugThread2.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("2BD956D9-7B07-4BEF-8A98-12AA862417C5"), ComConversionLoss]
+    public interface ICorDebugThread2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetActiveFunctions([In] uint cFunctions, out uint pcFunctions, [In, Out] IntPtr pFunctions);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetConnectionID(out uint pdwConnectionId);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetTaskID(out ulong pTaskId);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVolatileOSThreadID(out uint pdwTid);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void InterceptCurrentException([In, MarshalAs(UnmanagedType.Interface)] ICorDebugFrame pFrame);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugThreadEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ComConversionLoss, Guid("CC7BCB06-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugThreadEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr threads, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugType.cs

@@ -0,0 +1,26 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("D613F0BB-ACE1-4C19-BD72-E4C08D5DA7F5"), InterfaceType((short) 1)]
+    public interface ICorDebugType
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint ty);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetClass([MarshalAs(UnmanagedType.Interface)] out ICorDebugClass ppClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumerateTypeParameters([MarshalAs(UnmanagedType.Interface)] out ICorDebugTypeEnum ppTyParEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFirstTypeParameter([MarshalAs(UnmanagedType.Interface)] out ICorDebugType value);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetBase([MarshalAs(UnmanagedType.Interface)] out ICorDebugType pBase);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetStaticFieldValue([In] uint fieldDef, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugFrame pFrame, [MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRank(out uint pnRank);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugTypeEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ComConversionLoss, Guid("10F27499-9DF2-43CE-8333-A321D7C99CB4"), InterfaceType((short) 1)]
+    public interface ICorDebugTypeEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr values, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugUnmanagedCallback.cs

@@ -0,0 +1,14 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("5263E909-8CB5-11D3-BD2F-0000F80849BD"), InterfaceType((short) 1)]
+    public interface ICorDebugUnmanagedCallback
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DebugEvent([In, ComAliasName("DebuggerInterop.Core.ULONG_PTR")] uint pDebugEvent, [In] int fOutOfBand);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugValue.cs

@@ -0,0 +1,20 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCAF7-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugValue
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetType(out uint pType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSize(out uint pSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetAddress(out ulong pAddress);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CreateBreakpoint([MarshalAs(UnmanagedType.Interface)] out ICorDebugValueBreakpoint ppBreakpoint);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugValue2.cs

@@ -0,0 +1,14 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("5E0B54E7-D88A-4626-9420-A691E0A78B49"), InterfaceType((short) 1)]
+    public interface ICorDebugValue2
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetExactType([MarshalAs(UnmanagedType.Interface)] out ICorDebugType ppType);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugValueBreakpoint.cs

@@ -0,0 +1,18 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCAEB-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1)]
+    public interface ICorDebugValueBreakpoint : ICorDebugBreakpoint
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Activate([In] int bActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsActive(out int pbActive);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetValue([MarshalAs(UnmanagedType.Interface)] out ICorDebugValue ppValue);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ICorDebugValueEnum.cs

@@ -0,0 +1,22 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("CC7BCB0A-8A68-11D2-983C-0000F808342D"), InterfaceType((short) 1), ComConversionLoss]
+    public interface ICorDebugValueEnum : ICorDebugEnum
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Skip([In] uint celt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Reset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out ICorDebugEnum ppEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCount(out uint pcelt);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Next([In] uint celt, [Out] IntPtr values, out uint pceltFetched);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/ISequentialStream.cs

@@ -0,0 +1,16 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("0C733A30-2A1C-11CE-ADE5-00AA0044773D"), InterfaceType((short) 1)]
+    public interface ISequentialStream
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteRead(out byte pv, [In] uint cb, out uint pcbRead);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteWrite([In] ref byte pv, [In] uint cb, out uint pcbWritten);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/IStream.cs

@@ -0,0 +1,34 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("0000000C-0000-0000-C000-000000000046")]
+    public interface IStream : ISequentialStream
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteRead(out byte pv, [In] uint cb, out uint pcbRead);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteWrite([In] ref byte pv, [In] uint cb, out uint pcbWritten);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteSeek([In] _LARGE_INTEGER dlibMove, [In] uint dwOrigin, out _ULARGE_INTEGER plibNewPosition);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetSize([In] _ULARGE_INTEGER libNewSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteCopyTo([In, MarshalAs(UnmanagedType.Interface)] IStream pstm, [In] _ULARGE_INTEGER cb, out _ULARGE_INTEGER pcbRead, out _ULARGE_INTEGER pcbWritten);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Commit([In] uint grfCommitFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Revert();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void LockRegion([In] _ULARGE_INTEGER libOffset, [In] _ULARGE_INTEGER cb, [In] uint dwLockType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UnlockRegion([In] _ULARGE_INTEGER libOffset, [In] _ULARGE_INTEGER cb, [In] uint dwLockType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Stat(out tagSTATSTG pstatstg, [In] uint grfStatFlag);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out IStream ppstm);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/_COR_IL_MAP.cs

@@ -0,0 +1,14 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=4)]
+    public struct _COR_IL_MAP
+    {
+        public uint oldOffset;
+        public uint newOffset;
+        public int fAccurate;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/_COR_VERSION.cs

@@ -0,0 +1,15 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=4)]
+    public struct _COR_VERSION
+    {
+        public uint dwMajor;
+        public uint dwMinor;
+        public uint dwBuild;
+        public uint dwSubBuild;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/_FILETIME.cs

@@ -0,0 +1,13 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=4)]
+    public struct _FILETIME
+    {
+        public uint dwLowDateTime;
+        public uint dwHighDateTime;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/_LARGE_INTEGER.cs

@@ -0,0 +1,12 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=8)]
+    public struct _LARGE_INTEGER
+    {
+        public long QuadPart;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/_SECURITY_ATTRIBUTES.cs

@@ -0,0 +1,14 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=4)]
+    public struct _SECURITY_ATTRIBUTES
+    {
+        public uint nLength;
+        public IntPtr lpSecurityDescriptor;
+        public int bInheritHandle;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/_ULARGE_INTEGER.cs

@@ -0,0 +1,12 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=8)]
+    public struct _ULARGE_INTEGER
+    {
+        public ulong QuadPart;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/Core/tagSTATSTG.cs

@@ -0,0 +1,23 @@
+namespace DebuggerInterop.Core
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=8)]
+    public struct tagSTATSTG
+    {
+        [MarshalAs(UnmanagedType.LPWStr)]
+        public string pwcsName;
+        public uint type;
+        public _ULARGE_INTEGER cbSize;
+        public _FILETIME mtime;
+        public _FILETIME ctime;
+        public _FILETIME atime;
+        public uint grfMode;
+        public uint grfLocksSupported;
+        public Guid clsid;
+        public uint grfStateBits;
+        public uint reserved;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/MetaData/COR_FIELD_OFFSET.cs

@@ -0,0 +1,13 @@
+namespace DebuggerInterop.MetaData
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=4)]
+    public struct COR_FIELD_OFFSET
+    {
+        public uint ridOfField;
+        public uint ulOffset;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/DebuggerInterop/MetaData/IMetaDataImport.cs

@@ -0,0 +1,136 @@
+namespace DebuggerInterop.MetaData
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("7DAC8207-D3AE-4C75-9B67-92801A497D44"), ComConversionLoss]
+    public interface IMetaDataImport
+    {
+        [PreserveSig, MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CloseEnum(IntPtr hEnum);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CountEnum(IntPtr hEnum, ref uint pulCount);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ResetEnum(IntPtr hEnum, uint ulPos);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumTypeDefs(ref IntPtr phEnum, ref uint rTypeDefs, uint cMax, ref uint pcTypeDefs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumInterfaceImpls(ref IntPtr phEnum, uint td, ref uint rImpls, uint cMax, ref uint pcImpls);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumTypeRefs(ref IntPtr phEnum, ref uint rTypeRefs, uint cMax, ref uint pcTypeRefs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void FindTypeDefByName([In, MarshalAs(UnmanagedType.LPWStr)] string szTypeDef, [In] uint tkEnclosingClass, out uint ptd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetScopeProps([Out, MarshalAs(UnmanagedType.LPWStr)] string szName, [In] uint cchName, out uint pchName, out Guid pmvid);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetModuleFromScope(out uint pmd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetTypeDefProps([In] uint td, [Out] IntPtr szTypeDef, [In] uint cchTypeDef, out uint pchTypeDef, out uint pdwTypeDefFlags, out uint ptkExtends);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetInterfaceImplProps([In] uint iiImpl, out uint pClass, out uint ptkIface);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetTypeRefProps([In] uint tr, out uint ptkResolutionScope, [Out] IntPtr szName, [In] uint cchName, out uint pchName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ResolveTypeRef(uint tr, ref Guid riid, [MarshalAs(UnmanagedType.IUnknown)] ref object ppIScope, ref uint ptd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumMembers([In] ref IntPtr phEnum, [In] uint cl, out uint rMembers, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumMembersWithName([In, Out] ref IntPtr phEnum, [In] uint cl, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, out uint rMembers, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumMethods([In] ref IntPtr phEnum, [In] uint cl, out uint rMethods, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumMethodsWithName([In] ref IntPtr phEnum, [In] uint cl, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, out uint rMethods, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumFields([In, Out] ref IntPtr phEnum, [In] uint cl, out uint rFields, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumFieldsWithName([In, Out] ref IntPtr phEnum, [In] uint cl, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, out uint rFields, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumParams([In] ref IntPtr phEnum, [In] uint mb, out uint rParams, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumMemberRefs([In] ref IntPtr phEnum, [In] uint tkParent, out uint rMemberRefs, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumMethodImpls([In, Out] ref IntPtr phEnum, [In] uint td, out uint rMethodBody, out uint rMethodDecl, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumPermissionSets([In, Out] ref IntPtr phEnum, [In] uint tk, [In] uint dwActions, out uint rPermission, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void FindMember([In] uint td, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, [In] ref byte pvSigBlob, [In] uint cbSigBlob, out uint pmb);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void FindMethod([In] uint td, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, [In] ref byte pvSigBlob, [In] uint cbSigBlob, out uint pmb);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void FindField([In] uint td, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, [In] ref byte pvSigBlob, [In] uint cbSigBlob, out uint pmb);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void FindMemberRef([In] uint td, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, [In] ref byte pvSigBlob, [In] uint cbSigBlob, out uint pmr);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetMethodProps([In] uint mb, out uint pClass, [Out] IntPtr szMethod, [In] uint cchMethod, out uint pchMethod, out uint pdwAttr, [Out] IntPtr ppvSigBlob, out uint pcbSigBlob, out uint pulCodeRVA, out uint pdwImplFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetMemberRefProps([In] uint mr, out uint ptk, [Out, MarshalAs(UnmanagedType.LPWStr)] string szMember, [In] uint cchMember, out uint pchMember, [Out] IntPtr ppvSigBlob, out uint pbSig);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumProperties([In] ref IntPtr phEnum, [In] uint td, out uint rProperties, [In] uint cMax, out uint pcProperties);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumEvents([In, Out] ref IntPtr phEnum, [In] uint td, out uint rEvents, [In] uint cMax, out uint pcEvents);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetEventProps([In] uint ev, out uint pClass, [Out, MarshalAs(UnmanagedType.LPWStr)] string szEvent, [In] uint cchEvent, out uint pchEvent, out uint pdwEventFlags, out uint ptkEventType, out uint pmdAddOn, out uint pmdRemoveOn, out uint pmdFire, out uint rmdOtherMethod, [In] uint cMax, out uint pcOtherMethod);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumMethodSemantics([In, Out] ref IntPtr phEnum, [In] uint mb, out uint rEventProp, [In] uint cMax, out uint pcEventProp);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetMethodSemantics([In] uint mb, [In] uint tkEventProp, out uint pdwSemanticsFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetClassLayout([In] uint td, out uint pdwPackSize, out COR_FIELD_OFFSET rFieldOffset, [In] uint cMax, out uint pcFieldOffset, out uint pulClassSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFieldMarshal([In] uint tk, [Out] IntPtr ppvNativeType, out uint pcbNativeType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRVA([In] uint tk, out uint pulCodeRVA, out uint pdwImplFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetPermissionSetProps([In] uint pm, out uint pdwAction, out IntPtr ppvPermission, out uint pcbPermission);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSigFromToken([In] uint mdSig, [Out] IntPtr ppvSig, out uint pcbSig);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetModuleRefProps([In] uint mur, [Out, MarshalAs(UnmanagedType.LPWStr)] string szName, [In] uint cchName, out uint pchName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumModuleRefs([In, Out] ref IntPtr phEnum, out uint rModuleRefs, [In] uint cMax, out uint pcModuleRefs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetTypeSpecFromToken([In] uint typespec, [Out] IntPtr ppvSig, out uint pcbSig);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNameFromToken([In] uint tk, [Out] IntPtr pszUtf8NamePtr);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumUnresolvedMethods([In, Out] ref IntPtr phEnum, out uint rMethods, [In] uint cMax, out uint pcTokens);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetUserString([In] uint stk, [Out, MarshalAs(UnmanagedType.LPWStr)] string szString, [In] uint cchString, out uint pchString);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetPinvokeMap([In] uint tk, out uint pdwMappingFlags, [Out, MarshalAs(UnmanagedType.LPWStr)] string szImportName, [In] uint cchImportName, out uint pchImportName, out uint pmrImportDLL);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumSignatures([In, Out] ref IntPtr phEnum, out uint rSignatures, [In] uint cMax, out uint pcSignatures);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumTypeSpecs([In, Out] ref IntPtr phEnum, out uint rTypeSpecs, [In] uint cMax, out uint pcTypeSpecs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumUserStrings([In, Out] ref IntPtr phEnum, out uint rStrings, [In] uint cMax, out uint pcStrings);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetParamForMethodIndex([In] uint md, [In] uint ulParamSeq, [In] ref uint ppd);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void EnumCustomAttributes([In, Out] ref IntPtr phEnum, [In] uint tk, [In] uint tkType, out uint rCustomAttributes, [In] uint cMax, out uint pcCustomAttributes);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCustomAttributeProps([In] uint cv, out uint ptkObj, out uint ptkType, out IntPtr ppBlob, out uint pcbSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void FindTypeRef([In] uint tkResolutionScope, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, out uint ptr);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetMemberProps([In] uint mb, out uint pClass, [In, MarshalAs(UnmanagedType.LPWStr)] string szMember, [In] uint cchMember, out uint pchMember, out uint pdwAttr, [Out] IntPtr ppvSigBlob, out uint pcbSigBlob, out uint pulCodeRVA, out uint pdwImplFlags, out uint pdwCPlusTypeFlag, out IntPtr ppValue, out uint pcchValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetFieldProps([In] uint mb, out uint pClass, [In] IntPtr szField, [In] uint cchField, out uint pchField, out uint pdwAttr, [Out] IntPtr ppvSigBlob, out uint pcbSigBlob, out uint pdwCPlusTypeFlag, out IntPtr ppValue, out uint pcchValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetPropertyProps([In] uint prop, out uint pClass, [Out, MarshalAs(UnmanagedType.LPWStr)] string szProperty, [In] uint cchProperty, out uint pchProperty, out uint pdwPropFlags, [Out] IntPtr ppvSig, out uint pbSig, out uint pdwCPlusTypeFlag, out IntPtr ppDefaultValue, out uint pcchDefaultValue, out uint pmdSetter, out uint pmdGetter, out uint rmdOtherMethod, [In] uint cMax, out uint pcOtherMethod);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetParamProps([In] uint tk, out uint pmd, out uint pulSequence, [Out] IntPtr szName, [In] uint cchName, out uint pchName, out uint pdwAttr, out uint pdwCPlusTypeFlag, [Out] IntPtr ppValue, out uint pcchValue);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCustomAttributeByName([In] uint tkObj, [In, MarshalAs(UnmanagedType.LPWStr)] string szName, out IntPtr ppData, out uint pcbData);
+        [PreserveSig, MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        int IsValidToken(uint tk);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNestedClassProps([In] uint tdNestedClass, out uint ptdEnclosingClass);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNativeCallConvFromSig([In] IntPtr pvSig, [In] uint cbSig, out uint pCallConv);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void IsGlobal([In] uint pd, out int pbGlobal);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Interop/Project/README.TXT

@@ -1,7 +0,0 @@
-Debugger.Core and Debugger.Interop are the two libraries that hold most core debugging functionality. 
-
-The vast majority of the code of these libraries was written by me without any modifications made by other people. If you could preserve this ratio by not making any modifications, I would be extremely pleased and I would be indebted to you.
-
-However, if you find a bug or if you have an idea or suggestion, please do send me an e-mail to dsrbecky@gmail.com
-
-Thank you very much, David Srbecky

src/AddIns/Misc/Debugger/Debugger.Interop/Project/Src/AssemblyInfo.il

@@ -1,32 +0,0 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt">2002-2005 AlphaSierraPapa</copyright>
-//     <license see="prj:///doc/license.txt">GNU General Public License</license>
-//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
-//     <version>$Revision$</version>
-// </file>
-
-// Metadata version: v2.0.50215
-.assembly extern mscorlib
-{
-  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
-  .ver 2:0:0:0
-}
-.assembly Debugger.Interop
-{
-  .custom instance void [mscorlib]System.Runtime.InteropServices.ImportedFromTypeLibAttribute::.ctor(string) = ( 01 00 08 43 4F 52 44 42 4C 69 62 00 00 )          // ...CORDBLib..
-  .custom instance void [mscorlib]System.Runtime.InteropServices.GuidAttribute::.ctor(string) = ( 01 00 24 35 33 64 31 33 36 32 30 2D 66 34 31 37   // ..$53d13620-f417
-                                                                                                  2D 31 31 64 31 2D 39 37 36 32 2D 61 36 33 38 32   // -11d1-9762-a6382
-                                                                                                  36 61 34 66 32 35 35 00 00 )                      // 6a4f255..
-  .custom instance void [mscorlib]System.Runtime.InteropServices.TypeLibVersionAttribute::.ctor(int32,
-                                                                                                int32) = ( 01 00 01 00 00 00 00 00 00 00 00 00 ) 
-  .hash algorithm 0x00008004
-  .ver 2:0:0:0
-}
-.module CORDBLib.dll
-// MVID: {0F507CC5-B630-4DED-BC39-27191862A333}
-.imagebase 0x00400000
-.file alignment 0x00001000
-.stackreserve 0x00100000
-.subsystem 0x0003       // WINDOWS_CUI
-.corflags 0x00000001    //  ILONLY
-// Image base: 0x00F30000