internal bool AddBreakpoint(DnModule module) { foreach (var bp in rawBps) { if (bp.Module == module) return true; } var func = module.CorModule.GetFunctionFromToken(Token); if (func == null) return false; var ilCode = func.ILCode; if (ilCode == null) return false; var funcBp = ilCode.CreateBreakpoint(ILOffset); if (funcBp == null) return false; var modIlBp = new ModuleILCodeBreakpoint(module, funcBp); rawBps.Add(modIlBp); funcBp.IsActive = IsEnabled; return true; }
internal bool AddBreakpoint(DnModule module) { foreach (var bp in rawBps) { if (bp.Module == module) return true; } var c = code; if (c == null) { var func = module.CorModule.GetFunctionFromToken(Token); if (func == null) return false; c = GetCode(func); } else { if (GetModule(code) != module.DnModuleId) return false; } if (c == null) return false; var funcBp = c.CreateBreakpoint(Offset); if (funcBp == null) return false; var modIlBp = new ModuleCodeBreakpoint(module, funcBp); rawBps.Add(modIlBp); funcBp.IsActive = IsEnabled; return true; }
internal bool AddBreakpoint(DnModule module) { var func = module.CorModule.GetFunctionFromToken(Token); if (func == null) { return(false); } var ilCode = func.ILCode; if (ilCode == null) { return(false); } var funcBp = ilCode.CreateBreakpoint(ILOffset); if (funcBp == null) { return(false); } var modIlBp = new ModuleILCodeBreakpoint(module, funcBp); rawBps.Add(modIlBp); funcBp.IsActive = IsEnabled; return(true); }
public void UnloadClass(DnModule dnModule, uint token) { Debug.WriteLine(string.Format("Class unloaded: 0x{0:X8} {1}", token, dnModule.CorModuleDef)); Debug.Assert(dnModule.CorModuleDef != null); if (dnModule.CorModuleDef == null) return; // Nothing to do }
internal void RemoveModule(DnModule module) { foreach (var bp in rawBps.ToArray()) { if (bp.Module == module) { rawBps.Remove(bp); } } }
public void LoadClass(DnModule dnModule, uint token) { Debug.Assert(dnModule.CorModuleDef != null); if (dnModule.CorModuleDef == null) return; HashSet<uint> hash; if (!loadedClasses.TryGetValue(dnModule, out hash)) loadedClasses.Add(dnModule, hash = new HashSet<uint>()); hash.Add(token); }
internal void RemoveModule(DnModule module) { for (int i = rawBps.Count - 1; i >= 0; i--) { if (rawBps[i].Module == module) { rawBps.RemoveAt(i); } } }
internal void AddBreakpoint(DnModule module) { var newError = AddBreakpointCore(module); if (newError != error) { error = newError; ErrorChanged?.Invoke(this, EventArgs.Empty); } }
public DnSpyFile LoadModule(DnModule module, bool canLoadDynFile) { if (module == null) return null; if (UseMemoryModules || module.IsDynamic || module.IsInMemory) return InMemoryModuleManager.Instance.LoadFile(module, canLoadDynFile); var file = InMemoryModuleManager.Instance.FindFile(module); if (file != null) return file; var serMod = module.SerializedDnModule.ToSerializedDnSpyModule(); return LoadModule(serMod, canLoadDynFile); }
public DebuggerModule(Debugger debugger, DnModule mod) { debugger.Dispatcher.VerifyAccess(); this.debugger = debugger; this.mod = mod; hashCode = mod.GetHashCode(); uniqueId = mod.UniqueId; name = mod.Name; address = mod.Address; size = mod.Size; var moduleId = mod.DnModuleId; this.moduleId = new ModuleId(moduleId.AssemblyFullName, moduleId.ModuleName, moduleId.IsDynamic, moduleId.IsInMemory, moduleId.ModuleNameOnly); }
DnCodeBreakpointError AddBreakpointCore(DnModule module) { foreach (var bp in rawBps) { if (bp.Module == module) { return(DnCodeBreakpointError.None); } } var c = code; if (c == null) { var func = module.CorModule.GetFunctionFromToken(Token); if (func == null) { return(DnCodeBreakpointError.FunctionNotFound); } c = GetCode(func); } else { if (c.Function?.Module != module.CorModule) { return(DnCodeBreakpointError.OtherError); } } if (c == null) { return(DnCodeBreakpointError.FunctionNotFound); } var funcBp = c.CreateBreakpoint(Offset); if (funcBp == null) { return(DnCodeBreakpointError.CouldNotCreateBreakpoint); } var modIlBp = new ModuleCodeBreakpoint(module, funcBp); rawBps.Add(modIlBp); funcBp.IsActive = IsEnabled; return(DnCodeBreakpointError.None); }
internal bool AddBreakpoint(DnModule module) { foreach (var bp in rawBps) { if (bp.Module == module) { return(true); } } var c = code; if (c == null) { var func = module.CorModule.GetFunctionFromToken(Token); if (func == null) { return(false); } c = GetCode(func); } else { if (GetModule(code) != module.SerializedDnModule) { return(false); } } if (c == null) { return(false); } var funcBp = c.CreateBreakpoint(Offset); if (funcBp == null) { return(false); } var modIlBp = new ModuleCodeBreakpoint(module, funcBp); rawBps.Add(modIlBp); funcBp.IsActive = IsEnabled; return(true); }
public DnSpyFile FindFile(DnModule dnModule) { if (dnModule == null) return null; if (dnModule.IsDynamic) return FindDynamic(dnModule); // It could be a CorModuleDefFile if LoadFromMemory() failed and called LoadDynamic() return (DnSpyFile)FindMemory(dnModule) ?? FindDynamic(dnModule); }
void OnUnloadClass(DnModule dnModule, CorClass cls) { if (dnModule == null || !dnModule.IsDynamic || cls == null) return; var cmd = dnModule.CorModuleDef; if (cmd == null) return; Debug.Assert(classLoader != null); if (classLoader == null) return; classLoader.UnloadClass(dnModule, cls.Token); }
internal void ModuleUnloaded(DnModule module) { module.SetHasUnloaded(); modules.Remove(module.CorModule.RawObject); }
internal void CorModuleDefCreated(DnModule module) { DebugVerifyThread(); Debug.Assert(module.CorModuleDef != null); if (OnCorModuleDefCreated != null) OnCorModuleDefCreated(this, new CorModuleDefCreatedEventArgs(module, module.CorModuleDef)); }
public DebuggerModule(Debugger debugger, DnModule mod) { debugger.Dispatcher.VerifyAccess(); this.debugger = debugger; this.mod = mod; this.hashCode = mod.GetHashCode(); this.uniqueId = mod.UniqueId; this.name = mod.Name; this.address = mod.Address; this.size = mod.Size; var serMod = mod.SerializedDnModule; this.moduleName = new ModuleName(serMod.AssemblyFullName, serMod.ModuleName, serMod.IsDynamic, serMod.IsInMemory, serMod.ModuleNameOnly); }
MemoryModuleDefFile FindMemory(DnModule dnModule) { if (dnModule == null) return null; var key = MemoryModuleDefFile.CreateKey(dnModule.Process, dnModule.Address); return AllMemoryModuleDefFiles.FirstOrDefault(a => key.Equals(a.Key)); }
CorModuleDefFile FindDynamic(DnModule dnModule) { if (dnModule == null) return null; var mod = dnModule.GetOrCreateCorModuleDef(); return AllCorModuleDefFiles.FirstOrDefault(a => a.ModuleDef == mod); }
public ModuleDebuggerEventArgs(DnModule module, bool added) { Module = module; Added = added; }
public ModuleILCodeBreakpoint(DnModule module, CorFunctionBreakpoint funcBp) { this.module = module; this.funcBp = funcBp; }
void CallOnModuleAdded(DnModule module, bool added) => OnModuleAdded?.Invoke(this, new ModuleDebuggerEventArgs(module, added));
internal void AddBreakpoint(DnModule module) => SetError(AddBreakpointCore(module));
public ModuleCodeBreakpoint(DnModule module, CorFunctionBreakpoint funcBp) { Module = module; FunctionBreakpoint = funcBp; }
public ModuleDebuggerEventArgs(DnModule module, bool added) { this.Module = module; this.Added = added; }
public DnSpyFile LoadFile(DnModule dnModule, bool canLoadDynFile) { if (dnModule == null) return null; if (dnModule.IsDynamic) return LoadDynamic(dnModule, canLoadDynFile); return LoadFromMemory(dnModule, canLoadDynFile); }
DnSpyFile LoadDynamic(DnModule dnModule, bool canLoadDynFile) { var file = FindDynamic(dnModule); if (file != null) return file; if (DebugManager.Instance.ProcessState != DebuggerProcessState.Stopped) return null; if (!canLoadDynFile) return null; var manifestDnModule = dnModule.Assembly.Modules[0]; var manifestKey = CorModuleDefFile.CreateKey(manifestDnModule); var manMod = FindAssemblyByKey(manifestKey); Debug.Assert(manMod == null); if (manMod != null) return null; manMod = FindDynamic(manifestDnModule); Debug.Assert(manMod == null); if (manMod != null) return null; var modules = manifestDnModule.Assembly.Modules; var dict = new Dictionary<ModuleDef, CorModuleDefFile>(modules.Length); foreach (var module in modules) { UpdateResolver(module.GetOrCreateCorModuleDef()); dict.Add(module.GetOrCreateCorModuleDef(), new CorModuleDefFile(dict, module, UseDebugSymbols)); } Initialize(dict.Select(a => a.Value.DnModule.CorModuleDef)); manMod = dict[manifestDnModule.CorModuleDef]; DnSpyFileList.AddFile(manMod, true, true, false); return dict[dnModule.CorModuleDef]; }
public abstract ModuleLoadOptions GetModuleLoadOptions(DnModule module);
DnSpyFile LoadFromMemory(DnModule dnModule, bool canLoadDynFile) { Debug.Assert(!dnModule.IsDynamic); if (dnModule.Address == 0) return null; var file = FindMemory(dnModule); if (file != null) return file; var manifestDnModule = dnModule.Assembly.Modules[0]; var manifestKey = MemoryModuleDefFile.CreateKey(manifestDnModule.Process, manifestDnModule.Address); var manMod = FindAssemblyByKey(manifestKey); Debug.Assert(manMod == null); if (manMod != null) return null; manMod = FindMemory(manifestDnModule); Debug.Assert(manMod == null); if (manMod != null) return null; var modules = manifestDnModule.Assembly.Modules; var dict = new Dictionary<ModuleDef, MemoryModuleDefFile>(modules.Length); var files = new List<MemoryModuleDefFile>(modules.Length); MemoryModuleDefFile result = null; foreach (var module in modules) { MemoryModuleDefFile mfile; try { mfile = MemoryModuleDefFile.Create(dict, module, UseDebugSymbols); UpdateResolver(mfile.ModuleDef); if (module == dnModule) result = mfile; } catch { // The PE headers and/or .NET headers are probably corrupt return LoadDynamic(dnModule, canLoadDynFile); } files.Add(mfile); dict.Add(mfile.ModuleDef, mfile); } Debug.Assert(result != null); if (files.Count == 0) return null; var asm = files[0].AssemblyDef; if (asm == null) { if (files.Count > 1) { asm = files[0].ModuleDef.UpdateRowId(new AssemblyDefUser("???")); asm.Modules.Add(files[0].ModuleDef); } } asm.Modules.Clear(); for (int i = 0; i < files.Count; i++) asm.Modules.Add(files[i].ModuleDef); DnSpyFileList.AddFile(files[0], true, true, false); return result; }
void RemoveModuleFromBreakpoints(DnModule module) { if (module == null) return; foreach (var bp in ilCodeBreakpointList.GetBreakpoints(module.DnModuleId)) bp.RemoveModule(module); foreach (var bp in nativeCodeBreakpointList.GetBreakpoints(module.DnModuleId)) bp.RemoveModule(module); }
public CorModuleDefCreatedEventArgs(DnModule module, CorModuleDef corModuleDef) { Module = module; CorModuleDef = corModuleDef; }
public CorModuleDefCreatedEventArgs(DnModule module, CorModuleDef corModuleDef) { this.Module = module; this.CorModuleDef = corModuleDef; }
bool VerifyDebugger(DnModule module) { if (module == null) return false; var dbg = DebugManager.Instance.Debugger; return module.Debugger == dbg; }
public CorModuleDefHelper(DnModule module) { this.module = module; Debug.Assert(!module.IsDynamic || module.Address == 0); }
void Remove(DnModule module) { bool b = VerifyDebugger(module); Debug.Assert(b); if (!b) return; for (int i = Collection.Count - 1; i >= 0; i--) { var vm = Collection[i]; if (vm.Module == module) { Collection.RemoveAt(i); return; } } Debug.Fail(string.Format("Module wasn't added to list: {0}", module)); }
public ModuleVM(DnModule module) { this.module = module; }
void RemoveModuleFromBreakpoints(DnModule module) { if (module == null) return; foreach (var bp in this.ilCodeBreakpointList.GetBreakpoints(module.SerializedDnModule)) bp.RemoveModule(module); }
void Add(DnModule module) { bool b = VerifyDebugger(module); Debug.Assert(b); if (!b) return; Collection.Add(new ModuleVM(module)); }
public IDsDocument LoadModule(DnModule module, bool canLoadDynFile, bool isAutoLoaded) { if (module == null) return null; if (UseMemoryModules || module.IsDynamic || module.IsInMemory) return inMemoryModuleService.Value.LoadDocument(module, canLoadDynFile); var file = inMemoryModuleService.Value.FindDocument(module); if (file != null) return file; var moduleId = module.DnModuleId; return LoadModule(moduleId.ToModuleId(), canLoadDynFile, diskFileOk: false, isAutoLoaded: isAutoLoaded); }
void OnModuleUnloaded(DnModule module) { module.Assembly.ModuleUnloaded(module); CallOnModuleAdded(module, false); RemoveModuleFromBreakpoints(module); }
bool VerifyDebugger(DnModule module) { if (module == null) return false; var dbg = theDebugger.Debugger; return module.Debugger == dbg; }
/// <summary> /// Re-add breakpoints to the module. Should be called if the debugged module has breakpoints /// in decrypted methods and the methods have now been decrypted. /// </summary> /// <param name="module"></param> public void AddBreakpoints(DnModule module) { foreach (var bp in ilCodeBreakpointList.GetBreakpoints(module.SerializedDnModule)) bp.AddBreakpoint(module); }
void CallOnModuleAdded(DnModule module, bool added) { if (OnModuleAdded != null) OnModuleAdded(this, new ModuleDebuggerEventArgs(module, added)); }
void OnModuleAdded(DnModule module) { // If an assembly is visible in the treeview, and a new netmodule gets added, add a // new netmodule node to the assembly in the treeview. var manifestModule = module.Assembly.Modules[0]; // If it's the manifest module, it can't possibly have been inserted in the treeview already if (manifestModule == module) return; // Update a dynamic assembly, if one exists { var manifestKey = CorModuleDefFile.CreateKey(manifestModule); var manifestFile = FindAssemblyByKey(manifestKey); var manifestNode = DnSpyFileListTreeNode.FindAssemblyNode(manifestFile); if (manifestNode != null) { var cmdf = (CorModuleDefFile)manifestFile; var moduleKey = CorModuleDefFile.CreateKey(module); manifestNode.EnsureChildrenFiltered(); Debug.Assert(manifestNode.Children.Count >= 1); var moduleNode = manifestNode.Children.OfType<AssemblyTreeNode>().FirstOrDefault(a => moduleKey.Equals(a.DnSpyFile.Key)); Debug.Assert(moduleNode == null); if (moduleNode == null) { var newFile = new CorModuleDefFile(cmdf.Dictionary, module, UseDebugSymbols); UpdateResolver(module.GetOrCreateCorModuleDef()); cmdf.Dictionary.Add(newFile.ModuleDef, newFile); Initialize(new[] { newFile.DnModule.CorModuleDef }); manifestNode.Children.Add(new AssemblyTreeNode(newFile)); } } } // Update an in-memory assembly, if one exists if (manifestModule.Address != 0 && module.Address != 0) { var manifestKey = MemoryModuleDefFile.CreateKey(manifestModule.Process, manifestModule.Address); var manifestFile = FindAssemblyByKey(manifestKey); var manifestNode = DnSpyFileListTreeNode.FindAssemblyNode(manifestFile); if (manifestNode != null) { var mmdf = (MemoryModuleDefFile)manifestFile; var moduleKey = MemoryModuleDefFile.CreateKey(module.Process, module.Address); manifestNode.EnsureChildrenFiltered(); Debug.Assert(manifestNode.Children.Count >= 1); var moduleNode = manifestNode.Children.OfType<AssemblyTreeNode>().FirstOrDefault(a => moduleKey.Equals(a.DnSpyFile.Key)); Debug.Assert(moduleNode == null); if (moduleNode == null) { MemoryModuleDefFile newFile = null; try { newFile = MemoryModuleDefFile.Create(mmdf.Dictionary, module, UseDebugSymbols); } catch { } Debug.Assert(newFile != null); if (newFile != null) { UpdateResolver(newFile.ModuleDef); mmdf.Dictionary.Add(newFile.ModuleDef, newFile); manifestNode.DnSpyFile.ModuleDef.Assembly.Modules.Add(newFile.ModuleDef); manifestNode.Children.Add(new AssemblyTreeNode(newFile)); } } } } }