bool IsProgramModule(DnModule module)
{
if (module.IsDynamic || module.IsInMemory)
{
return(true);
}
var filename = module.Name;
if (!File.Exists(filename))
{
return(true);
}
if (GacInfo.IsGacPath(filename))
{
return(false);
}
var dnDebugger = module.Process.Debugger;
if (IsInDirOrSubDir(Path.GetDirectoryName(dnDebugger.CLRPath), filename))
{
return(false);
}
return(true);
}
void OnModuleAddedRemoved(DnModule module, bool added)
{
if (module.Address == 0 || module.Size == 0)
{
return;
}
var service = hexBufferFileServiceFactory.Create(debuggerHexBufferStreamProvider.Buffer);
int refCount;
var pos = new HexPosition(module.Address);
moduleReferences.TryGetValue(pos, out refCount);
if (added)
{
if (refCount == 0)
{
var tags = module.IsInMemory ?
new string[] { PredefinedBufferFileTags.FileLayout } :
new string[] { PredefinedBufferFileTags.MemoryLayout };
service.CreateFile(new HexSpan(module.Address, module.Size), module.Name, module.Name, tags);
}
refCount++;
}
else
{
if (refCount == 1)
{
service.RemoveFiles(new HexSpan(module.Address, module.Size));
}
refCount--;
}
moduleReferences[pos] = refCount;
}
public CorModuleDefFile(Dictionary <ModuleDef, CorModuleDefFile> dict, DnModule dnModule, bool loadSyms)
: base(dnModule.GetOrCreateCorModuleDef(), loadSyms)
{
this.dict = dict;
this.dnModule = dnModule;
this.lastValidRids = new LastValidRids();
}
public override ModuleLoadOptions GetModuleLoadOptions(DnModule module)
{
ModuleLoadOptions options = default;
bool suppressJITOptimization;
if (IsProgramModule(module))
{
suppressJITOptimization = suppressJITOptimization_ProgramModules;
}
else
{
suppressJITOptimization = suppressJITOptimization_SystemModules;
}
if (suppressJITOptimization)
{
options.JITCompilerFlags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DISABLE_OPTIMIZATION;
options.ModuleTrackJITInfo = true;
options.ModuleAllowJitOptimizations = false;
}
else
{
options.JITCompilerFlags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DEFAULT;
options.ModuleTrackJITInfo = false;
options.ModuleAllowJitOptimizations = true;
}
options.JustMyCode = IsJustMyCode(module);
return(options);
}
internal bool TryGetDnModule(DbgModule module, out DnModule dnModule) {
if (module.TryGetData(out DbgModuleData data) && data.Engine == this) {
dnModule = data.DnModule;
return true;
}
dnModule = null;
return false;
}
internal DmdDynamicModuleHelperImpl GetDynamicModuleHelper(DnModule dnModule) {
Debug.Assert(dnModule.IsDynamic);
lock (lockObj) {
if (!toDynamicModuleHelper.TryGetValue(dnModule.CorModule, out var helper))
toDynamicModuleHelper.Add(dnModule.CorModule, helper = new DmdDynamicModuleHelperImpl(this));
return helper;
}
}
IDnSpyFile LoadDynamic(DnModule dnModule, bool canLoadDynFile)
{
var file = FindDynamic(dnModule);
if (file != null)
{
return(file);
}
if (dnModule.Debugger.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);
var files = new List <CorModuleDefFile>(modules.Length);
foreach (var module in modules)
{
UpdateResolver(module.GetOrCreateCorModuleDef());
var newFile = new CorModuleDefFile(module, UseDebugSymbols);
dict.Add(module.GetOrCreateCorModuleDef(), newFile);
files.Add(newFile);
}
Debug.Assert(files.Count != 0);
Initialize(dnModule.Debugger, dict.Select(a => a.Value.DnModule.CorModuleDef));
var asmFile = CorModuleDefFile.CreateAssembly(files);
var addedFile = fileManager.GetOrAdd(asmFile);
Debug.Assert(addedFile == asmFile);
return(dict[dnModule.CorModuleDef]);
}
IDnSpyFile FindDynamic(DnModule dnModule)
{
if (dnModule == null)
{
return(null);
}
var mod = dnModule.GetOrCreateCorModuleDef();
return(AllCorModuleDefFiles.FirstOrDefault(a => a.ModuleDef == mod));
}
bool VerifyDebugger(DnModule module)
{
if (module == null)
{
return(false);
}
var dbg = DebugManager.Instance.Debugger;
return(module.Debugger == dbg);
}
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)));
}
bool VerifyDebugger(DnModule module)
{
if (module == null)
{
return(false);
}
var dbg = theDebugger.Debugger;
return(module.Debugger == dbg);
}
internal bool TryGetDnModuleAndVersion(DbgModule module, out DnModule dnModule, out int loadClassVersion) {
if (module.TryGetData(out DbgModuleData data) && data.Engine == this) {
dnModule = data.DnModule;
loadClassVersion = data.LoadClassVersion;
return true;
}
dnModule = null;
loadClassVersion = -1;
return false;
}
/// <summary>
/// Saves Assembly After Modifications
/// </summary>
public void SaveContext()
{
string NewPath = PathIs.Insert(PathIs.Length - 4, "HereWeGo"); // Thx 4 drakoniа#0601 for the insert trick :D
if (DnModule != null)
{
if (DnModule.IsILOnly)
{
var MangedWriter = new ModuleWriterOptions(DnModule)
{
Logger = DummyLogger.NoThrowInstance,
MetadataOptions = { Flags = MetadataFlags.PreserveAll }
};
DnModule.Write(NewPath.Replace("HereWeGo", "-DnLibed"), MangedWriter);
Log.Info("Done Saved Manged Dnlib Module");
}
else
{
var UnMangedWriter = new NativeModuleWriterOptions(DnModule, false)
{
Logger = DummyLogger.NoThrowInstance,
MetadataOptions = { Flags = MetadataFlags.PreserveAll }
};
DnModule.NativeWrite(NewPath.Replace("HereWeGo", "-DnLibed"), UnMangedWriter);
Log.Info("Done Saved Native Dnlib Module");
}
}
if (AsmModule != null)
{
var IMPEIB = new ManagedPEImageBuilder()
{
DotNetDirectoryFactory = new DotNetDirectoryFactory()
{
MetadataBuilderFlags = MetadataBuilderFlags.PreserveAll,
MethodBodySerializer = new CilMethodBodySerializer
{
ComputeMaxStackOnBuildOverride = false
}
}
};
var IR = IMPEIB.CreateImage(AsmModule);
var FBuilder = new ManagedPEFileBuilder();
var File = FBuilder.CreateFile(IR.ConstructedImage);
if (!IR.DiagnosticBag.IsFatal)
{
File.Write(NewPath.Replace("HereWeGo", "-AsmResolved")); // Ignore Errors.
}
else
{
AsmModule.Write(NewPath.Replace("HereWeGo", "-AsmResolved"), IMPEIB);
}
Log.Info("Done Saved AsmResolver Module");
}
}
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
}
void Add(DnModule module)
{
bool b = VerifyDebugger(module);
Debug.Assert(b);
if (!b)
{
return;
}
Collection.Add(new ModuleVM(module, moduleContext));
}
static DbgImageLayout CalculateImageLayout(DnModule dnModule)
{
if (dnModule.IsDynamic)
{
return(DbgImageLayout.Unknown);
}
if (dnModule.IsInMemory)
{
return(DbgImageLayout.File);
}
return(DbgImageLayout.Memory);
}
internal static bool ShowErrorIfDynamic(DnModule module)
{
if (module.IsDynamic && DebugManager.Instance.ProcessState != DebuggerProcessState.Stopped)
{
if (InMemoryModuleManager.Instance.LoadFile(module, false) == null)
{
MainWindow.Instance.ShowMessageBox("You must break the process before dynamic modules can be loaded.");
return(false);
}
}
return(true);
}
public IDnSpyFile 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(FindMemory(dnModule) ?? FindDynamic(dnModule));
}
public IDnSpyFile LoadFile(DnModule dnModule, bool canLoadDynFile)
{
if (dnModule == null)
{
return(null);
}
if (dnModule.IsDynamic)
{
return(LoadDynamic(dnModule, canLoadDynFile));
}
return(LoadFromMemory(dnModule, canLoadDynFile));
}
public IDsDocument LoadDocument(DnModule dnModule, bool canLoadDynFile)
{
if (dnModule == null)
{
return(null);
}
if (dnModule.IsDynamic)
{
return(LoadDynamic(dnModule, canLoadDynFile));
}
return(LoadFromMemory(dnModule, 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);
}
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);
}
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]);
}
static bool?CalculateIsOptimized(DnModule dnModule)
{
switch (dnModule.CachedJITCompilerFlags)
{
case CorDebugJITCompilerFlags.CORDEBUG_JIT_DEFAULT:
return(true);
case CorDebugJITCompilerFlags.CORDEBUG_JIT_DISABLE_OPTIMIZATION:
case CorDebugJITCompilerFlags.CORDEBUG_JIT_ENABLE_ENC:
return(false);
default:
Debug.Fail($"Unknown JIT compiler flags: {dnModule.CachedJITCompilerFlags}");
return(null);
}
}
static string GetModuleFilename(DnModule module)
{
if (module.IsDynamic)
{
return(null);
}
if (!module.IsInMemory)
{
return(DebugOutputUtils.GetFilename(module.Name));
}
if (module.CorModule.IsManifestModule)
{
return(DebugOutputUtils.GetFilename(new AssemblyNameInfo(module.Assembly.FullName).Name));
}
return(DebugOutputUtils.GetFilename(module.DnlibName));
}
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);
}
static void InitializeExeFields(DnModule dnModule, string filename, DbgImageLayout imageLayout, out bool isExe, out bool isDll, out DateTime?timestamp, out string version, out string assemblySimpleName)
{
isExe = false;
isDll = false;
timestamp = null;
version = null;
assemblySimpleName = null;
if (dnModule.IsDynamic)
{
if (dnModule.CorModule.IsManifestModule)
{
version = new AssemblyNameInfo(dnModule.Assembly.FullName).Version.ToString();
}
}
else if (dnModule.IsInMemory)
{
Debug.Assert(imageLayout == DbgImageLayout.File, nameof(GetFileVersion) + " assumes file layout");
var bytes = dnModule.Process.CorProcess.ReadMemory(dnModule.Address, (int)dnModule.Size);
if (bytes != null)
{
try {
version = GetFileVersion(bytes);
using (var peImage = new PEImage(bytes, imageLayout == DbgImageLayout.File ? ImageLayout.File : ImageLayout.Memory, true))
InitializeExeFieldsFrom(peImage, out isExe, out isDll, out timestamp, ref version, out assemblySimpleName);
}
catch {
}
}
}
else
{
try {
version = GetFileVersion(filename);
using (var peImage = new PEImage(filename))
InitializeExeFieldsFrom(peImage, out isExe, out isDll, out timestamp, ref version, out assemblySimpleName);
}
catch {
}
}
if (version == null)
{
version = string.Empty;
}
}
string GetModuleName(DnModule module)
{
if (module == null)
{
return("???");
}
if (module.IsInMemory)
{
return(module.Name);
}
try {
return(Path.GetFileName(module.Name));
}
catch {
}
return(module.Name);
}
static bool Save(DnModule module, string filename, byte[] buffer)
{
bool createdFile = false;
try {
using (var file = File.Create(filename)) {
createdFile = true;
ulong addr = module.CorModule.Address;
ulong sizeLeft = module.CorModule.Size;
while (sizeLeft > 0)
{
int bytesToRead = sizeLeft <= (ulong)buffer.Length ? (int)sizeLeft : buffer.Length;
int bytesRead;
int hr = module.Process.CorProcess.ReadMemory(addr, buffer, 0, bytesToRead, out bytesRead);
if (hr < 0)
{
MainWindow.Instance.ShowMessageBox(string.Format("Failed to save '{0}'\nERROR: {1:X8}", filename, hr));
return(false);
}
if (bytesRead == 0)
{
MainWindow.Instance.ShowMessageBox(string.Format("Failed to save '{0}'\nERROR: Could not read any data", filename));
return(false);
}
file.Write(buffer, 0, bytesRead);
addr += (ulong)bytesRead;
sizeLeft -= (ulong)bytesRead;
}
return(true);
}
}
catch (Exception ex) {
MainWindow.Instance.ShowMessageBox(string.Format("Failed to save '{0}'\nERROR: {1}", filename, ex.Message));
if (createdFile && File.Exists(filename))
{
try {
File.Delete(filename);
} catch { }
}
return(false);
}
}
// When a dynamic assembly is created with option Run, a module gets created and its
// metadata name is "RefEmit_InMemoryManifestModule". Shortly thereafter, its name
// gets changed to the name the user chose.
// This name is also saved in ModuleIds, and used when setting breakpoints...
// There's code that caches ModuleIds, but they don't cache it if IsDynamic is true.
// This method updates the ModuleId and resets breakpoints in the module.
void UpdateDynamicModuleIds(DnModule dnModule) {
debuggerThread.VerifyAccess();
if (!dnModule.IsDynamic)
return;
var module = TryGetModule(dnModule.CorModule);
if (module == null || !TryGetModuleData(module, out var data) || data.HasUpdatedModuleId)
return;
List<(DbgModule dbgModule, DnModule dnModule)> updatedModules = null;
lock (lockObj) {
if (toAssemblyModules.TryGetValue(dnModule.Assembly, out var modules)) {
for (int i = 0; i < modules.Count; i++) {
dnModule = modules[i];
if (!dnModule.IsDynamic)
continue;
if (!toEngineModule.TryGetValue(dnModule.CorModule, out var em))
continue;
if (!TryGetModuleData(em.Module, out data))
continue;
dnModule.CorModule.ClearCachedDnlibName();
var moduleId = dnModule.DnModuleId.ToModuleId();
if (data.ModuleId == moduleId)
continue;
data.UpdateModuleId(moduleId);
if (dnModule.CorModuleDef != null) {
//TODO: This doesn't update the treeview node
dnModule.CorModuleDef.Name = moduleId.ModuleName;
}
if (updatedModules == null)
updatedModules = new List<(DbgModule, DnModule)>();
updatedModules.Add((em.Module, dnModule));
}
}
}
if (updatedModules != null) {
foreach (var info in updatedModules) {
var mdi = info.dnModule.CorModule.GetMetaDataInterface<IMetaDataImport2>();
var scopeName = MDAPI.GetModuleName(mdi) ?? string.Empty;
((DbgCorDebugInternalModuleImpl)info.dbgModule.InternalModule).ReflectionModule.ScopeName = scopeName;
}
dbgModuleMemoryRefreshedNotifier.RaiseModulesRefreshed(updatedModules.Select(a => a.dbgModule).ToArray());
}
}
