/// <summary> /// Finds a module of given MVID in one of the processes being debugged and returns its baseline metadata. /// Shall only be called while in debug mode. /// Shall only be called on MTA thread. /// </summary> public DebuggeeModuleInfo TryGetBaselineModuleInfo(Guid mvid) { Contract.ThrowIfFalse(Thread.CurrentThread.GetApartmentState() == ApartmentState.MTA); return(_baselineMetadata.GetOrAdd(mvid, m => { using (DebuggerComponent.ManagedEditAndContinueService()) { var clrModuleInstance = FindClrModuleInstance(m); if (clrModuleInstance == null) { return default; } if (!TryGetBaselineModuleInfo(clrModuleInstance, out var metadata, out var symReader)) { return default; } // hook up a callback on module unload (the call blocks until the message is processed): DkmCustomMessage.Create( Connection: clrModuleInstance.Process.Connection, Process: clrModuleInstance.Process, SourceId: DebuggerService.MessageSourceId, MessageCode: 0, Parameter1: this, Parameter2: clrModuleInstance).SendLower(); return new DebuggeeModuleInfo(metadata, symReader); }
private static bool ShouldEnableChildDebugging(DkmProcess process, DebugProcessOptions options) { if (options.ChildDebuggingMode == ChildDebuggingMode.AlwaysAttach) { return(true); } if (options.ChildDebuggingMode == ChildDebuggingMode.UseDefault) { Logger.LogInfo( "Requesting default child process debugging mode for process {0}.", process.UniqueId); DkmCustomMessage attachRequest = DkmCustomMessage.Create( process.Connection, process, PackageServices.VsPackageMessageGuid, (int)VsPackageMessage.IsChildDebuggingEnabled, process.UniqueId, process.Connection.UniqueId); // This needs to happen synchronously in order to guarantee that child debugging is enabled // before the process finishes initializing. attachRequest.SendToVsService(PackageServices.DkmComponentEventHandler, true); } return(false); }
private static bool ShouldEnable(DkmProcess process) { var message = DkmCustomMessage.Create( process.Connection, process, s_messageSourceId, MessageCode: 1, // Is legacy EE enabled? Parameter1: null, Parameter2: null); try { var reply = message.SendLower(); var result = (int)reply.Parameter1; // Possible values are 0 = false, 1 = true, 2 = not ready. // At this point, we should only get 0 or 1, but to be // safe, treat values other than 0 or 1 as false. Debug.Assert(result == 0 || result == 1); return(result == 0); } catch (NotImplementedException) { return(false); } }
/// <summary> /// Finds a module of given MVID in one of the processes being debugged and returns its baseline metadata. /// Shall only be called while in debug mode. /// </summary> public ModuleMetadata TryGetBaselineMetadata(Guid mvid) { return(_baselineMetadata.GetOrAdd(mvid, m => { using (DebuggerComponent.ManagedEditAndContinueService()) { var clrModuleInstance = FindClrModuleInstance(m); if (clrModuleInstance == null) { return default; } var metadata = GetBaselineModuleMetadata(clrModuleInstance); if (metadata == null) { return default; } // hook up a callback on module unload (the call blocks until the message is processed): DkmCustomMessage.Create( Connection: clrModuleInstance.Process.Connection, Process: clrModuleInstance.Process, SourceId: DebuggerService.MessageSourceId, MessageCode: 0, Parameter1: this, Parameter2: clrModuleInstance).SendLower(); return metadata; } })); }
public void StartDebugging(DebugSessionOptions options) { _debuggingService.OnBeforeDebuggingStateChanged(DebuggingState.Design, DebuggingState.Run); if ((options & DebugSessionOptions.EditAndContinueDisabled) == 0) { _encService = _workspace.Services.GetRequiredService <IEditAndContinueWorkspaceService>(); // hook up a callbacks (the call blocks until the message is processed): using (DebuggerComponent.ManagedEditAndContinueService()) { DkmCustomMessage.Create( Connection: null, Process: null, SourceId: DebuggerService.MessageSourceId, MessageCode: 0, Parameter1: _encService, Parameter2: null).SendLower(); } _encService.StartDebuggingSession(); } else { _encService = null; } }
DkmCustomMessage IDkmCustomMessageForwardReceiver.SendLower(DkmCustomMessage customMessage) { var process = customMessage.Process; if (customMessage.MessageCode == MessageToLocalWorker.fetchLuaSymbols) { var moduleUniqueId = new Guid(customMessage.Parameter1 as byte[]); var nativeModuleInstance = process.GetNativeRuntimeInstance().GetNativeModuleInstances().FirstOrDefault(el => el.UniqueId == moduleUniqueId); if (nativeModuleInstance == null) { return(null); } // Check if Lua library is loaded ulong luaNewState = AttachmentHelpers.TryGetFunctionAddress(nativeModuleInstance, "lua_newstate", out _).GetValueOrDefault(0); ulong luaLibNewState = AttachmentHelpers.TryGetFunctionAddress(nativeModuleInstance, "luaL_newstate", out _).GetValueOrDefault(0); if (luaNewState != 0 || luaLibNewState != 0) { var locations = new LuaLocationsMessage(); locations.luaExecuteAtStart = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaV_execute", out _).GetValueOrDefault(0); locations.luaExecuteAtEnd = AttachmentHelpers.TryGetFunctionAddressAtDebugEnd(nativeModuleInstance, "luaV_execute", out _).GetValueOrDefault(0); if (luaNewState != 0) { locations.luaNewStateAtStart = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "lua_newstate", out _).GetValueOrDefault(0); locations.luaNewStateAtEnd = AttachmentHelpers.TryGetFunctionAddressAtDebugEnd(nativeModuleInstance, "lua_newstate", out _).GetValueOrDefault(0); } else { locations.luaNewStateAtStart = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaL_newstate", out _).GetValueOrDefault(0); locations.luaNewStateAtEnd = AttachmentHelpers.TryGetFunctionAddressAtDebugEnd(nativeModuleInstance, "luaL_newstate", out _).GetValueOrDefault(0); } locations.luaClose = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "lua_close", out _).GetValueOrDefault(0); locations.closeState = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "close_state", out _).GetValueOrDefault(0); locations.luaLoadFileEx = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaL_loadfilex", out _).GetValueOrDefault(0); locations.luaLoadFile = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaL_loadfile", out _).GetValueOrDefault(0); locations.solCompatLoadFileEx = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "kp_compat53L_loadfilex", out _).GetValueOrDefault(0); locations.luaLoadBufferEx = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaL_loadbufferx", out _).GetValueOrDefault(0); locations.luaLoadBuffer = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaL_loadbuffer", out _).GetValueOrDefault(0); locations.luaLoad = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "lua_load", out _).GetValueOrDefault(0); locations.luaError = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaB_error", out _).GetValueOrDefault(0); locations.luaRunError = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaG_runerror", out _).GetValueOrDefault(0); locations.luaThrow = AttachmentHelpers.TryGetFunctionAddressAtDebugStart(nativeModuleInstance, "luaD_throw", out _).GetValueOrDefault(0); return(DkmCustomMessage.Create(process.Connection, process, MessageToLocal.guid, MessageToLocal.luaSymbols, locations.Encode(), null)); } } return(null); }
public void SendHigher(DkmProcess process) { var stream = new MemoryStream(); _serializer.WriteObject(stream, this); var message = DkmCustomMessage.Create(process.Connection, process, _sourceId, MessageCode, stream.ToArray(), null); message.SendHigher(); }
void IDkmModuleSymbolsLoadedNotification.OnModuleSymbolsLoaded(DkmModuleInstance moduleInstance, DkmModule module, bool isReload, DkmWorkList workList, DkmEventDescriptor eventDescriptor) { var process = moduleInstance.Process; var engines = process.DebugLaunchSettings.EngineFilter; if (engines == null || !engines.Contains(AD7Engine.DebugEngineGuid)) { return; } var pyrtInfo = process.GetPythonRuntimeInfo(); var nativeModuleInstance = moduleInstance as DkmNativeModuleInstance; if (nativeModuleInstance != null) { if (PythonDLLs.CTypesNames.Contains(moduleInstance.Name)) { pyrtInfo.DLLs.CTypes = nativeModuleInstance; var traceHelper = process.GetDataItem <TraceManagerLocalHelper>(); if (traceHelper != null) { traceHelper.OnCTypesLoaded(nativeModuleInstance); } } else if (PythonDLLs.GetPythonLanguageVersion(nativeModuleInstance) != PythonLanguageVersion.None) { if (IsModuleCompiledWithPGO(moduleInstance)) { pyrtInfo.DLLs.Python = null; var pgoWarnMsg = DkmCustomMessage.Create(process.Connection, process, Guid.Empty, (int)VsPackageMessage.WarnAboutPGO, moduleInstance.Name, null); pgoWarnMsg.SendToVsService(Guids.CustomDebuggerEventHandlerGuid, IsBlocking: true); return; } } } if (process.GetPythonRuntimeInstance() != null) { return; } if (pyrtInfo.DLLs.Python != null && pyrtInfo.DLLs.Python.HasSymbols()) { if (process.LivePart == null || pyrtInfo.DLLs.DebuggerHelper != null) { CreatePythonRuntimeInstance(process); } else { InjectHelperDll(process); } } }
public int OnCustomDebugEvent(ref Guid ProcessId, VsComponentMessage message) { try { VsPackageMessage code = (VsPackageMessage)message.MessageCode; switch (code) { case VsPackageMessage.AttachToChild: int parentId = (int)message.Parameter1; int childId = (int)message.Parameter2; Process proc = Process.GetProcessById(childId); if (proc != null) { DebugAttach.AttachToProcess(new Process[] { proc }, ChildDebuggingMode.AlwaysAttach); } break; case VsPackageMessage.IsChildDebuggingEnabled: Guid processGuid = (Guid)message.Parameter1; Guid connectionGuid = (Guid)message.Parameter2; DkmTransportConnection connection = DkmTransportConnection.FindConnection(connectionGuid); if (connection != null) { if (IsChildDebuggingEnabledByDefault) { DkmCustomMessage response = DkmCustomMessage.Create( connection, null, PackageServices.VsDebuggerMessageGuid, (int)VsDebuggerMessage.EnableChildProcessDebugging, processGuid, null ); response.SendLower(); } else { Logger.Log( "Not enabling child process debugging for process {0}. " + "Child debugging is disabled by default.", processGuid); } } break; } } catch (Exception exception) { Logger.LogException( exception, "An error occured while handling a VsPackage message. HR=0x{0:X}", exception.HResult); } return(0); }
/// <summary> /// Called by the debugger when a debugging session starts and managed debugging is being used. /// </summary> public void StartDebugging() { // Hook up a callbacks (the call blocks until the message is processed). using (DebuggerComponent.ManagedEditAndContinueService()) { DkmCustomMessage.Create( Connection: null, Process: null, SourceId: DebuggerService.MessageSourceId, MessageCode: 0, Parameter1: this, Parameter2: null).SendLower(); } _debuggingService.OnBeforeDebuggingStateChanged(DebuggingState.Design, DebuggingState.Run); _encService.StartDebuggingSession(); }
public DkmCustomMessage SendLower(DkmCustomMessage message) { object result; byte[] bytes; MessageCodes messageCode = (MessageCodes)message.MessageCode; try { bytes = (byte[])message.Parameter1; result = ProcessMessage(messageCode, bytes); } catch (Exception e) { result = e.ToString(); messageCode = MessageCodes.Exception; } bytes = MessageSerializer.Serialize(result); return(DkmCustomMessage.Create(message.Connection, message.Process, Guid.Empty, (int)messageCode, bytes, null)); }
void createProcessTracer_OnFunctionExited( DkmStackWalkFrame frame, StackFrameAnalyzer frameAnalyzer) { try { ulong processInfoAddr = Convert.ToUInt64( frameAnalyzer.GetArgumentValue(frame, "lpProcessInformation")); // Check the return address first, it should be in EAX. CreateProcessAsUser and // CreateProcess both return 0 on failure. If the function failed, there is no child to // attach to. if (0 == frame.VscxGetRegisterValue32(CpuRegister.Eax)) { return; } // The process was successfully created. Extract the PID from the PROCESS_INFORMATION // output param. An attachment request must happend through the EnvDTE, which can only // be accessed from the VsPackage, so a request must be sent via a component message. DkmProcess process = frame.Process; int size = Marshal.SizeOf(typeof(PROCESS_INFORMATION)); byte[] buffer = new byte[size]; process.ReadMemory(processInfoAddr, DkmReadMemoryFlags.None, buffer); PROCESS_INFORMATION info = MarshalUtility.ByteArrayToStructure <PROCESS_INFORMATION>(buffer); DkmCustomMessage attachRequest = DkmCustomMessage.Create( process.Connection, process, PackageServices.VsPackageMessageGuid, (int)VsPackageMessage.AttachToChild, process.LivePart.Id, info.dwProcessId); attachRequest.SendToVsService(PackageServices.DkmComponentEventHandler, false); } catch (Exception exception) { Logger.LogError( exception, "An error occured handling the exit breakpoint. HR = 0x{0:X}", exception.HResult); } }
/// <summary> /// Finds a module of given MVID in one of the processes being debugged and returns its baseline metadata. /// Shall only be called while in debug mode. /// Shall only be called on MTA thread. /// </summary> /// <returns>Null, if the module with the specified MVID is not found.</returns> public DebuggeeModuleInfo TryGetBaselineModuleInfo(Guid mvid) { Contract.ThrowIfFalse(Thread.CurrentThread.GetApartmentState() == ApartmentState.MTA); return(_baselineMetadata.GetOrAdd(mvid, m => { using (DebuggerComponent.ManagedEditAndContinueService()) { var clrModuleInstance = EnumerateClrModuleInstances(m).FirstOrDefault(); if (clrModuleInstance == null) { return null; } // The DebuggeeModuleInfo holds on a pointer to module metadata and on a SymReader instance. // // The module metadata lifetime is that of the module instance, so we need to stop using the module // as soon as the module instance is unloaded. We do so by associating a DataItem with the module // instance and removing the metadata from our cache when the DataItem is disposed. // // The SymReader instance is shared across all instancese of the module. if (!clrModuleInstance.TryGetModuleInfo(out var info)) { return null; } // hook up a callback on module unload (the call blocks until the message is processed): DkmCustomMessage.Create( Connection: clrModuleInstance.Process.Connection, Process: clrModuleInstance.Process, SourceId: DebuggerService.MessageSourceId, MessageCode: 0, Parameter1: this, Parameter2: clrModuleInstance).SendLower(); return info; }
public override void Handle(DkmProcess process) { if (process.LivePart == null) { // When debugging dumps, there's no stepping or live expression evaluation. Hence, we don't // need the helper DLL nor _ctypes.pyd for anything, and even if they are loaded in the dump, // we don't care about them at all. return; } var pyrtInfo = process.GetPythonRuntimeInfo(); var moduleInstance = process.GetNativeRuntimeInstance().GetNativeModuleInstances().Single(mi => mi.UniqueId == ModuleInstanceId); if (pyrtInfo.DLLs.CTypes == null && PythonDLLs.CTypesNames.Contains(moduleInstance.Name)) { moduleInstance.TryLoadSymbols(); if (moduleInstance.HasSymbols()) { pyrtInfo.DLLs.CTypes = moduleInstance; var traceHelper = process.GetDataItem <TraceManagerLocalHelper>(); if (traceHelper != null) { traceHelper.OnCTypesLoaded(moduleInstance); } } } if (process.GetPythonRuntimeInstance() != null) { return; } if (PythonDLLs.GetPythonLanguageVersion(moduleInstance) != PythonLanguageVersion.None) { pyrtInfo.DLLs.Python = moduleInstance; for (int i = 0; i < 2; ++i) { if (moduleInstance.HasSymbols()) { if (IsModuleCompiledWithPGO(moduleInstance)) { pyrtInfo.DLLs.Python = null; var pgoWarnMsg = DkmCustomMessage.Create(process.Connection, process, Guid.Empty, (int)VsPackageMessage.WarnAboutPGO, moduleInstance.Name, null); pgoWarnMsg.SendToVsService(Guids.CustomDebuggerEventHandlerGuid, IsBlocking: true); return; } if (process.LivePart == null) { // If debugging crash dumps, runtime can be created as soon as Python symbols are resolved. CreatePythonRuntimeInstance(process); } else { // If not, we need to check for debugger helper DLL as well, and inject it if it isn't there yet. if (pyrtInfo.DLLs.DebuggerHelper != null) { CreatePythonRuntimeInstance(process); } else { InjectHelperDll(process); } } return; } moduleInstance.TryLoadSymbols(); } var symWarnMsg = DkmCustomMessage.Create(process.Connection, process, Guid.Empty, (int)VsPackageMessage.WarnAboutPythonSymbols, moduleInstance.Name, null); symWarnMsg.SendToVsService(Guids.CustomDebuggerEventHandlerGuid, IsBlocking: true); } else if (PythonDLLs.DebuggerHelperNames.Contains(moduleInstance.Name)) { moduleInstance.TryLoadSymbols(); // When the module is reported is loaded, it is not necessarily fully initialized yet - it is possible to get into a state // where its import table is not processed yet. If we register TraceFunc and it gets called by Python when in that state, // we'll get a crash as soon as any imported WinAPI function is called. So check whether DllMain has already run - if it // is, we're good to go, and if not, set a breakpoint on a hook that will be called once it is run, and defer runtime // creation until that breakpoint is hit. bool isInitialized = moduleInstance.GetExportedStaticVariable <ByteProxy>("isInitialized").Read() != 0; if (isInitialized) { OnHelperDllInitialized(moduleInstance); } else { DkmRuntimeBreakpoint initBP = null; initBP = CreateRuntimeDllExportedFunctionBreakpoint(moduleInstance, "OnInitialized", (thread, frameBase, vFrame) => { initBP.Close(); OnHelperDllInitialized(moduleInstance); }); initBP.Enable(); } } }
void IDkmRuntimeBreakpointReceived.OnRuntimeBreakpointReceived(DkmRuntimeBreakpoint runtimeBreakpoint, DkmThread thread, bool hasException, DkmEventDescriptorS eventDescriptor) { var process = thread.Process; var processData = DebugHelpers.GetOrCreateDataItem <LuaRemoteProcessData>(process); if (runtimeBreakpoint.SourceId == Guids.luaSupportBreakpointGuid) { if (processData.locations != null) { if (runtimeBreakpoint.UniqueId == processData.locations.breakpointLuaHelperBreakpointHit) { // Breakpoint can get hit again after expression evaluation 'slips' the thread if (processData.pauseBreakpoints) { return; } eventDescriptor.Suppress(); var breakpointPos = DebugHelpers.ReadUintVariable(process, processData.locations.helperBreakHitIdAddress); if (!breakpointPos.HasValue) { return; } if (breakpointPos.Value < processData.activeBreakpoints.Count) { try { var breakpoint = processData.activeBreakpoints[(int)breakpointPos.Value]; if (breakpoint.runtimeBreakpoint != null) { breakpoint.runtimeBreakpoint.OnHit(thread, false); } } catch (System.ObjectDisposedException) { // Breakpoint was implicitly closed processData.activeBreakpoints.RemoveAt((int)breakpointPos.Value); } catch (DkmException) { // In case another component evaluates a function } } return; } else if (runtimeBreakpoint.UniqueId == processData.locations.breakpointLuaHelperStepComplete) { if (processData.activeStepper != null) { var activeStepper = processData.activeStepper; ClearStepperData(process, processData); activeStepper.OnStepComplete(thread, false); } return; } else if (runtimeBreakpoint.UniqueId == processData.locations.breakpointLuaHelperStepInto) { if (processData.activeStepper != null) { var activeStepper = processData.activeStepper; ClearStepperData(process, processData); activeStepper.OnStepComplete(thread, false); } return; } else if (runtimeBreakpoint.UniqueId == processData.locations.breakpointLuaHelperStepOut) { if (processData.activeStepper != null) { var activeStepper = processData.activeStepper; ClearStepperData(process, processData); activeStepper.OnStepComplete(thread, false); } return; } } thread.GetCurrentFrameInfo(out ulong retAddr, out ulong frameBase, out ulong vframe); var data = new SupportBreakpointHitMessage { breakpointId = runtimeBreakpoint.UniqueId, threadId = thread.UniqueId, retAddr = retAddr, frameBase = frameBase, vframe = vframe }; var message = DkmCustomMessage.Create(process.Connection, process, MessageToLocal.guid, MessageToLocal.luaSupportBreakpointHit, data.Encode(), null); var response = message.SendHigher(); if (response?.MessageCode == MessageToRemote.throwException) { if (runtimeBreakpoint is DkmRuntimeInstructionBreakpoint runtimeInstructionBreakpoint) { var exceptionInformation = DkmCustomExceptionInformation.Create(processData.runtimeInstance, Guids.luaExceptionGuid, thread, runtimeInstructionBreakpoint.InstructionAddress, "LuaError", 0, DkmExceptionProcessingStage.Thrown | DkmExceptionProcessingStage.UserVisible | DkmExceptionProcessingStage.Unhandled, null, new ReadOnlyCollection <byte>(response.Parameter1 as byte[])); exceptionInformation.OnDebugMonitorException(); } } } }
void IDkmProcessExecutionNotification.OnProcessPause(DkmProcess process, DkmProcessExecutionCounters processCounters) { try { ulong?moduleBaseOpt = DebugHelpers.ReadPointerVariable(process, "nullcModuleStartAddress"); // Check if nullc is available if (moduleBaseOpt == null) { return; } var processData = DebugHelpers.GetOrCreateDataItem <NullcRemoteProcessDataItem>(process); if (processData.language == null) { processData.compilerId = new DkmCompilerId(DebugHelpers.NullcCompilerGuid, DebugHelpers.NullcLanguageGuid); processData.language = DkmLanguage.Create("nullc", processData.compilerId); } // Create VM runtime and module if (processData.vmRuntimeInstance == null) { DkmRuntimeInstanceId runtimeId = new DkmRuntimeInstanceId(DebugHelpers.NullcVmRuntimeGuid, 0); processData.vmRuntimeInstance = DkmCustomRuntimeInstance.Create(process, runtimeId, null); } if (processData.vmModule == null) { DkmModuleId moduleId = new DkmModuleId(Guid.NewGuid(), DebugHelpers.NullcSymbolProviderGuid); processData.vmModule = DkmModule.Create(moduleId, "nullc.vm.code", processData.compilerId, process.Connection, null); } if (processData.vmModuleInstance == null) { DkmDynamicSymbolFileId symbolFileId = DkmDynamicSymbolFileId.Create(DebugHelpers.NullcSymbolProviderGuid); processData.vmModuleInstance = DkmCustomModuleInstance.Create("nullc_vm", "nullc.vm.code", 0, processData.vmRuntimeInstance, null, symbolFileId, DkmModuleFlags.None, DkmModuleMemoryLayout.Unknown, 0, 1, 0, "nullc vm code", false, null, null, null); processData.vmModuleInstance.SetModule(processData.vmModule, true); // Can use reload? } ulong moduleBase = moduleBaseOpt.GetValueOrDefault(0); uint moduleSize = (uint)(DebugHelpers.ReadPointerVariable(process, "nullcModuleEndAddress").GetValueOrDefault(0) - moduleBase); // Create JiT runtime and module if (moduleBase != 0 && moduleSize != 0) { if (processData.runtimeInstance == null && processData.nativeRuntimeInstance == null) { DkmRuntimeInstanceId runtimeId = new DkmRuntimeInstanceId(DebugHelpers.NullcRuntimeGuid, 0); if (DebugHelpers.useNativeInterfaces) { processData.nativeRuntimeInstance = DebugHelpers.useDefaultRuntimeInstance ? process.GetNativeRuntimeInstance() : DkmNativeRuntimeInstance.Create(process, runtimeId, DkmRuntimeCapabilities.None, process.GetNativeRuntimeInstance(), null); } else { processData.runtimeInstance = DkmCustomRuntimeInstance.Create(process, runtimeId, null); } } if (processData.module == null) { DkmModuleId moduleId = new DkmModuleId(Guid.NewGuid(), DebugHelpers.NullcSymbolProviderGuid); processData.module = DkmModule.Create(moduleId, "nullc.embedded.code", processData.compilerId, process.Connection, null); } if (processData.moduleInstance == null && processData.nativeModuleInstance == null) { DkmDynamicSymbolFileId symbolFileId = DkmDynamicSymbolFileId.Create(DebugHelpers.NullcSymbolProviderGuid); if (DebugHelpers.useNativeInterfaces) { processData.nativeModuleInstance = DkmNativeModuleInstance.Create("nullc", "nullc.embedded.code", 0, null, symbolFileId, DkmModuleFlags.None, DkmModuleMemoryLayout.Unknown, 1, "nullc embedded code", processData.nativeRuntimeInstance, moduleBase, moduleSize, Microsoft.VisualStudio.Debugger.Clr.DkmClrHeaderStatus.NativeBinary, false, null, null, null); processData.nativeModuleInstance.SetModule(processData.module, true); // Can use reload? } else { processData.moduleInstance = DkmCustomModuleInstance.Create("nullc", "nullc.embedded.code", 0, processData.runtimeInstance, null, symbolFileId, DkmModuleFlags.None, DkmModuleMemoryLayout.Unknown, moduleBase, 1, moduleSize, "nullc embedded code", false, null, null, null); processData.moduleInstance.SetModule(processData.module, true); // Can use reload? } } } // Update bytecode var moduleBytecodeVersion = DebugHelpers.ReadPointerVariable(process, "nullcModuleBytecodeVersion").GetValueOrDefault(0); if (processData.moduleBytecodeLocation != 0 && moduleBytecodeVersion != processData.moduleBytecodeVersion) { processData.moduleBytecodeLocation = 0; processData.moduleBytecodeSize = 0; processData.moduleBytecodeRaw = null; processData.bytecode = null; } if (processData.moduleBytecodeLocation == 0) { processData.moduleBytecodeLocation = DebugHelpers.ReadPointerVariable(process, "nullcModuleBytecodeLocation").GetValueOrDefault(0); processData.moduleBytecodeSize = DebugHelpers.ReadPointerVariable(process, "nullcModuleBytecodeSize").GetValueOrDefault(0); processData.moduleBytecodeVersion = moduleBytecodeVersion; if (processData.moduleBytecodeLocation != 0) { processData.moduleBytecodeRaw = new byte[processData.moduleBytecodeSize]; process.ReadMemory(processData.moduleBytecodeLocation, DkmReadMemoryFlags.None, processData.moduleBytecodeRaw); processData.bytecode = new NullcBytecode(); processData.bytecode.ReadFrom(processData.moduleBytecodeRaw, DebugHelpers.Is64Bit(process)); // Notify local component about bytecode update var message = DkmCustomMessage.Create(process.Connection, process, DebugHelpers.NullcReloadSymbolsMessageGuid, 1, null, null); message.SendHigher(); } } } catch (Exception ex) { Console.WriteLine("OnProcessPause failed with: " + ex.ToString()); } }