DbgCodeRange[] TryGetCodeRanges_UI(DbgModule module, uint token, uint offset)
{
uiDispatcher.VerifyAccess();
var tab = documentTabService.Value.GetOrCreateActiveTab();
var documentViewer = tab.TryGetDocumentViewer();
var methodDebugService = documentViewer.GetMethodDebugService();
var moduleId = dbgModuleIdProviderService.GetModuleId(module);
if (moduleId == null)
{
return(null);
}
uint refNavOffset;
if (offset == EPILOG)
{
refNavOffset = DotNetReferenceNavigator.EPILOG;
var mod = dbgMetadataService.TryGetMetadata(module, DbgLoadModuleOptions.AutoLoaded);
if (mod?.ResolveToken(token) is MethodDef md && md.Body != null && md.Body.Instructions.Count > 0)
{
offset = md.Body.Instructions[md.Body.Instructions.Count - 1].Offset;
}
else
{
return(null);
}
}
public DbgLanguageDebugInfoKey(ModuleId moduleId, uint token)
{
this.token = token;
this.moduleId = moduleId;
module = null;
refreshedVersion = 0;
}
ModuleDef LoadModule(DbgModule module, bool useMemory, ref bool canShowMessageBox)
{
if (!module.IsDotNetModule())
{
return(null);
}
if (module.IsDynamic && !module.Runtime.IsClosed && module.Process.IsRunning)
{
if (canShowMessageBox)
{
canShowMessageBox = false;
messageBoxService.Value.Show(dnSpy_Debugger_DotNet_Resources.Module_BreakProcessBeforeLoadingDynamicModules);
}
return(null);
}
var loadOptions = DbgLoadModuleOptions.AutoLoaded;
if (useMemory)
{
loadOptions |= DbgLoadModuleOptions.ForceMemory;
}
return(dbgMetadataService.Value.TryGetMetadata(module, loadOptions));
}
public ModuleVM(DbgModule module, IModuleContext context, int order)
{
Module = module ?? throw new ArgumentNullException(nameof(module));
Context = context ?? throw new ArgumentNullException(nameof(context));
Order = order;
module.PropertyChanged += DbgModule_PropertyChanged;
}
public override ModuleDef?GetDynamicMetadata(DbgModule module, out ModuleId moduleId)
{
var data = module.GetOrCreateData <DynamicModuleData>();
if (!(data.Metadata is null))
{
moduleId = data.ModuleId;
return(data.Metadata);
}
var info = Invoke(() => {
if (!(data.Metadata is null))
{
return(metadata: data.Metadata, moduleId: data.ModuleId);
}
var info2 = engine.GetDynamicMetadata_EngineThread(module);
if (!(info2.metadata is null))
{
// DsDotNetDocumentBase sets EnableTypeDefFindCache to true and that property accesses the
// Types property. It must be initialized in the correct thread.
_ = info2.metadata.Types;
info2.metadata.DisableMDAPICalls = true;
}
return(info2);
});
data.ModuleId = info.moduleId;
data.Metadata = info.metadata;
moduleId = info.moduleId;
return(data.Metadata);
}
public DbgLanguageDebugInfoKey(DbgModule module, uint token)
{
this.token = token;
moduleId = default;
this.module = module;
refreshedVersion = module.RefreshedVersion;
}
public override ModuleDef?TryGetMetadata(DbgModule module, DbgLoadModuleOptions options)
{
if (module is null)
{
throw new ArgumentNullException(nameof(module));
}
if (UseMemoryModules || module.IsDynamic || module.IsInMemory || (options & DbgLoadModuleOptions.ForceMemory) != 0)
{
return(dbgInMemoryModuleService.LoadModule(module));
}
var mod = dbgInMemoryModuleService.FindModule(module);
if (!(mod is null))
{
return(mod);
}
var id = dbgModuleIdProviderService.GetModuleId(module);
if (!(id is null))
{
return(TryGetMetadata(id.Value, options));
}
return(null);
}
internal ModuleId GetModuleId(DbgModule module)
{
if (TryGetModuleData(module, out var data))
{
return(data.ModuleId);
}
throw new InvalidOperationException();
}
public SpecialDbgEngineStackFrame(string name, DbgCodeLocation location, DbgModule module, uint functionOffset, uint functionToken)
{
this.name = name ?? throw new ArgumentNullException(nameof(name));
Location = location;
Module = module;
FunctionOffset = functionOffset;
FunctionToken = functionToken;
}
ModuleDef FindDynamicModule(DbgModule module)
{
if (module == null)
{
throw new ArgumentNullException(nameof(module));
}
return(AllDynamicModuleDefDocuments.FirstOrDefault(a => a.DbgModule == module)?.ModuleDef);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="location">Location</param>
/// <param name="module">Module or null if none</param>
/// <param name="address">Address or <see cref="NoAddress"/> if it's not known</param>
/// <param name="message">Warning/error message or null if none</param>
/// <param name="data">Data to add to the <see cref="DbgBoundCodeBreakpoint"/> or null if nothing gets added.
/// If the data implements <see cref="IDisposable"/>, it gets disposed when the bound breakpoint gets deleted.</param>
public DbgBoundCodeBreakpointInfo(DbgCodeLocation location, DbgModule module, ulong address, DbgEngineBoundCodeBreakpointMessage message, T data)
{
Location = location ?? throw new ArgumentNullException(nameof(location));
Module = module;
Address = address;
Message = message;
Data = data;
}
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;
}
bool TryGetModuleData(DbgModule module, out DbgModuleData data)
{
if (module.TryGetData(out data) && data.Engine == this)
{
return(true);
}
data = null;
return(false);
}
// The compiler adds a new instance method to the class if a base member is accessed using 'base.XXX'
// from inside an iterator or async method. That method just calls the real base method.
public static bool IsBaseWrapperMethod(DbgModule module, uint token)
{
var reflectionModule = module.GetReflectionModule();
Debug2.Assert(!(reflectionModule is null));
if (reflectionModule is null)
{
return(false);
}
var method = reflectionModule.ResolveMethod((int)token, DmdResolveOptions.None);
Debug2.Assert(!(method is null));
if (method is null)
{
return(false);
}
if (!method.IsPrivate || method.IsStatic || method.IsAbstract || method.IsVirtual)
{
return(false);
}
var name = method.Name;
if (string.IsNullOrEmpty(name))
{
return(false);
}
bool okName = false;
var c = name[0];
if (c == '<')
{
// Roslyn C#, eg. "<>n__2"
if (name.StartsWith("<>n__", StringComparison.Ordinal))
{
okName = true;
}
// mcs, eg. "<GetString>__BaseCallProxy1"
else if (name.IndexOf(">__BaseCallProxy", StringComparison.Ordinal) >= 0)
{
okName = true;
}
}
// VB, eg. "$VB$ClosureStub_GetString_MyBase"
else if (c == '$' && name.StartsWith("$VB$ClosureStub_", StringComparison.Ordinal) && name.EndsWith("_MyBase", StringComparison.Ordinal))
{
okName = true;
}
if (!okName)
{
return(false);
}
return(method.IsDefined("System.Runtime.CompilerServices.CompilerGeneratedAttribute", inherit: false));
}
internal void UpdateModule_DbgThread(DbgModule module)
{
Dispatcher.VerifyAccess();
if (this.module != module)
{
this.module = module;
OnPropertyChanged(nameof(Module));
}
}
public DbgBoundCodeBreakpointImpl(DbgRuntimeImpl runtime, DbgCodeBreakpoint breakpoint, DbgModule module, ulong address, DbgBoundCodeBreakpointMessage message)
{
lockObj = new object();
this.runtime = runtime ?? throw new ArgumentNullException(nameof(runtime));
this.breakpoint = breakpoint ?? throw new ArgumentNullException(nameof(breakpoint));
this.module = module;
this.address = address;
this.message = message;
}
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>
/// Constructor
/// </summary>
/// <param name="module">Module</param>
public DbgModuleBreakpointInfo(DbgModule module) {
if (module == null)
throw new ArgumentNullException(nameof(module));
ModuleName = module.Name ?? string.Empty;
IsDynamic = module.IsDynamic;
IsInMemory = module.IsInMemory;
Order = module.Order;
AppDomainName = module.AppDomain?.Name ?? string.Empty;
ProcessName = module.Process.Name;
}
public override void LoadClass(DbgModule module, uint token)
{
lock (lockObj) {
if (!loadedClasses.TryGetValue(module, out var hash))
{
loadedClasses.Add(module, hash = new HashSet <uint>());
}
hash.Add(token);
}
}
internal DnILCodeBreakpoint CreateBreakpointForStepper(DbgModule module, uint token, uint offset, Func <CorThread, bool> callback)
{
debuggerThread.VerifyAccess();
return(dnDebugger.CreateBreakpoint(GetModuleId(module).ToDnModuleId(), token, offset, ctx => {
if (callback(ctx.E.CorThread))
{
ctx.E.AddPauseReason(DebuggerPauseReason.AsyncStepperBreakpoint);
}
return false;
}));
}
GetMethodDebugInfoResult TryGetMethodDebugInfo_UI(DbgModule module, uint token, uint offset)
{
uiDispatcher.VerifyAccess();
var tab = documentTabService.Value.GetOrCreateActiveTab();
var documentViewer = tab.TryGetDocumentViewer();
var methodDebugService = documentViewer.GetMethodDebugService();
var moduleId = dbgModuleIdProviderService.GetModuleId(module);
if (moduleId == null)
{
return(default);
void GetMethodDebugInfo_UI(DbgModule module, uint token, uint offset, TaskCompletionSource <GetMethodDebugInfoResult> tcs)
{
uiDispatcher.VerifyAccess();
try {
var info = TryGetMethodDebugInfo_UI(module, token, offset);
tcs.SetResult(info);
}
catch (Exception ex) {
tcs.SetException(ex);
}
}
public override Task <GetMethodDebugInfoResult> GetMethodDebugInfoAsync(DbgModule module, uint token, uint offset)
{
if (module == null)
{
throw new ArgumentNullException(nameof(module));
}
var tcs = new TaskCompletionSource <GetMethodDebugInfoResult>();
UI(() => GetMethodDebugInfo_UI(module, token, offset, tcs));
return(tcs.Task);
}
public override ModuleDef LoadModule(DbgModule module)
{
if (module == null)
{
throw new ArgumentNullException(nameof(module));
}
if (module.IsDynamic)
{
return(LoadDynamicModule(module));
}
return(LoadMemoryModule(module));
}
ModuleId?GetModuleIdCore(DbgModule module)
{
foreach (var lz in dbgModuleIdProviders)
{
var id = lz.Value.GetModuleId(module);
if (id != null)
{
return(id);
}
}
return(null);
}
public override void GetCodeRanges(DbgModule module, uint token, uint offset, Action <GetCodeRangeResult> callback)
{
if (module == null)
{
throw new ArgumentNullException(nameof(module));
}
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
UI(() => GetCodeRanges_UI(module, token, offset, callback));
}
public DbgExceptionImpl(DbgRuntime runtime, DbgExceptionId id, DbgExceptionEventFlags flags, string message, DbgThread thread, DbgModule module)
{
if (id.IsDefaultId)
{
throw new ArgumentException();
}
Runtime = runtime ?? throw new ArgumentNullException(nameof(runtime));
Id = id;
Flags = flags;
Message = message;
Thread = thread;
Module = module;
}
public override ModuleDef FindModule(DbgModule module)
{
if (module == null)
{
throw new ArgumentNullException(nameof(module));
}
if (module.IsDynamic)
{
return(FindDynamicModule(module));
}
// It could be a dynamic module if LoadMemoryModule() failed and called LoadDynamicModule()
return(FindMemoryModule(module) ?? FindDynamicModule(module));
}
ModuleDef FindMemoryModule(DbgModule module)
{
if (module == null)
{
throw new ArgumentNullException(nameof(module));
}
if (!module.HasAddress)
{
return(null);
}
var key = MemoryModuleDefDocument.CreateKey(module.Process, module.Address);
return(AllMemoryModuleDefDocuments.FirstOrDefault(a => key.Equals(a.Key))?.ModuleDef);
}
public override ModuleId?GetModuleId(DbgModule module)
{
if (module == null)
{
throw new ArgumentNullException(nameof(module));
}
// Don't cache dynamic modules. The reason is that their ModuleIds could change,
// see CorDebug's DbgEngineImpl.UpdateDynamicModuleIds()
if (module.IsDynamic)
{
return(GetModuleIdCore(module));
}
return(module.GetOrCreateData(() => new CachedModuleId(GetModuleIdCore(module))).Id);
}
