public void GetSymbolForAddress(ulong addr, ref Symbol ret) { IDiaSymbol symbol = null; SymTagEnum tagEnum = SymTagEnum.SymTagFunction; diaSession.findSymbolByVA((ulong)addr, tagEnum, out symbol); if (symbol != null) { ret.functionName = (tagEnum == SymTagEnum.SymTagNull ? symbol.undecoratedName : symbol.name); ret.address = addr; ret.functionAddress = symbol.virtualAddress; IDiaEnumLineNumbers lineNumbers; diaSession.findLinesByVA(addr, 1, out lineNumbers); uint celt = 0; IDiaLineNumber line; while (true) { lineNumbers.Next(1, out line, out celt); if (celt == 1) { ret.fileName = line.sourceFile.fileName; ret.line = line.lineNumber; break; } if (celt != 1) { break; } } } }
/// <summary> /// Converts <see cref="SymTagEnum"/> to <see cref="CodeTypeTag"/>. /// </summary> public static CodeTypeTag ToCodeTypeTag(this SymTagEnum tag) { switch (tag) { case SymTagEnum.ArrayType: return(CodeTypeTag.Array); case SymTagEnum.BaseType: return(CodeTypeTag.BuiltinType); case SymTagEnum.UDT: // TODO: What about Structure/Union? IDiaSymbol.udtKind might help... return(CodeTypeTag.Class); case SymTagEnum.Enum: return(CodeTypeTag.Enum); case SymTagEnum.FunctionType: return(CodeTypeTag.Function); case SymTagEnum.PointerType: return(CodeTypeTag.Pointer); case SymTagEnum.BaseClass: return(CodeTypeTag.BaseClass); case SymTagEnum.Exe: return(CodeTypeTag.ModuleGlobals); default: return(CodeTypeTag.Unsupported); } }
/// <summary> /// Initializes a new instance of the <see cref="DiaSymbol"/> class. /// </summary> /// <param name="module">The module.</param> /// <param name="symbol">The DIA symbol.</param> public DiaSymbol(DiaModule module, IDiaSymbol symbol) : base(module) { SymTagEnum symTag = symbol.symTag; this.symbol = symbol; Tag = ConvertToCodeTypeTag(symTag); BasicType = symbol.baseType; Id = symbol.symIndexId; if (symTag != SymTagEnum.Exe) { Name = TypeToString.GetTypeString(symbol); } else { Name = ""; } Offset = symbol.offset; ulong size = symbol.length; if (size > int.MaxValue) { throw new ArgumentException("Symbol size is unexpected"); } Size = (int)size; IsVirtualInheritance = symbol.virtualBaseClass; }
/// <summary> /// Gets the children. /// </summary> /// <param name="symbol">The symbol.</param> /// <param name="tag">The tag.</param> public static IEnumerable<IDiaSymbol> GetChildren(this IDiaSymbol symbol, SymTagEnum tag = SymTagEnum.SymTagNull) { IDiaEnumSymbols symbols; symbol.findChildren(tag, null, 0, out symbols); return symbols.Enum(); }
public static IDiaSymbol FindSymbol(String symName, IDiaSymbol parent, SymTagEnum symTag) { IDiaEnumSymbols e; parent.findChildren(symTag, symName, (uint)(NameSearchOptions.nsfCaseSensitive), out e); IDiaSymbol s; uint celt; if (e == null || e.count == 0) return null; e.Next(1, out s, out celt); if (e.count > 1) { for (int i = 1; i < e.count; i++) { IDiaSymbol s2; e.Next(1, out s2, out celt); // Diasym reader returns multiple symbols with same RVA in some cases. Issue the warning only // if the returned symbols actually differ. if (s.virtualAddress != s2.virtualAddress) { Shell.Error("Symbol " + symName + " has " + e.count + " matches. Taking first."); break; } } } return s; }
public static IDiaSymbol FindClassSymbol(String name, IDiaSymbol sym, SymTagEnum tag) { IDiaSymbol res = null; //Console.WriteLine("Looking for " + name + " in " + sym.name); res = Util.FindSymbol(name, sym, tag); if (res == null) { IDiaEnumSymbols e; sym.findChildren( SymTagEnum.SymTagBaseClass, null, (uint)NameSearchOptions.nsNone, out e); if (e == null || e.count == 0) return null; for (int i = 0; i < e.count && res == null; i++) { UInt32 celt; IDiaSymbol s; e.Next(1, out s, out celt); res = FindClassSymbol(name, s.type, tag); } } return res; }
/// <summary> /// Gets the child symbol. /// </summary> /// <param name="symbol">The symbol.</param> /// <param name="name">The name.</param> /// <param name="tag">The tag.</param> public static IDiaSymbol GetChild(this IDiaSymbol symbol, string name, SymTagEnum tag = SymTagEnum.SymTagNull) { IDiaEnumSymbols symbols; symbol.findChildren(tag, name, 0, out symbols); return symbols.Enum().FirstOrDefault(); }
public static IDiaSymbol FindClassSymbol(String name, IDiaSymbol sym, SymTagEnum tag) { IDiaSymbol res = null; //Console.WriteLine("Looking for " + name + " in " + sym.name); res = Util.FindSymbol(name, sym, tag); if (res == null) { IDiaEnumSymbols e; sym.findChildren( SymTagEnum.SymTagBaseClass, null, (uint)NameSearchOptions.nsNone, out e); if (e == null || e.count == 0) { return(null); } for (int i = 0; i < e.count && res == null; i++) { UInt32 celt; IDiaSymbol s; e.Next(1, out s, out celt); res = FindClassSymbol(name, s.type, tag); } } return(res); }
private IEnumerable <Symbol> CreateChildrenImpl(SymTagEnum symbolTagType, string symbolName, NameSearchOptions searchOptions) { IDiaEnumSymbols enumSymbols = null; try { _sym.findChildren(symbolTagType, symbolName, (uint)searchOptions, out enumSymbols); if (enumSymbols == null) { yield break; } while (true) { uint celt = 0; IDiaSymbol symbol; enumSymbols.Next(1, out symbol, out celt); if (celt != 1) { break; //No more symbols } yield return(Symbol.Create(symbol)); } } finally { if (enumSymbols != null) { Marshal.ReleaseComObject(enumSymbols); } } }
public static ComPtr<IDiaSymbol> GetSymbol(this IDiaSymbol symbol, SymTagEnum symTag, string name, Predicate<IDiaSymbol> filter = null) { var result = new ComPtr<IDiaSymbol>(); IDiaEnumSymbols enumSymbols; symbol.findChildren(symTag, name, 1, out enumSymbols); using (ComPtr.Create(enumSymbols)) { int n = enumSymbols.count; if (n == 0) { Debug.Fail("Symbol '" + name + "' was not found."); throw new ArgumentException(); } try { for (int i = 0; i < n; ++i) { using (var item = ComPtr.Create(enumSymbols.Item((uint)i))) { if (filter == null || filter(item.Object)) { if (result.Object == null) { result = item.Detach(); } else { Debug.Fail("Found more than one symbol named '" + name + "' and matching the filter."); throw new ArgumentException(); } } } } } catch { result.Dispose(); throw; } } return result; }
/// <summary> /// Gets the children. /// </summary> /// <param name="symbol">The symbol.</param> /// <param name="tag">The tag.</param> public static IEnumerable <IDiaSymbol> GetChildren(this IDiaSymbol symbol, SymTagEnum tag = SymTagEnum.SymTagNull) { IDiaEnumSymbols symbols; symbol.findChildren(tag, null, 0, out symbols); return(symbols.Enum()); }
/// <summary> /// Gets the child symbol. /// </summary> /// <param name="symbol">The symbol.</param> /// <param name="name">The name.</param> /// <param name="tag">The tag.</param> public static IDiaSymbol GetChild(this IDiaSymbol symbol, string name, SymTagEnum tag = SymTagEnum.SymTagNull) { IDiaEnumSymbols symbols; symbol.findChildren(tag, name, 0, out symbols); return(symbols.Enum().FirstOrDefault()); }
/// <summary> /// Converts <see cref="SymTagEnum"/> to <see cref="CodeTypeTag"/>. /// </summary> public static CodeTypeTag ConvertToCodeTypeTag(SymTagEnum tag) { switch (tag) { case SymTagEnum.ArrayType: return(CodeTypeTag.Array); case SymTagEnum.BaseType: return(CodeTypeTag.BuiltinType); case SymTagEnum.UDT: // TODO: What about Structure/Union? return(CodeTypeTag.Class); case SymTagEnum.Enum: return(CodeTypeTag.Enum); case SymTagEnum.FunctionType: return(CodeTypeTag.Function); case SymTagEnum.PointerType: return(CodeTypeTag.Pointer); case SymTagEnum.BaseClass: return(CodeTypeTag.BaseClass); case SymTagEnum.Exe: return(CodeTypeTag.ModuleGlobals); default: return(CodeTypeTag.Unsupported); } }
public static ComPtr <IDiaSymbol>[] GetSymbols(this IDiaSymbol symbol, SymTagEnum symTag, string name) { symbol.findChildren(symTag, name, 1, out IDiaEnumSymbols enumSymbols); using (ComPtr.Create(enumSymbols)) { int n = enumSymbols.count; ComPtr <IDiaSymbol>[] result = new ComPtr <IDiaSymbol> [n]; try { for (int i = 0; i < n; ++i) { result[i] = ComPtr.Create(enumSymbols.Item((uint)i)); } } catch { foreach (ComPtr <IDiaSymbol> item in result) { item.Dispose(); } throw; } return(result); } }
internal SymbolInformation(SymTagEnum tag, long size, int type_index, SymbolLoadedModule module, string name) { Name = name; Size = size; Module = module; TypeIndex = type_index; Type = MapType(tag); }
/// <summary> /// Gets the code type tag of the specified type. /// </summary> /// <param name="typeId">The type identifier.</param> public CodeTypeTag GetTypeTag(uint typeId) { using (ProcessSwitcher switcher = new ProcessSwitcher(DbgEngDll.StateCache, Module.Process)) { SymTagEnum symTag = DbgEngSymbolProvider.typedData[Tuple.Create(Module.Address, typeId, Module.Process.PebAddress)].Tag; return(symTag.ToCodeTypeTag()); } }
private bool CheckTypeTag(long module_base, int type_index, SymTagEnum tag) { var tag_check = GetSymbolTag(module_base, type_index); if (!tag_check.HasValue) { return(false); } return(tag_check.Value == tag); }
public int GetSymTag(out SymTagEnum symTagEnum) { symTagEnum = default(SymTagEnum); int _symTagEnum; int hr = S.StdCall <int>(GetVTableMember(4), Punk, out _symTagEnum); GC.KeepAlive(this); symTagEnum = (SymTagEnum)_symTagEnum; return(hr); }
public int FindSymbolByRVA(int rva, SymTagEnum symTag, out IDiaSymbol symbol) { symbol = null; IntPtr _symbol; int hr = S.StdCall<int>(GetVTableMember(14), Punk, rva, (int)symTag, out _symbol); GC.KeepAlive(this); if (hr != S_OK) return hr; symbol = new IDiaSymbol(_symbol); return hr; }
private IDiaSymbol FindSymbol(SymTagEnum symTag, string symbolName) { foreach (var pdb in pdbEntries) { var result = pdb.session.findChildren(pdb.session.globalScope, symTag, symbolName, NameSearchOptions.CaseSensitive); if (result.count > 0) { return(result.Item(0)); } } throw new KeyNotFoundException(); }
/// <summary> /// Gets all children for this symbol /// </summary> /// <param name="parent"></param> /// <param name="symTag"></param> /// <returns></returns> public static IEnumerable<IDiaSymbol> EnumerateChildren(this IDiaSymbol parent, SymTagEnum symTag) { IDiaEnumSymbols enumSymbols; parent.findChildren(symTag, null, 0, out enumSymbols); IDiaSymbol curSymbol; uint fetched; enumSymbols.Next(1, out curSymbol, out fetched); while (fetched == 1) { yield return curSymbol; enumSymbols.Next(1, out curSymbol, out fetched); } }
private String GetBoundString(IDiaSymbol bound) { SymTagEnum tag = (SymTagEnum)bound.symTag; LocationType kind = (LocationType)bound.locationType; System.Diagnostics.Debugger.Break(); if (tag == SymTagEnum.SymTagData && kind == LocationType.LocIsConstant) { return(GetVariantString(bound.value)); } return(bound.name); }
public static ComPtr<IDiaSymbol> FindChildSymbol(ComPtr<IDiaSymbol> parent, SymTagEnum tag, string name) { var result = new ComPtr<IDiaSymbol>(); IDiaEnumSymbols enumerator; parent.Ptr.findChildren(tag, name, 1, out enumerator); using (ComPtr.Create(enumerator)) { if (enumerator.count == 0) return new ComPtr<IDiaSymbol>(); result = ComPtr.Create(enumerator.Item((uint)0)); } return result; }
public DiaSymbol FindSymbolByRVA(IntPtr rva, SymTagEnum symTag) { int hr; IDiaSymbol symbol; hr = session.findSymbolByRVA((uint)rva, symTag, out symbol); if (hr != VSConstants.S_OK) { Marshal.ThrowExceptionForHR(hr); } return(new DiaSymbol(symbol)); }
public int FindSymbolByRVA(int rva, SymTagEnum symTag, out IDiaSymbol symbol) { symbol = null; IntPtr _symbol; int hr = S.StdCall <int>(GetVTableMember(14), Punk, rva, (int)symTag, out _symbol); GC.KeepAlive(this); if (hr != S_OK) { return(hr); } symbol = new IDiaSymbol(_symbol); return(hr); }
internal static IDiaSymbol TryGetDiaSymbol(IDiaSymbol symbol, SymTagEnum symTag, string name, out string error) { symbol.findChildren(symTag, name, 1, out IDiaEnumSymbols enumSymbols); if (enumSymbols.count != 1) { error = $"TryGetDiaSymbols() enumSymbols.count {enumSymbols.count} != 1"; ReleaseComObject(enumSymbols); return(null); } error = null; return(enumSymbols.Item(0u)); }
public async Task <SSymbolNameAndDisplacement> LookupSymbolName(ulong pointer) { try { SModule module = await this.debuggerEngine.GetModuleForAddress(pointer); Dia2Lib.IDiaSession session = await this.debuggerEngine.DiaLoader.LoadDiaSession(module.Name); if (session != null) { // We have a DIA session; use it. Dia2Lib.IDiaSymbol symbol; ulong rva = pointer - module.BaseAddress; session.findSymbolByRVA((uint)rva, Dia2Lib.SymTagEnum.SymTagNull, out symbol); // Blocks don't have names. Walk up to the nearest non-block parent. while ((Dia2Lib.SymTagEnum)symbol.symTag == Dia2Lib.SymTagEnum.SymTagBlock) { symbol = symbol.lexicalParent; } SymTagEnum symTag = (SymTagEnum)symbol.symTag; string name; if (symTag == SymTagEnum.SymTagPublicSymbol || symTag == SymTagEnum.SymTagThunk) { // Public symbols have decorated names that need to be undecorated (see dbghelp!diaFillSymbolInfo). symbol.get_undecoratedNameEx(0x1000, out name); } else { name = symbol.name; } return(new SSymbolNameAndDisplacement() { Module = module.Name, Name = name, Displacement = (ulong)(rva - symbol.relativeVirtualAddress) }); } else { return(await this.debuggerEngine.LookupSymbolName(pointer)); } } catch { throw new DebuggerException(String.Format("Invalid symbol address: 0x{0:x8}", pointer)); } }
void IDiaSession.findChildren(IDiaSymbol parent, SymTagEnum symTag, string name, uint compareFlags, out IDiaEnumSymbols ppResult) { dynamic typ = null; if (!Dia3.StructCache.ContainsKey(name)) { var json = SymAPI.TypeDef(name, CV); var converter = new Newtonsoft.Json.Converters.ExpandoObjectConverter(); var obj = JsonConvert.DeserializeObject <List <ExpandoObject> >(json.Result, converter); // we access just the first object back Dia3.StructCache.TryAdd(name, obj.First()); } Dia3.StructCache.TryGetValue(name, out typ); ppResult = new EnumSymbols(CV, EnumSymType.Sym, typ); return; }
private static SymbolInformationType MapType(SymTagEnum tag) { switch (tag) { case SymTagEnum.SymTagUDT: return(SymbolInformationType.UserDefinedType); case SymTagEnum.SymTagEnum: return(SymbolInformationType.EnumeratedType); case SymTagEnum.SymTagBaseType: return(SymbolInformationType.BaseType); default: return(SymbolInformationType.UndefinedType); } }
private TypeInformation CreateType(TypeInformationCache type_cache, SymTagEnum tag, long module_base, int index, long size, SymbolLoadedModule module, string name, long address = 0) { if (type_cache.HasEntry(module_base, index)) { return(type_cache.GetEntry(module_base, index)); } TypeInformation ret; switch (tag) { case SymTagEnum.SymTagUDT: ret = CreateUserDefinedType(type_cache, module_base, index, module, name); break; case SymTagEnum.SymTagEnum: ret = CreateEnumType(type_cache, module_base, index, module, name); break; case SymTagEnum.SymTagBaseType: ret = CreateBaseType(type_cache, module_base, index, module); break; case SymTagEnum.SymTagPointerType: ret = CreatePointerType(type_cache, module_base, index, module); break; case SymTagEnum.SymTagArrayType: ret = CreateArrayType(type_cache, module_base, index, module); break; case SymTagEnum.SymTagFunction: ret = CreateFunctionType(type_cache, module_base, index, module, name, address); break; default: Debug.WriteLine(tag.ToString()); ret = new TypeInformation(tag, size, index, module, name); break; } type_cache.AddEntry(module_base, index, ret); return(ret); }
public static ComPtr <IDiaSymbol> GetSymbol(this IDiaSymbol symbol, SymTagEnum symTag, string name, Predicate <IDiaSymbol> filter = null) { ComPtr <IDiaSymbol> result = new ComPtr <IDiaSymbol>(); symbol.findChildren(symTag, name, 1, out IDiaEnumSymbols enumSymbols); using (ComPtr.Create(enumSymbols)) { int n = enumSymbols.count; if (n == 0) { Debug.Fail("Symbol '" + name + "' was not found."); throw new ArgumentException(); } try { for (int i = 0; i < n; ++i) { using (ComPtr <T> item = ComPtr.Create(enumSymbols.Item((uint)i))) { if (filter == null || filter(item.Object)) { if (result.Object == null) { result = item.Detach(); } else { Debug.Fail("Found more than one symbol named '" + name + "' and matching the filter."); throw new ArgumentException(); } } } } } catch { result.Dispose(); throw; } } return(result); }
private ConstantCache LoadGlobalConstantsFromDiaSession(IDiaSession diaSession) { List <SConstantResult> constants = new List <SConstantResult>(); diaSession.findChildren(diaSession.globalScope, SymTagEnum.SymTagData, null, 0, out IDiaEnumSymbols symbols); foreach (IDiaSymbol symbol in symbols) { SymTagEnum symTag = (SymTagEnum)symbol.symTag; if (symbol.locationType == (uint)DiaHelpers.LocationType.LocIsConstant) { constants.Add(new SConstantResult() { ConstantName = symbol.name, Value = (ulong)symbol.value }); } } return(new ConstantCache(constants)); }
public static ComPtr<IDiaSymbol>[] GetSymbols(this IDiaSymbol symbol, SymTagEnum symTag, string name) { IDiaEnumSymbols enumSymbols; symbol.findChildren(symTag, name, 1, out enumSymbols); using (ComPtr.Create(enumSymbols)) { int n = enumSymbols.count; var result = new ComPtr<IDiaSymbol>[n]; try { for (int i = 0; i < n; ++i) { result[i] = ComPtr.Create(enumSymbols.Item((uint)i)); } } catch { foreach (var item in result) { item.Dispose(); } throw; } return result; } }
public int FindChildren(IDiaSymbol parent, SymTagEnum symTag, String name, NameSearchOptions compareFlags, out IDiaEnumSymbols enumSymbols) { enumSymbols = null; IntPtr _enumSymbols; int hr; unsafe { fixed (char* _name = name) { hr = S.StdCall<int>(GetVTableMember(8), Punk, parent.Punk, (int)symTag, _name, (int)compareFlags, out _enumSymbols); } } GC.KeepAlive(this); GC.KeepAlive(parent); if (hr != S_OK) return hr; enumSymbols = new IDiaEnumSymbols(_enumSymbols); return hr; }
public DiaSymbol FindClassSymbol(String name, SymTagEnum tag) { DiaSymbol res = null; IDiaSymbol sym = Util.FindClassSymbol(name, m_symbol, tag); if (sym != null) { if ((SymTagEnum)sym.symTag == SymTagEnum.SymTagData) { res = new DiaDataSymbol(sym); } else { res = new DiaSymbol(sym); } } return(res); }
public unsafe int FindChildren(IDiaSymbol parent, SymTagEnum symTag, string name, NameSearchOptions compareFlags, out IDiaEnumSymbols enumSymbols) { enumSymbols = null; IntPtr _enumSymbols; int hr; fixed(char *_name = name) { hr = S.StdCall <int>(GetVTableMember(8), Punk, parent.Punk, (int)symTag, _name, (int)compareFlags, out _enumSymbols); } GC.KeepAlive(this); GC.KeepAlive(parent); if (hr != S_OK) { return(hr); } enumSymbols = new IDiaEnumSymbols(_enumSymbols); return(hr); }
/// <summary> /// Gets the stack frame locals. /// </summary> /// <param name="block">The block.</param> /// <param name="relativeAddress">The relative address or uint.MaxValue if only first children are desired.</param> /// <param name="variables">The variables.</param> /// <param name="frame">The frame.</param> /// <param name="module">The module.</param> /// <param name="arguments">if set to <c>true</c> only arguments will be returned.</param> private static void GetFrameLocals(IDiaSymbol block, uint relativeAddress, List <Variable> variables, StackFrame frame, Module module, bool arguments) { IEnumerable <IDiaSymbol> symbols; if (relativeAddress != uint.MaxValue) { IDiaEnumSymbols symbolsEnum = block.findChildrenExByRVA(SymTagEnum.Null, null, 0, relativeAddress); symbols = symbolsEnum.Enum(); } else { symbols = block.GetChildren(SymTagEnum.Data); } foreach (var symbol in symbols) { SymTagEnum tag = symbol.symTag; if (tag == SymTagEnum.Data) { DataKind symbolDataKind = symbol.dataKind; if ((arguments && symbolDataKind != DataKind.Param) || symbol.locationType == LocationType.Null) { continue; } } else if (tag != SymTagEnum.FunctionArgType || !arguments) { continue; } CodeType codeType = module.TypesById[symbol.typeId]; ulong address = ResolveAddress(module.Process, symbol, frame.FrameContext); var variableName = symbol.name; variables.Add(Variable.CreateNoCast(codeType, address, variableName, variableName)); } }
public static IDiaSymbol FindSymbol(String symName, IDiaSymbol parent, SymTagEnum symTag) { IDiaEnumSymbols e; parent.findChildren(symTag, symName, (uint)(NameSearchOptions.nsfCaseSensitive), out e); IDiaSymbol s; uint celt; if (e == null || e.count == 0) { return(null); } e.Next(1, out s, out celt); if (e.count > 1) { for (int i = 1; i < e.count; i++) { IDiaSymbol s2; e.Next(1, out s2, out celt); // Diasym reader returns multiple symbols with same RVA in some cases. Issue the warning only // if the returned symbols actually differ. if (s.virtualAddress != s2.virtualAddress) { Shell.Error("Symbol " + symName + " has " + e.count + " matches. Taking first."); break; } } } return(s); }
public DiaSymbol FindClassSymbol(String name, SymTagEnum tag) { DiaSymbol res = null; IDiaSymbol sym = Util.FindClassSymbol(name, m_symbol, tag); if (sym != null) { if ((SymTagEnum)sym.symTag == SymTagEnum.SymTagData) res = new DiaDataSymbol(sym); else res = new DiaSymbol(sym); } return res; }
/// <summary> /// Gets the code type tag of the specified type. /// </summary> /// <param name="typeId">The type identifier.</param> public CodeTypeTag GetTypeTag(uint typeId) { SymTagEnum symTag = GetTypeFromId(typeId).symTag; return(symTag.ToCodeTypeTag()); }
private String GetTypeString(IDiaSymbol s) { SymTagEnum tag = (SymTagEnum)s.symTag; if (tag == SymTagEnum.SymTagData || tag == SymTagEnum.SymTagTypedef) { s = s.type; tag = (SymTagEnum)s.symTag; } StringBuilder str = new StringBuilder(); if (s.name != null) { str.Append(s.name); } else if (tag == SymTagEnum.SymTagPointerType) { str.Append(GetTypeString(s.type)); str.Append("*"); } else if (tag == SymTagEnum.SymTagBaseType) { BasicType bt = (BasicType)s.baseType; str.AppendFormat("(base type={0}, len={1:d})", bt.ToString(), s.length); } else if (tag == SymTagEnum.SymTagArrayType) { str.Append(GetTypeString(s.type)); bool succ = true; int i; try { UInt32 rank = s.rank; IDiaEnumSymbols e; s.findChildren(SymTagEnum.SymTagDimension, null, (UInt32)NameSearchOptions.nsNone, out e); for (i = 0; i < e.count; i++) { IDiaSymbol ds; UInt32 celt; e.Next(1, out ds, out celt); str.Append("[" + GetBoundString(ds.lowerBound) + ".." + GetBoundString(ds.upperBound) + "]"); } } catch (Exception) { succ = false; } if (succ == false) { try { succ = true; IDiaEnumSymbols e; s.findChildren(SymTagEnum.SymTagCustomType, null, (UInt32)NameSearchOptions.nsNone, out e); for (i = 0; i < e.count; i++) { IDiaSymbol ds; UInt32 celt; e.Next(1, out ds, out celt); str.Append("[" + GetTypeString(ds) + "]"); } } catch (Exception) { succ = false; } } if (succ == false) { try { succ = true; str.AppendFormat("[{0:d}]", s.length / s.type.length); } catch (Exception) { succ = false; } } } else if (tag == SymTagEnum.SymTagFunctionType) { str.Append("Function Type"); } else if (tag == SymTagEnum.SymTagCustomType) { throw new Exception("NYI"); /* * str.Append("Custom Type: "); * try * { * str.Append(s.guid.ToString()); * } * catch (Exception e) * { * try * { * str.AppendFormat("{0:x}:{0:x}", s.oemId, s.oemSymbolId); * } * catch (Exception) * { * } * } * DWORD len = 0; * if ( s.get_types( 0, &len, NULL ) == S_OK && len > 0 ) { * IDiaSymbol** psyms = new IDiaSymbol*[ len ]; * s.get_types( len, &len, psyms ); * for ( DWORD i = 0; i < len; ++i ) { * printf( " <" ); * printType( psyms[i] ); * printf( ">" ); * psyms[i]->Release(); * } * delete [] psyms; * } * len = 0; * if ( s.get_dataBytes( 0, &len, NULL ) == S_OK && len > 0 ) { * BYTE* pdata = new BYTE[ len ]; * s.get_dataBytes( len, &len, pdata ); * printf( "<data" ); * for ( DWORD i = 0; i < len; ++i ) { * printf( " %02x", pdata[i] ); * } * printf( " data>" ); * delete [] pdata; * } */ } else { str.Append("No Type."); } return(str.ToString()); }
/// <summary>Creates symbols which are children of this symbol of the specified type.</summary> /// <param name="symbolTagType">Type of the symbols to retrieve.</param> /// <returns>The symbols that are a child of this symbol and have tag <paramref name="symbolTagType"/>.</returns> public DisposableEnumerable<Symbol> CreateChildIterator(SymTagEnum symbolTagType) { return this.CreateChildren(symbolTagType, null, NameSearchOptions.nsNone); }
public DisposableEnumerable<Symbol> CreateChildren(SymTagEnum symbolTagType, string symbolName, NameSearchOptions searchOptions) { this.AssertNotDisposed(); return new DisposableEnumerable<Symbol>(this.CreateChildrenImpl(symbolTagType, symbolName, searchOptions)); }
private IEnumerable<Symbol> CreateChildrenImpl(SymTagEnum symbolTagType, string symbolName, NameSearchOptions searchOptions) { IDiaEnumSymbols enumSymbols = null; try { _sym.findChildren(symbolTagType, symbolName, (uint)searchOptions, out enumSymbols); if (enumSymbols == null) { yield break; } while (true) { uint celt = 0; IDiaSymbol symbol; enumSymbols.Next(1, out symbol, out celt); if (celt != 1) break; //No more symbols yield return Symbol.Create(symbol); } } finally { if (enumSymbols != null) { Marshal.ReleaseComObject(enumSymbols); } } }
/// <summary> /// Gets the children using wildcard search: Applies a case-sensitive name match using asterisks (*) and question marks (?) as wildcards. /// </summary> /// <param name="symbol">The symbol.</param> /// <param name="nameWildcard">The name wildcard.</param> /// <param name="tag">The tag.</param> public static IEnumerable<IDiaSymbol> GetChildrenWildcard(this IDiaSymbol symbol, string nameWildcard, SymTagEnum tag = SymTagEnum.SymTagNull) { IDiaEnumSymbols symbols; const uint nsfRegularExpression = 0x8; // https://msdn.microsoft.com/en-us/library/yat28ads.aspx symbol.findChildren(tag, nameWildcard, nsfRegularExpression, out symbols); return symbols.Enum(); }
public int GetSymTag(out SymTagEnum symTagEnum) { symTagEnum = default(SymTagEnum); int _symTagEnum; int hr = S.StdCall<int>(GetVTableMember(4), Punk, out _symTagEnum); GC.KeepAlive(this); symTagEnum = (SymTagEnum)_symTagEnum; return hr; }