/// <summary> /// Gets the source file name and line for the specified address. /// </summary> /// <param name="process">The process.</param> /// <param name="address">The address.</param> /// <param name="sourceFileName">Name of the source file.</param> /// <param name="sourceFileLine">The source file line.</param> /// <param name="displacement">The displacement.</param> public void GetProcessAddressSourceFileNameAndLine(Process process, ulong address, out string sourceFileName, out uint sourceFileLine, out ulong displacement) { ulong distance; Module module; ISymbolProviderModule diaModule = GetDiaModule(process, address, out distance, out module); diaModule.GetSourceFileNameAndLine(process, address, (uint)distance, out sourceFileName, out sourceFileLine, out displacement); }
/// <summary> /// Gets the source file name and line for the specified stack frame. /// </summary> /// <param name="stackFrame">The stack frame.</param> /// <param name="sourceFileName">Name of the source file.</param> /// <param name="sourceFileLine">The source file line.</param> /// <param name="displacement">The displacement.</param> public void GetStackFrameSourceFileNameAndLine(StackFrame stackFrame, out string sourceFileName, out uint sourceFileLine, out ulong displacement) { ulong distance; Module module; ISymbolProviderModule diaModule = GetDiaModule(stackFrame.Process, stackFrame.InstructionOffset, out distance, out module); diaModule.GetSourceFileNameAndLine(stackFrame.Process, stackFrame.InstructionOffset, (uint)distance, out sourceFileName, out sourceFileLine, out displacement); }
/// <summary> /// Gets the stack frame locals. /// </summary> /// <param name="stackFrame">The stack frame.</param> /// <param name="arguments">if set to <c>true</c> only arguments will be returned.</param> public VariableCollection GetFrameLocals(StackFrame stackFrame, bool arguments) { ulong distance; Module module; ISymbolProviderModule diaModule = GetDiaModule(stackFrame.Process, stackFrame.InstructionOffset, out distance, out module); return(diaModule.GetFrameLocals(stackFrame, module, (uint)distance, arguments)); }
/// <summary> /// Gets the runtime code type and offset to original code type. /// </summary> /// <param name="process">The process.</param> /// <param name="vtableAddress">The vtable address.</param> public Tuple <CodeType, int> GetRuntimeCodeTypeAndOffset(Process process, ulong vtableAddress) { ulong distance; Module module; ISymbolProviderModule diaModule = GetDiaModule(process, vtableAddress, out distance, out module); return(diaModule?.GetRuntimeCodeTypeAndOffset(process, vtableAddress, (uint)distance)); }
/// <summary> /// Gets the symbol name by address. /// </summary> /// <param name="process">The process.</param> /// <param name="address">The address.</param> public Tuple <string, ulong> GetSymbolNameByAddress(Process process, ulong address) { ulong distance; Module module; ISymbolProviderModule diaModule = GetDiaModule(process, address, out distance, out module); var result = diaModule.GetSymbolNameByAddress(process, address, (uint)distance); return(new Tuple <string, ulong>(module.Name + "!" + result.Item1, result.Item2)); }
/// <summary> /// Gets the name of the function for the specified address. /// </summary> /// <param name="process">The process.</param> /// <param name="address">The address.</param> /// <param name="functionName">Name of the function.</param> /// <param name="displacement">The displacement.</param> public void GetProcessAddressFunctionName(Process process, ulong address, out string functionName, out ulong displacement) { ulong distance; Module module; ISymbolProviderModule diaModule = GetDiaModule(process, address, out distance, out module); diaModule.GetFunctionNameAndDisplacement(process, address, (uint)distance, out functionName, out displacement); functionName = module.Name + "!" + functionName; }
/// <summary> /// Gets the runtime code type and offset to original code type. /// </summary> /// <param name="tuple">The tuple containing process and vtable address.</param> private Tuple <CodeType, int> GetRuntimeCodeTypeAndOffset(Tuple <Process, ulong> tuple) { Process process = tuple.Item1; ulong vtableAddress = tuple.Item2; ulong distance; Module module; ISymbolProviderModule diaModule = GetDiaModule(process, vtableAddress, out distance, out module); return(diaModule?.GetRuntimeCodeTypeAndOffset(process, vtableAddress, (uint)distance)); }
/// <summary> /// Gets the virtual base class start address. /// </summary> /// <param name="originalCodeType">Code type of the object.</param> /// <param name="objectAddress">Object address.</param> /// <param name="virtualCodeType">Virtual class code type.</param> /// <returns>Address of the object which code type is virtual class.</returns> public ulong GetVirtualClassBaseAddress(CodeType originalCodeType, ulong objectAddress, CodeType virtualCodeType) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(originalCodeType.Module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.GetVirtualClassBaseAddress(originalCodeType, objectAddress, virtualCodeType)); } return(symbolProviderModule.GetVirtualClassBaseAddress(((NativeCodeType)originalCodeType).TypeId, objectAddress, ((NativeCodeType)virtualCodeType).TypeId)); }
/// <summary> /// Gets the type pointer to type of the specified type. /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> /// <returns>Type id to pointer type, or <c>int.MaxValue</c> if it doesn't exist and fake should be used.</returns> public uint GetTypePointerToTypeId(Module module, uint typeId) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.GetTypePointerToTypeId(module, typeId)); } return(symbolProviderModule.GetTypePointerToTypeId(typeId)); }
/// <summary> /// Gets the type's direct base classes type and offset. /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> public Dictionary <string, Tuple <uint, int> > GetTypeDirectBaseClasses(Module module, uint typeId) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetTypeDirectBaseClasses(module, typeId)); } return(symbolProviderModule.GetTypeDirectBaseClasses(typeId)); }
/// <summary> /// Gets the type's base class type and offset. /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> /// <param name="className">Name of the class.</param> public Tuple <uint, int> GetTypeBaseClass(Module module, uint typeId, string className) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetTypeBaseClass(module, typeId, className)); } return(symbolProviderModule.GetTypeBaseClass(typeId, className)); }
/// <summary> /// Gets the name of the enumeration value. /// </summary> /// <param name="module">The module.</param> /// <param name="enumTypeId">The enumeration type identifier.</param> /// <param name="enumValue">The enumeration value.</param> public string GetEnumName(Module module, uint enumTypeId, ulong enumValue) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetEnumName(module, enumTypeId, enumValue)); } return(symbolProviderModule.GetEnumName(enumTypeId, enumValue)); }
/// <summary> /// Gets the names of fields of the specified type. /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> public string[] GetTypeFieldNames(Module module, uint typeId) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetTypeFieldNames(module, typeId)); } return(symbolProviderModule.GetTypeFieldNames(typeId)); }
/// <summary> /// Gets the field type id and offset of the specified type. /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> /// <param name="fieldName">Name of the field.</param> public Tuple <uint, int> GetTypeFieldTypeAndOffset(Module module, uint typeId, string fieldName) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetTypeFieldTypeAndOffset(module, typeId, fieldName)); } return(symbolProviderModule.GetTypeFieldTypeAndOffset(typeId, fieldName)); }
/// <summary> /// Reads the simple data (1 to 8 bytes) for specified type and address to read from. /// </summary> /// <param name="codeType">Type of the code.</param> /// <param name="address">The address.</param> public ulong ReadSimpleData(CodeType codeType, ulong address) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(codeType.Module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.ReadSimpleData(codeType, address)); } return(symbolProviderModule.ReadSimpleData(codeType, address)); }
/// <summary> /// Gets path to the symbols file or <c>null</c> if we don't have symbols. /// </summary> /// <param name="module">The module.</param> /// <returns>Paths to the symbols file.</returns> public string GetModuleSymbolsPath(Module module) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetModuleSymbolsPath(module)); } return(symbolProviderModule.GetSymbolsPath()); }
/// <summary> /// Gets the code type tag of the specified type. /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> public CodeTypeTag GetTypeTag(Module module, uint typeId) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.GetTypeTag(module, typeId)); } return(symbolProviderModule.GetTypeTag(typeId)); }
/// <summary> /// Gets the template arguments. /// <para>For given type: MyType<Arg1, 2, Arg3<5>></para> /// <para>It will return: <code>new object[] { CodeType.Create("Arg1", Module), 2, CodeType.Create("Arg3<5>", Module) }</code></para> /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> public object[] GetTemplateArguments(Module module, uint typeId) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetTemplateArguments(module, typeId)); } return(symbolProviderModule.GetTemplateArguments(typeId)); }
/// <summary> /// Gets the type identifier. /// </summary> /// <param name="module">The module.</param> /// <param name="typeName">Name of the type.</param> public uint GetTypeId(Module module, string typeName) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.GetTypeId(module, typeName)); } return(symbolProviderModule.GetTypeId(typeName)); }
/// <summary> /// Gets the type's built-in type. /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> public BuiltinType GetTypeBuiltinType(Module module, uint typeId) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.GetTypeBuiltinType(module, typeId)); } return(symbolProviderModule.GetTypeBuiltinType(typeId)); }
/// <summary> /// Gets the global variable type identifier. /// </summary> /// <param name="module">The module.</param> /// <param name="globalVariableName">Name of the global variable.</param> public uint GetGlobalVariableTypeId(Module module, string globalVariableName) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.GetGlobalVariableTypeId(module, globalVariableName)); } return(symbolProviderModule.GetGlobalVariableTypeId(globalVariableName)); }
/// <summary> /// Gets the global variable address. /// </summary> /// <param name="module">The module.</param> /// <param name="globalVariableName">Name of the global variable.</param> public ulong GetGlobalVariableAddress(Module module, string globalVariableName) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.GetGlobalVariableAddress(module, globalVariableName)); } return(symbolProviderModule.GetGlobalVariableAddress(globalVariableName)); }
/// <summary> /// Gets the name of the specified type. /// </summary> /// <param name="module">The module.</param> /// <param name="typeId">The type identifier.</param> public string GetTypeName(Module module, uint typeId) { ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.GetTypeName(module, typeId)); } return(symbolProviderModule.GetTypeName(typeId)); }
/// <summary> /// Determines whether the specified process address is function type public symbol. /// </summary> /// <param name="process">The process.</param> /// <param name="address">The address.</param> /// <returns> /// <c>true</c> if the specified process address is function type public symbol; otherwise, <c>false</c>. /// </returns> public bool IsFunctionAddressPublicSymbol(Process process, ulong address) { ulong distance; Module module; ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(process, address, out distance, out module); if (symbolProviderModule == null) { return(FallbackSymbolProvider.IsFunctionAddressPublicSymbol(process, address)); } return(symbolProviderModule.IsFunctionAddressPublicSymbol((uint)distance)); }
/// <summary> /// Gets the stack frame locals. /// </summary> /// <param name="stackFrame">The stack frame.</param> /// <param name="arguments">if set to <c>true</c> only arguments will be returned.</param> public VariableCollection GetFrameLocals(StackFrame stackFrame, bool arguments) { ulong distance; Module module; ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(stackFrame.Process, stackFrame.InstructionOffset, out distance, out module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetFrameLocals(stackFrame, arguments)); } return(symbolProviderModule.GetFrameLocals(stackFrame, (uint)distance, arguments)); }
/// <summary> /// Gets the name of the function for the specified stack frame. /// </summary> /// <param name="stackFrame">The stack frame.</param> /// <param name="functionName">Name of the function.</param> /// <param name="displacement">The displacement.</param> public void GetStackFrameFunctionName(StackFrame stackFrame, out string functionName, out ulong displacement) { ulong distance; Module module; ISymbolProviderModule diaModule = GetDiaModule(stackFrame.Process, stackFrame.InstructionOffset, out distance, out module); diaModule.GetFunctionNameAndDisplacement(stackFrame.Process, stackFrame.InstructionOffset, (uint)distance, out functionName, out displacement); if (!functionName.Contains("!")) { functionName = module.Name + "!" + functionName; } }
/// <summary> /// Gets the source file name and line for the specified address. /// </summary> /// <param name="process">The process.</param> /// <param name="address">The address.</param> /// <param name="sourceFileName">Name of the source file.</param> /// <param name="sourceFileLine">The source file line.</param> /// <param name="displacement">The displacement.</param> public void GetProcessAddressSourceFileNameAndLine(Process process, ulong address, out string sourceFileName, out uint sourceFileLine, out ulong displacement) { ulong distance; Module module; ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(process, address, out distance, out module); if (symbolProviderModule == null) { FallbackSymbolProvider.GetProcessAddressSourceFileNameAndLine(process, address, out sourceFileName, out sourceFileLine, out displacement); return; } symbolProviderModule.GetSourceFileNameAndLine((uint)distance, out sourceFileName, out sourceFileLine, out displacement); }
/// <summary> /// Gets the source file name and line for the specified stack frame. /// </summary> /// <param name="stackFrame">The stack frame.</param> /// <param name="sourceFileName">Name of the source file.</param> /// <param name="sourceFileLine">The source file line.</param> /// <param name="displacement">The displacement.</param> public void GetStackFrameSourceFileNameAndLine(StackFrame stackFrame, out string sourceFileName, out uint sourceFileLine, out ulong displacement) { ulong distance; Module module; ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(stackFrame.Process, stackFrame.InstructionOffset, out distance, out module); if (symbolProviderModule == null) { FallbackSymbolProvider.GetStackFrameSourceFileNameAndLine(stackFrame, out sourceFileName, out sourceFileLine, out displacement); return; } symbolProviderModule.GetSourceFileNameAndLine((uint)distance, out sourceFileName, out sourceFileLine, out displacement); }
/// <summary> /// Gets the runtime code type and offset to original code type. /// </summary> /// <param name="tuple">The tuple containing process and vtable address.</param> private Tuple <CodeType, int> GetRuntimeCodeTypeAndOffset(Tuple <Process, ulong> tuple) { Process process = tuple.Item1; ulong vtableAddress = tuple.Item2; ulong distance; Module module; ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(process, vtableAddress, out distance, out module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetRuntimeCodeTypeAndOffset(tuple.Item1, tuple.Item2)); } return(symbolProviderModule?.GetRuntimeCodeTypeAndOffset((uint)distance)); }
/// <summary> /// Gets the symbol name by address. /// </summary> /// <param name="process">The process.</param> /// <param name="address">The address.</param> public Tuple <string, ulong> GetSymbolNameByAddress(Process process, ulong address) { ulong distance; Module module; ISymbolProviderModule symbolProviderModule = GetSymbolProviderModule(process, address, out distance, out module); if (symbolProviderModule == null) { return(FallbackSymbolProvider?.GetSymbolNameByAddress(process, address)); } var result = symbolProviderModule.GetSymbolNameByAddress((uint)distance); return(new Tuple <string, ulong>(module.Name + "!" + result.Item1, result.Item2)); }