/// <summary>
/// Initializes a new instance of the <see cref="ElfImage"/> class.
/// </summary>
/// <param name="path">The image path.</param>
/// <param name="loadOffset">Offset from where image was loaded.</param>
public ElfImage(string path, ulong loadOffset = 0)
{
elf = ELFReader.Load <ulong>(path);
LoadOffset = loadOffset;
foreach (var segment in elf.Segments)
{
if (segment.Type == ELFSharp.ELF.Segments.SegmentType.ProgramHeader)
{
CodeSegmentOffset = segment.Address - (ulong)segment.Offset;
break;
}
}
List <PublicSymbol> publicSymbols = new List <PublicSymbol>();
SymbolTable <ulong> symbols = elf.Sections.FirstOrDefault(s => s.Type == SectionType.SymbolTable) as SymbolTable <ulong>;
if (symbols == null || !symbols.Entries.Any())
{
symbols = elf.Sections.FirstOrDefault(s => s.Type == SectionType.DynamicSymbolTable) as SymbolTable <ulong>;
}
if (symbols != null)
{
foreach (SymbolEntry <ulong> symbol in symbols.Entries)
{
publicSymbols.Add(new PublicSymbol(symbol.Name, symbol.Value - CodeSegmentOffset));
}
}
PublicSymbols = publicSymbols;
sectionRegions = SimpleCache.Create(() => elf.Sections.Where(s => s.LoadAddress > 0).OrderBy(s => s.LoadAddress).ToArray());
sectionRegionFinder = SimpleCache.Create(() => new MemoryRegionFinder(sectionRegions.Value.Select(s => new MemoryRegion {
BaseAddress = s.LoadAddress, RegionSize = s.Size
}).ToArray()));
}
/// <summary>
/// Initializes a new instance of the <see cref="StackFrame" /> class.
/// </summary>
/// <param name="stackTrace">The stack trace.</param>
/// <param name="frameContext">The frame context.</param>
internal StackFrame(StackTrace stackTrace, ThreadContext frameContext)
{
StackTrace = stackTrace;
FrameContext = frameContext;
sourceFileNameAndLine = SimpleCache.Create(ReadSourceFileNameAndLine);
functionNameAndDisplacement = SimpleCache.Create(ReadFunctionNameAndDisplacement);
locals = SimpleCache.Create(GetLocals);
arguments = SimpleCache.Create(GetArguments);
clrStackFrame = SimpleCache.Create(() => Thread.ClrThread?.GetClrStackFrame(InstructionOffset));
userTypeConvertedLocals = SimpleCache.Create(() =>
{
VariableCollection collection = Variable.CastVariableCollectionToUserType(locals.Value);
GlobalCache.UserTypeCastedVariableCollections.Add(userTypeConvertedLocals);
return(collection);
});
userTypeConvertedArguments = SimpleCache.Create(() =>
{
VariableCollection collection = Variable.CastVariableCollectionToUserType(arguments.Value);
GlobalCache.UserTypeCastedVariableCollections.Add(userTypeConvertedArguments);
return(collection);
});
module = SimpleCache.Create(() =>
{
var m = Process.GetModuleByInnerAddress(InstructionOffset);
if (m == null && ClrStackFrame != null)
{
m = Process.ClrModuleCache[ClrStackFrame.Module];
}
return(m);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdHeap"/> class.
/// </summary>
/// <param name="runtime">The runtime.</param>
public VSClrHeap(VSClrRuntime runtime)
{
VSRuntime = runtime;
canWalkHeapCache = SimpleCache.Create(() => Proxy.GetClrHeapCanWalkHeap(VSRuntime.Process.Id, VSRuntime.Id));
totalHeapSizeCache = SimpleCache.Create(() => Proxy.GetClrHeapTotalHeapSize(VSRuntime.Process.Id, VSRuntime.Id));
typesByAddressCache = new DictionaryCache <ulong, VSClrType>((a) => default(VSClrType));
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdModule"/> class.
/// </summary>
/// <param name="provider">The CLR provider.</param>
/// <param name="clrModule">The CLR module.</param>
public ClrMdModule(CLR.ClrMdProvider provider, Microsoft.Diagnostics.Runtime.ClrModule clrModule)
{
Provider = provider;
ClrModule = clrModule;
clrPdbReader = SimpleCache.Create(() =>
{
try
{
string pdbPath = ClrModule.Runtime.DataTarget.SymbolLocator.FindPdb(ClrModule.Pdb);
if (!string.IsNullOrEmpty(pdbPath))
{
return(new Microsoft.Diagnostics.Runtime.Utilities.Pdb.PdbReader(pdbPath));
}
}
catch (Exception)
{
}
return(null);
});
module = SimpleCache.Create(() =>
{
return(Provider.GetProcess(ClrModule.Runtime)?.ClrModuleCache[this]);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="Module" /> class.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="address">The module address.</param>
internal Module(Process process, ulong address)
{
Address = address;
Process = process;
Id = uint.MaxValue;
name = SimpleCache.Create(() =>
{
string name = Context.Debugger.GetModuleName(this);
Process.UpdateModuleByNameCache(this, name);
return(name);
});
imageName = SimpleCache.Create(() => Context.Debugger.GetModuleImageName(this));
loadedImageName = SimpleCache.Create(() => Context.Debugger.GetModuleLoadedImage(this));
symbolFileName = SimpleCache.Create(() => Context.Debugger.GetModuleSymbolFile(this));
mappedImageName = SimpleCache.Create(() => Context.Debugger.GetModuleMappedImage(this));
moduleVersion = SimpleCache.Create(() =>
{
ModuleVersion version = new ModuleVersion();
Context.Debugger.GetModuleVersion(this, out version.Major, out version.Minor, out version.Revision, out version.Patch);
return(version);
});
timestampAndSize = SimpleCache.Create(() => Context.Debugger.GetModuleTimestampAndSize(this));
clrModule = SimpleCache.Create(() => Process.ClrRuntimes.SelectMany(r => r.Modules).Where(m => m.ImageBase == Address).FirstOrDefault());
pointerSize = SimpleCache.Create(() => Process.GetPointerSize());
TypesByName = new DictionaryCache <string, CodeType>(GetTypeByName);
TypesById = new DictionaryCache <uint, CodeType>(GetTypeById);
ClrTypes = new DictionaryCache <IClrType, CodeType>(GetClrCodeType);
GlobalVariables = new DictionaryCache <string, Variable>(GetGlobalVariable);
UserTypeCastedGlobalVariables = Context.UserTypeMetadataCaches.CreateDictionaryCache <string, Variable>((name) => Process.CastVariableToUserType(GlobalVariables[name]));
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrThread"/> class.
/// </summary>
/// <param name="thread">The thread.</param>
/// <param name="clrThread">The CLR thread.</param>
/// <param name="process">The process.</param>
internal ClrThread(Thread thread, Microsoft.Diagnostics.Runtime.ClrThread clrThread, Process process)
: base(thread != null ? thread.Id : uint.MaxValue, clrThread.OSThreadId, process)
{
ClrThread = clrThread;
runtime = SimpleCache.Create(() => Process.ClrRuntimes.Single(r => r.ClrRuntime == clrThread.Runtime));
appDomain = SimpleCache.Create(() => Runtime.AppDomains.Single(a => a.ClrAppDomain.Address == clrThread.AppDomain));
clrStackTrace = SimpleCache.Create(() =>
{
StackTrace stackTrace = new StackTrace(this);
uint frameNumber = 0;
stackTrace.Frames = ClrThread.StackTrace.Where(f => f.Method != null).Select(f =>
{
return(new StackFrame(stackTrace, new ThreadContext(f.InstructionPointer, f.StackPointer, ulong.MaxValue))
{
FrameNumber = frameNumber++,
InstructionOffset = f.InstructionPointer,
StackOffset = f.StackPointer,
FrameOffset = ulong.MaxValue,
ReturnOffset = ulong.MaxValue,
ClrStackFrame = f,
});
}).ToArray();
return(stackTrace);
});
lastThrownException = SimpleCache.Create(() => ClrThread.CurrentException != null ? new ClrException(this, ClrThread.CurrentException) : null);
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeFunction" /> class.
/// </summary>
/// <param name="address">The function address.</param>
/// <param name="process">The process.</param>
public CodeFunction(ulong address, Process process = null)
{
Address = address;
Process = process ?? Process.Current;
sourceFileNameAndLine = SimpleCache.Create(ReadSourceFileNameAndLine);
functionNameAndDisplacement = SimpleCache.Create(ReadFunctionNameAndDisplacement);
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeFunction" /> class.
/// </summary>
/// <param name="address">The function address.</param>
/// <param name="process">The process.</param>
public CodeFunction(ulong address, Process process = null)
{
OriginalAddress = address;
Process = process ?? Process.Current;
functionAddress = SimpleCache.Create(() => Debugger.ResolveFunctionAddress(Process, OriginalAddress));
sourceFileNameAndLine = SimpleCache.Create(ReadSourceFileNameAndLine);
functionNameAndDisplacement = SimpleCache.Create(ReadFunctionNameAndDisplacement);
}
/// <summary>
/// Initializes a new instance of the <see cref="VSClrStackFrame"/> class.
/// </summary>
/// <param name="thread">The thread containing this stack frame.</param>
/// <param name="id">The stack frame id.</param>
/// <param name="instructionPointer">The instruction pointer.</param>
/// <param name="stackPointer">The stack pointer.</param>
/// <param name="moduleAddress">The module base address.</param>
public VSClrStackFrame(VSClrThread thread, int id, ulong instructionPointer, ulong stackPointer, ulong moduleAddress)
{
Thread = thread;
InstructionPointer = instructionPointer;
StackPointer = stackPointer;
argumentsCache = SimpleCache.Create(() => CreateVariableCollection(Proxy.GetClrStackFrameArguments(Thread.VSRuntime.Process.Id, Thread.VSRuntime.Id, Thread.SystemId, Id)));
localsCache = SimpleCache.Create(() => CreateVariableCollection(Proxy.GetClrStackFrameLocals(Thread.VSRuntime.Process.Id, Thread.VSRuntime.Id, Thread.SystemId, Id)));
moduleCache = SimpleCache.Create(() => Thread.VSRuntime.GetModule(moduleAddress));
}
/// <summary>
/// Initializes a new instance of the <see cref="Module" /> class.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="address">The module address.</param>
internal Module(Process process, ulong address)
{
Address = address;
Process = process;
name = SimpleCache.Create(() =>
{
string name = Context.Debugger.GetModuleName(this);
Process.UpdateModuleByNameCache(this, name);
return(name);
});
imageName = SimpleCache.Create(() => Context.Debugger.GetModuleImageName(this));
loadedImageName = SimpleCache.Create(() => Context.Debugger.GetModuleLoadedImage(this));
symbolFileName = SimpleCache.Create(() => Context.Debugger.GetModuleSymbolFile(this));
mappedImageName = SimpleCache.Create(() => Context.Debugger.GetModuleMappedImage(this));
moduleVersion = SimpleCache.Create(() =>
{
ModuleVersion version = new ModuleVersion();
Context.Debugger.GetModuleVersion(this, out version.Major, out version.Minor, out version.Revision, out version.Patch);
return(version);
});
timestampAndSize = SimpleCache.Create(() => Context.Debugger.GetModuleTimestampAndSize(this));
clrModule = SimpleCache.Create(() => Process.ClrRuntimes.SelectMany(r => r.ClrRuntime.Modules).Where(m => m.ImageBase == Address).FirstOrDefault());
clrPdbReader = SimpleCache.Create(() =>
{
try
{
string pdbPath = ClrModule.Runtime.DataTarget.SymbolLocator.FindPdb(ClrModule.Pdb);
if (!string.IsNullOrEmpty(pdbPath))
{
return(new Microsoft.Diagnostics.Runtime.Utilities.Pdb.PdbReader(pdbPath));
}
}
catch (Exception)
{
}
return(null);
});
TypesByName = new DictionaryCache <string, CodeType>(GetTypeByName);
TypesById = new DictionaryCache <uint, CodeType>(GetTypeById);
ClrTypes = new DictionaryCache <Microsoft.Diagnostics.Runtime.ClrType, CodeType>(GetClrCodeType);
GlobalVariables = new DictionaryCache <string, Variable>(GetGlobalVariable);
UserTypeCastedGlobalVariables = new DictionaryCache <string, Variable>((name) =>
{
Variable variable = Process.CastVariableToUserType(GlobalVariables[name]);
if (UserTypeCastedGlobalVariables.Count == 0)
{
GlobalCache.VariablesUserTypeCastedFieldsByName.Add(UserTypeCastedGlobalVariables);
}
return(variable);
});
}
public ObjectResultTreeItem(object obj, Type objType, string name, ImageSource image, InteractiveResultVisualizer interactiveResultVisualizer)
{
this.obj = obj;
this.objType = objType;
this.interactiveResultVisualizer = interactiveResultVisualizer;
Name = name;
Image = image;
valueString = SimpleCache.Create(() => Value.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="Thread" /> class.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="systemId">The system identifier.</param>
/// <param name="process">The process.</param>
internal Thread(uint id, uint systemId, Process process)
{
Id = id;
SystemId = systemId;
Process = process;
tebAddress = SimpleCache.Create(GetTEB);
stackTrace = SimpleCache.Create(GetStackTrace);
threadContext = SimpleCache.Create(GetThreadContext);
clrThread = SimpleCache.Create(() => Process.ClrRuntimes.SelectMany(r => r.Threads).Where(t => t.SystemId == SystemId).FirstOrDefault());
}
/// <summary>
/// Initializes the <see cref="UserTypeDelegates"/> class.
/// </summary>
static UserTypeDelegates()
{
moduleBuilder = SimpleCache.Create(() =>
{
AssemblyName assemblyName = new AssemblyName("SharpDebug.DynamicAssembly");
AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
return(assemblyBuilder.DefineDynamicModule("SharpDebug.Dynamic"));
});
}
/// <summary>
/// Initializes a new instance of the <see cref="Symbol"/> class.
/// </summary>
/// <param name="module">The module.</param>
public Symbol(Module module)
{
Module = module;
fields = SimpleCache.Create(() => GetFields().ToArray());
baseClasses = SimpleCache.Create(() => GetBaseClasses().ToArray());
elementType = SimpleCache.Create(() => GetElementType());
pointerType = SimpleCache.Create(() => GetPointerType());
enumValues = SimpleCache.Create(() => GetEnumValues().ToArray());
namespaces = SimpleCache.Create(() => SymbolNameHelper.GetSymbolNamespaces(Name));
userType = SimpleCache.Create(() => (UserType)null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultVisualizer"/> class.
/// </summary>
/// <param name="result">Resulting object that should be visualized.</param>
/// <param name="resultType">Type of the resulting object that should be visualized.</param>
/// <param name="name">Name of the variable / property.</param>
/// <param name="dataType">Data type that will be used to generate icon of the variable / property</param>
/// <param name="interactiveResultVisualizer">Interactive result visualizer that can be used for creating UI elements.</param>
public ResultVisualizer(object result, Type resultType, string name, CompletionDataType dataType, InteractiveResultVisualizer interactiveResultVisualizer)
{
this.result = result;
this.resultType = resultType;
this.interactiveResultVisualizer = interactiveResultVisualizer;
Name = name;
DataType = dataType;
value = SimpleCache.Create(GetValue);
typeString = SimpleCache.Create(GetTypeString);
valueString = SimpleCache.Create(GetValueString);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultVisualizer"/> class.
/// </summary>
/// <param name="result">Resulting object that should be visualized.</param>
/// <param name="resultType">Type of the resulting object that should be visualized.</param>
/// <param name="name">Name of the variable / property.</param>
/// <param name="image">Image that represents icon of the variable / property</param>
/// <param name="interactiveResultVisualizer">Interactive result visualizer that can be used for creating UI elements.</param>
public ResultVisualizer(object result, Type resultType, string name, ImageSource image, InteractiveResultVisualizer interactiveResultVisualizer)
{
this.result = result;
this.resultType = resultType;
this.interactiveResultVisualizer = interactiveResultVisualizer;
Name = name;
Image = image;
value = SimpleCache.Create(GetValue);
typeString = SimpleCache.Create(GetTypeString);
valueString = SimpleCache.Create(GetValueString);
}
/// <summary>
/// Initializes a new instance of the <see cref="InteractiveExecutionInitialization" /> class.
/// </summary>
/// <param name="interactiveExecutionBehavior">Customization of interactive execution.</param>
/// <param name="cacheInvalidator">Cache invalidator that will be used to create simple cache for creating interactive execution.</param>
public InteractiveExecutionInitialization(InteractiveExecutionBehavior interactiveExecutionBehavior, CacheInvalidator cacheInvalidator = null)
{
InteractiveExecutionBehavior = interactiveExecutionBehavior;
if (cacheInvalidator != null)
{
InteractiveExecutionCache = cacheInvalidator.CreateSimpleCache(CreateInteractiveExecution);
}
else
{
InteractiveExecutionCache = SimpleCache.Create(CreateInteractiveExecution);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdThread"/> class.
/// </summary>
/// <param name="runtime">The Visual Studio runtime.</param>
/// <param name="threadId">The thread system id.</param>
/// <param name="isFinalizerThread">Is this finalizer thread.</param>
/// <param name="appDomainAddress">The application domain address.</param>
public VSClrThread(VSClrRuntime runtime, uint threadId, bool isFinalizerThread, ulong appDomainAddress)
{
VSRuntime = runtime;
SystemId = threadId;
IsFinalizerThread = isFinalizerThread;
clrStackFramesCache = SimpleCache.Create(() =>
{
Tuple <int, ulong, ulong, ulong>[] frames = Proxy.GetClrThreadFrames(Runtime.Process.Id, runtime.Id, SystemId);
VSClrStackFrame[] clrFrames = new VSClrStackFrame[frames.Length];
for (int i = 0; i < frames.Length; i++)
{
clrFrames[i] = new VSClrStackFrame(this, frames[i].Item1, frames[i].Item2, frames[i].Item3, frames[i].Item4);
}
return(clrFrames);
});
stackTraceCache = SimpleCache.Create(() =>
{
Thread thread = VSRuntime.Process.Threads.First(t => t.SystemId == SystemId);
StackTrace stackTrace = new StackTrace(thread);
uint frameNumber = 0;
stackTrace.Frames = clrStackFramesCache.Value.Select(f =>
{
return(new StackFrame(stackTrace, new ThreadContext(f.InstructionPointer, f.StackPointer, ulong.MaxValue, null))
{
FrameNumber = frameNumber++,
InstructionOffset = f.InstructionPointer,
StackOffset = f.StackPointer,
FrameOffset = ulong.MaxValue,
ReturnOffset = ulong.MaxValue,
ClrStackFrame = f,
});
}).ToArray();
return(stackTrace);
});
appDomainCache = SimpleCache.Create(() => Runtime.AppDomains.Single(a => a.Address == appDomainAddress));
lastThrownExceptionCache = SimpleCache.Create(() =>
{
Tuple <ulong, int> tuple = Proxy.GetClrThreadLastException(Runtime.Process.Id, runtime.Id, SystemId);
ulong address = tuple.Item1;
IClrType clrType = runtime.GetClrType(tuple.Item2);
if (clrType == null)
{
return(null);
}
return(Variable.CreatePointer(runtime.Process.FromClrType(clrType), address));
});
}
public void Disposable()
{
int disposedCount = 0;
using (SimpleCache <DisposableAction> cache = SimpleCache.Create(() => new DisposableAction(() => disposedCount++)))
{
var v0 = cache.Value;
cache.InvalidateCache();
Assert.Equal(1, disposedCount);
var v1 = cache.Value;
}
Assert.Equal(2, disposedCount);
}
/// <summary>
/// Initializes a new instance of the <see cref="DiaModule"/> class.
/// </summary>
/// <param name="pdbPath">The PDB path.</param>
/// <param name="module">The module.</param>
public DiaModule(string pdbPath, Module module)
{
Module = module;
dia = new DiaSource();
dia.loadDataFromPdb(pdbPath);
dia.openSession(out session);
globalScope = session.globalScope;
typeAllFields = new DictionaryCache <uint, List <Tuple <string, uint, int> > >(GetTypeAllFields);
typeFields = new DictionaryCache <uint, List <Tuple <string, uint, int> > >(GetTypeFields);
basicTypes = SimpleCache.Create(() =>
{
var types = new Dictionary <string, IDiaSymbol>();
var basicTypes = globalScope.GetChildren(SymTagEnum.SymTagBaseType);
foreach (var type in basicTypes)
{
try
{
string typeString = TypeToString.GetTypeString(type);
if (!types.ContainsKey(typeString))
{
types.Add(typeString, type);
}
}
catch (Exception)
{
}
}
return(types);
});
symbolNamesByAddress = new DictionaryCache <uint, Tuple <string, ulong> >((distance) =>
{
IDiaSymbol symbol;
int displacement;
string name;
session.findSymbolByRVAEx(distance, SymTagEnum.SymTagNull, out symbol, out displacement);
symbol.get_undecoratedNameEx(0 | 0x8000 | 0x1000, out name);
return(Tuple.Create(name, (ulong)displacement));
});
session.loadAddress = module.Address;
enumTypeNames = new DictionaryCache <uint, Dictionary <ulong, string> >(GetEnumName);
}
/// <summary>
/// Initializes a new instance of the <see cref="Module" /> class.
/// </summary>
/// <param name="path">The module path.</param>
/// <param name="address">The module address.</param>
/// <param name="_pointerSize">The module's native pointerSize.</param>
public Module(string path, ulong address = 0, uint _pointerSize = 8)
{
Address = address;
Process = default(Process);
Id = uint.MaxValue;
name = SimpleCache.Create(() => path);
imageName = SimpleCache.Create(() => path);
loadedImageName = SimpleCache.Create(() => path);
symbolFileName = SimpleCache.Create(() => path);
mappedImageName = SimpleCache.Create(() => path);
clrModule = null;
pointerSize = SimpleCache.Create(() => _pointerSize);
TypesByName = new DictionaryCache <string, CodeType>(GetTypeByName);
TypesById = new DictionaryCache <uint, CodeType>(GetTypeById);
ClrTypes = new DictionaryCache <IClrType, CodeType>(GetClrCodeType);
GlobalVariables = new DictionaryCache <string, Variable>(GetGlobalVariable);
UserTypeCastedGlobalVariables = Context.UserTypeMetadataCaches.CreateDictionaryCache <string, Variable>((name) => Process.CastVariableToUserType(GlobalVariables[name]));
}
public void SingleEvaluation()
{
int count = 0;
SimpleCache <int> cache = SimpleCache.Create(() =>
{
count++;
return(42);
});
Assert.Equal(0, count);
Assert.False(cache.Cached);
Assert.Equal(42, cache.Value);
Assert.Equal(1, count);
Assert.True(cache.Cached);
Assert.Equal(42, cache.Value);
Assert.Equal(1, count);
Assert.Single(cache, 42);
}
/// <summary>
/// Initializes this instance of the <see cref="DiaModule"/> class.
/// </summary>
/// <param name="diaSession">The DIA session.</param>
/// <param name="module">The module.</param>
private void Initialize(IDiaSession diaSession, Module module)
{
Module = module;
session = diaSession;
globalScope = session.globalScope;
typeAllFields = new DictionaryCache <uint, List <Tuple <string, uint, int> > >(GetTypeAllFields);
typeFields = new DictionaryCache <uint, List <Tuple <string, uint, int> > >(GetTypeFields);
basicTypes = SimpleCache.Create(() =>
{
var types = new Dictionary <string, IDiaSymbol>();
var basicTypes = globalScope.GetChildren(SymTagEnum.BaseType);
foreach (var type in basicTypes)
{
try
{
string typeString = TypeToString.GetTypeString(type);
if (!types.ContainsKey(typeString))
{
types.Add(typeString, type);
}
}
catch (Exception)
{
}
}
return(types);
});
symbolNamesByAddress = new DictionaryCache <uint, Tuple <string, ulong> >((distance) =>
{
IDiaSymbol symbol;
int displacement;
string name;
session.findSymbolByRVAEx(distance, SymTagEnum.Null, out symbol, out displacement);
name = symbol.get_undecoratedNameEx(UndecoratedNameOptions.NameOnly | UndecoratedNameOptions.NoEscu);
return(Tuple.Create(name, (ulong)displacement));
});
session.loadAddress = module.Address;
enumTypeNames = new DictionaryCache <uint, Dictionary <ulong, string> >(GetEnumName);
}
public void EvaluationAfterInvalidate()
{
int count = 0;
SimpleCache <int> cache = SimpleCache.Create(() =>
{
count++;
return(42);
});
Assert.Equal(0, count);
Assert.Equal(42, cache.Value);
Assert.Equal(1, count);
Assert.Equal(42, cache.Value);
Assert.Equal(1, count);
cache.InvalidateCache();
Assert.Equal(1, count);
Assert.Equal(42, cache.Value);
Assert.Equal(2, count);
}
/// <summary>
/// Initializes a new instance of the <see cref="Process"/> class.
/// </summary>
/// <param name="id">The identifier.</param>
internal Process(uint id)
{
Id = id;
systemId = SimpleCache.Create(() => Context.Debugger.GetProcessSystemId(this));
upTime = SimpleCache.Create(() => Context.Debugger.GetProcessUpTime(this));
pebAddress = SimpleCache.Create(() => Context.Debugger.GetProcessEnvironmentBlockAddress(this));
executableName = SimpleCache.Create(() => Context.Debugger.GetProcessExecutableName(this));
dumpFileName = SimpleCache.Create(() => Context.Debugger.GetProcessDumpFileName(this));
actualProcessorType = SimpleCache.Create(() => Context.Debugger.GetProcessActualProcessorType(this));
effectiveProcessorType = SimpleCache.Create(() => Context.Debugger.GetProcessEffectiveProcessorType(this));
threads = SimpleCache.Create(() => Context.Debugger.GetProcessThreads(this));
modules = SimpleCache.Create(() => Context.Debugger.GetProcessModules(this));
userTypes = SimpleCache.Create(GetUserTypes);
clrDataTarget = SimpleCache.Create(() =>
{
var dataTarget = Microsoft.Diagnostics.Runtime.DataTarget.CreateFromDataReader(new CsDebugScript.CLR.DataReader(this));
dataTarget.SymbolLocator.SymbolPath += ";http://symweb";
return(dataTarget);
});
clrRuntimes = SimpleCache.Create(() => ClrDataTarget.ClrVersions.Select(clrInfo => new Runtime(this, clrInfo.CreateRuntime())).ToArray());
currentAppDomain = SimpleCache.Create(() => ClrRuntimes.SelectMany(r => r.AppDomains).FirstOrDefault());
ModulesByName = new DictionaryCache <string, Module>(GetModuleByName);
ModulesById = new DictionaryCache <ulong, Module>(GetModuleByAddress);
Variables = new DictionaryCache <Tuple <CodeType, ulong, string, string>, Variable>((tuple) => new Variable(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4));
UserTypeCastedVariables = new DictionaryCache <Variable, Variable>((variable) => Variable.CastVariableToUserType(variable));
GlobalCache.UserTypeCastedVariables.Add(UserTypeCastedVariables);
dumpFileMemoryReader = SimpleCache.Create(() =>
{
try
{
return(string.IsNullOrEmpty(DumpFileName) ? null : new DumpFileMemoryReader(DumpFileName));
}
catch (Exception)
{
return(null);
}
});
TypeToUserTypeDescription = new DictionaryCache <Type, UserTypeDescription[]>(GetUserTypeDescription);
ansiStringCache = new DictionaryCache <Tuple <ulong, int>, string>(DoReadAnsiString);
unicodeStringCache = new DictionaryCache <Tuple <ulong, int>, string>(DoReadUnicodeString);
}
public void SettingValue()
{
int count = 0;
SimpleCache <int> cache = SimpleCache.Create(() =>
{
count++;
return(42);
});
Assert.Equal(0, count);
Assert.Equal(42, cache.Value);
Assert.Equal(1, count);
cache.Value = 12345;
Assert.Equal(12345, cache.Value);
Assert.Equal(1, count);
cache.InvalidateCache();
Assert.Equal(1, count);
Assert.Equal(42, cache.Value);
Assert.Equal(2, count);
}
/// <summary>
/// Initializes a new instance of the <see cref="VSClrAppDomain" /> class.
/// </summary>
/// <param name="runtime">The runtime.</param>
/// <param name="id">The application domain identifier.</param>
/// <param name="address">The application domain address.</param>
/// <param name="applicationBase">The application domain base directory.</param>
/// <param name="configurationFile">The configuration file used for application domain.</param>
public VSClrAppDomain(VSClrRuntime runtime, int id, string name, ulong address, string applicationBase, string configurationFile)
{
VSRuntime = runtime;
Id = id;
Name = name;
Address = address;
ApplicationBase = applicationBase;
ConfigurationFile = configurationFile;
modulesCache = SimpleCache.Create(() =>
{
ulong[] moduleAddresses = VSRuntime.Proxy.GetClrAppDomainModules(VSRuntime.Process.Id, VSRuntime.Id, Id);
VSClrModule[] modules = new VSClrModule[moduleAddresses.Length];
for (int i = 0; i < modules.Length; i++)
{
modules[i] = VSRuntime.GetModule(moduleAddresses[i]);
}
return(modules);
});
}
/// <summary>
/// Initializes the <see cref="UserTypeDelegates"/> class.
/// </summary>
static UserTypeDelegates()
{
moduleBuilder = SimpleCache.Create(() =>
{
AssemblyName assemblyName = new AssemblyName("CsDebugScript.DynamicAssembly");
byte[] bytes;
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("CsDebugScript.Key.snk"))
{
bytes = new byte[stream.Length];
stream.Read(bytes, 0, bytes.Length);
}
assemblyName.KeyPair = new StrongNameKeyPair(bytes);
AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
return(assemblyBuilder.DefineDynamicModule("CsDebugScript.Dynamic"));
});
}
/// <summary>
/// Initializes a new instance of the <see cref="Runtime" /> class.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="clrRuntime">The CLR runtime.</param>
internal Runtime(Process process, Microsoft.Diagnostics.Runtime.ClrRuntime clrRuntime)
{
Process = process;
ClrRuntime = clrRuntime;
appDomains = SimpleCache.Create(() => ClrRuntime.AppDomains.Select(ad => new AppDomain(this, ad)).ToArray());
modules = SimpleCache.Create(() => ClrRuntime.Modules.Select(mm => Process.Modules.Where(m => m.Address == mm.ImageBase).FirstOrDefault()).Where(m => m != null).ToArray());
sharedDomain = SimpleCache.Create(() => ClrRuntime.SharedDomain != null ? new AppDomain(this, ClrRuntime.SharedDomain) : null);
systemDomain = SimpleCache.Create(() => ClrRuntime.SystemDomain != null ? new AppDomain(this, ClrRuntime.SystemDomain) : null);
threads = SimpleCache.Create(() => ClrRuntime.Threads.Select(tt => Process.Threads.Where(t => t.SystemId == tt.OSThreadId).FirstOrDefault()).Where(t => t != null).ToArray());
gcThreads = SimpleCache.Create(() => ClrRuntime.EnumerateGCThreads().Select(tt => Process.Threads.Where(t => t.SystemId == tt).FirstOrDefault()).Where(t => t != null).ToArray());
var version = ClrRuntime.ClrInfo.Version;
Version = new ModuleVersion()
{
Major = version.Major,
Minor = version.Minor,
Patch = version.Patch,
Revision = version.Revision,
};
}
/// <summary>
/// Initializes a new instance of the <see cref="ClrMdThread"/> class.
/// </summary>
/// <param name="thread">The thread.</param>
/// <param name="clrThread">The CLR thread.</param>
/// <param name="process">The process.</param>
internal ClrMdThread(Thread thread, Microsoft.Diagnostics.Runtime.ClrThread clrThread, Process process)
{
Thread = thread;
Process = process;
ClrThread = clrThread;
runtime = SimpleCache.Create(() => Process.ClrRuntimes.Single(r => ((ClrMdRuntime)r).ClrRuntime == clrThread.Runtime));
appDomain = SimpleCache.Create(() => Runtime.AppDomains.Single(a => a.Address == clrThread.AppDomain));
clrStackTrace = SimpleCache.Create(() =>
{
CLR.ClrMdProvider provider = ((ClrMdRuntime)Runtime).Provider;
StackTrace stackTrace = new StackTrace(Thread);
uint frameNumber = 0;
stackTrace.Frames = ClrThread.StackTrace.Where(f => f.Method != null).Select(f =>
{
return(new StackFrame(stackTrace, new ThreadContext(f.InstructionPointer, f.StackPointer, ulong.MaxValue, null))
{
FrameNumber = frameNumber++,
InstructionOffset = f.InstructionPointer,
StackOffset = f.StackPointer,
FrameOffset = ulong.MaxValue,
ReturnOffset = ulong.MaxValue,
ClrStackFrame = new ClrMdStackFrame(provider, f),
});
}).ToArray();
return(stackTrace);
});
lastThrownException = SimpleCache.Create(() =>
{
if (ClrThread.CurrentException != null)
{
CLR.ClrMdProvider provider = ((ClrMdRuntime)Runtime).Provider;
Microsoft.Diagnostics.Runtime.ClrException clrException = ClrThread.CurrentException;
return(Variable.CreatePointer(Process.FromClrType(provider.FromClrType(clrException.Type)), clrException.Address));
}
return(null);
});
}
