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;
}
internal void ModuleUnloaded(DnModule module) {
module.SetHasUnloaded();
modules.Remove(module.CorModule.RawObject);
}
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);
}
public CorModuleDefHelper(DnModule module)
{
this.module = module;
Debug.Assert(!module.IsDynamic || module.Address == 0);
}
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));
}
}
}
}
}
