/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
public SymbolResult(ulong address, TextInfo text)
{
Address = address;
Text = text;
Flags = SymbolFlags.None;
SymbolSize = MemorySize.Unknown;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
/// <param name="size">Symbol size</param>
public SymbolResult(ulong address, string text, MemorySize size)
{
Address = address;
Text = new TextInfo(text, FormatterTextKind.Label);
Flags = SymbolFlags.HasSymbolSize;
SymbolSize = size;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
/// <param name="color">Color</param>
/// <param name="flags">Symbol flags</param>
public SymbolResult(ulong address, string text, FormatterTextKind color, SymbolFlags flags)
{
Address = address;
Text = new TextInfo(text, color);
Flags = flags & ~SymbolFlags.HasSymbolSize;
SymbolSize = MemorySize.Unknown;
}
public SymbolEntry(uint Value, SymbolFlags Flags,
String Section, int Size, String Name)
{
this.Value = Value;
this.Flags = Flags;
this.Section = Section;
this.Size = Size;
this.Name = Name;
}
/// <summary>
/// Creates a new symbol entry.
/// </summary>
/// <param name="value">The symbol's integer value.</param>
/// <param name="flags">The symbol's flags.</param>
/// <param name="section">The section in which the symbol is declared.</param>
/// <param name="size">The size or alignment of the symbol.</param>
/// <param name="name">The unique name of the symbol.</param>
public SymbolEntry(long value, SymbolFlags flags,
String section, int size, String name)
{
this.Value = value;
this.Flags = flags;
this.Section = section;
this.Size = size;
this.Name = name;
}
public SymbolResultTestCase(ulong address, ulong symbolAddress, int addressSize, SymbolFlags flags, MemorySize?memorySize, string[] symbolParts)
{
Address = address;
SymbolAddress = symbolAddress;
AddressSize = addressSize;
Flags = flags;
MemorySize = memorySize;
SymbolParts = symbolParts;
}
public static IEnumerable <SymbolFilterRule> FromFlags(SymbolFlags flags, bool invert = false)
{
if ((flags & SymbolFlags.Const) != 0)
{
yield return((invert) ? IsNotConst : IsConst);
}
if ((flags & SymbolFlags.Static) != 0)
{
yield return((invert) ? IsNotStatic : IsStatic);
}
if ((flags & SymbolFlags.Virtual) != 0)
{
yield return((invert) ? IsNotVirtual : IsVirtual);
}
if ((flags & SymbolFlags.Sealed) != 0)
{
yield return((invert) ? IsNotSealed : IsSealed);
}
if ((flags & SymbolFlags.Override) != 0)
{
yield return((invert) ? IsNotOverride : IsOverride);
}
if ((flags & SymbolFlags.Abstract) != 0)
{
yield return((invert) ? IsNotAbstract : IsAbstract);
}
if ((flags & SymbolFlags.ReadOnly) != 0)
{
yield return((invert) ? IsNotReadOnly : IsReadOnly);
}
if ((flags & SymbolFlags.Extern) != 0)
{
yield return((invert) ? IsNotExtern : IsExtern);
}
if ((flags & SymbolFlags.Async) != 0)
{
yield return((invert) ? IsNotAsync : IsAsync);
}
if ((flags & SymbolFlags.Extension) != 0)
{
yield return((invert) ? IsNotExtension : IsExtension);
}
}
public static SymbolFlags SetFlag(this SymbolFlags flags, SymbolFlags flag, bool value)
{
int flagsInt = (int)flags;
int flagInt = (int)flag;
if (value)
{
flagsInt |= flagInt;
}
else
{
flagsInt &= ~flagInt;
}
return((SymbolFlags)flagsInt);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
/// <param name="color">Color</param>
/// <param name="flags">Symbol flags</param>
public SymbolResult(ulong address, string text, FormatterOutputTextKind color, SymbolFlags flags)
{
Address = address;
Text = new TextInfo(text, color);
Flags = flags & ~SymbolFlags.HasSymbolSize;
SymbolSize = 0;
}
public string GetSymbolFromAddress(ulong address, out SymbolResolveLevel level, out SymbolFlags flags, out string fileName, out string symbolName, out ulong displacement)
{
// Assume failure (and stop the compiler from complaining).
if (address == 0)
{
level = SymbolResolveLevel.Invalid;
flags = 0;
fileName = null;
}
// Allocate some memory for the symbol information.
using (var data = new MemoryAlloc(Marshal.SizeOf(typeof(SymbolInfo)) + _maxNameLen))
{
var info = new SymbolInfo();
info.SizeOfStruct = Marshal.SizeOf(info);
info.MaxNameLen = _maxNameLen - 1;
Marshal.StructureToPtr(info, data, false);
// Hack for drivers, since we don't get their module sizes.
// Preloading modules will fix this.
if (this.PreloadModules)
{
ulong b;
this.GetModuleFromAddress(address, out b);
using (Win32.DbgHelpLock.AcquireContext())
Win32.SymFromAddr(_handle, b, out displacement, data);
Marshal.StructureToPtr(info, data, false);
}
// Get the symbol name.
using (Win32.DbgHelpLock.AcquireContext())
{
if (Win32.SymFromAddr(_handle, address, out displacement, data))
{
info = data.ReadStruct<SymbolInfo>();
}
}
string modFileName;
ulong modBase;
// Get the module name.
if (info.ModBase == 0)
{
modFileName = this.GetModuleFromAddress(address, out modBase);
}
else
{
modBase = info.ModBase;
lock (_modules)
modFileName = _modules.Find(kvp => kvp.Key == info.ModBase).Value;
}
// If we don't have a module name, return an address.
if (modFileName == null)
{
level = SymbolResolveLevel.Address;
flags = 0;
fileName = null;
symbolName = null;
return Utils.FormatAddress(address);
}
FileInfo fi = null;
fileName = modFileName;
try
{
fi = new FileInfo(modFileName);
fileName = fi.FullName;
}
catch
{ }
// If we have a module name but not a symbol name,
// return a module plus an offset: module+offset.
if (info.NameLen == 0)
{
level = SymbolResolveLevel.Module;
flags = 0;
symbolName = null;
if (fi != null)
{
return fi.Name + "+0x" + (address - modBase).ToString("x");
}
else
{
var s = modFileName.Split('\\');
return s[s.Length - 1] + "+0x" + (address - modBase).ToString("x");
}
}
// If we have everything, return the full symbol name: module!symbol+offset.
string name = data.ReadAnsiString(SymbolInfo.NameOffset, info.NameLen);
level = SymbolResolveLevel.Function;
flags = info.Flags;
symbolName = name;
if (displacement == 0)
return fi.Name + "!" + name;
else
return fi.Name + "!" + name + "+0x" + displacement.ToString("x");
}
}
public string GetSymbolFromAddress(ulong address, out SymbolFlags flags)
{
SymbolResolveLevel level;
string fileName;
return this.GetSymbolFromAddress(address, out level, out flags, out fileName);
}
public string GetSymbolFromAddress(ulong address, out SymbolResolveLevel level, out SymbolFlags flags, out string fileName)
{
string symbolName;
ulong displacement;
return(this.GetSymbolFromAddress(address, out level, out flags, out fileName, out symbolName, out displacement));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
public SymbolResult(ulong address, TextInfo text)
{
Address = address;
Text = text;
Flags = 0;
}
public static TCSymbol NewVariable(TypeData type, ESIR_Expression expr, SymbolFlags flags = 0) => new (new (type, expr), flags);
public bool HasFlag(SymbolFlags flag)
{
return((flags & (int)flag) != 0);
}
void ISymbolDisplayBuilder.BuildSymbolDisplay(ISymbol symbol, ISymbolWriter writer, INode enclosingDeclaration, SymbolFlags meaning, SymbolFormatFlags flags)
{
BuildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags, typeFlags: TypeFormatFlags.None);
}
/// <summary>
/// Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
/// Meaning needs to be specified if the enclosing declaration is given
/// </summary>
private void BuildSymbolDisplay(ISymbol inputSymbol, ISymbolWriter writer, INode enclosingDeclaration = null, SymbolFlags inputMeaning = SymbolFlags.None, SymbolFormatFlags flags = SymbolFormatFlags.None, TypeFormatFlags typeFlags = TypeFormatFlags.None)
{
Contract.Assert(inputSymbol != null);
Contract.Assert(writer != null);
// HINT: To simplify migration we're using "local" functions via delegates.
// This code could be changed in the future, once C# would have local functions.
Action <ISymbol, SymbolFlags> walkSymbol = null;
ISymbol parentSymbol = null;
Action <ISymbol> appendParentTypeArgumentsAndSymbolName = null;
appendParentTypeArgumentsAndSymbolName = (ISymbol symbol) =>
{
if (parentSymbol != null)
{
// Write type arguments of instantiated class/interface here
if ((flags & SymbolFormatFlags.WriteTypeParametersOrArguments) != SymbolFormatFlags.None)
{
if ((symbol.Flags & SymbolFlags.Instantiated) != SymbolFlags.None)
{
// TODO: check types to avoid redundant ToArray call.
BuildDisplayForTypeArgumentsAndDelimiters(
m_checker.GetTypeParametersOfClassOrInterface(parentSymbol),
((ITransientSymbol)symbol).Mapper, writer, enclosingDeclaration);
}
else
{
BuildTypeParameterDisplayFromSymbol(parentSymbol, writer, enclosingDeclaration);
}
}
WritePunctuation(writer, SyntaxKind.DotToken);
}
parentSymbol = symbol;
AppendSymbolNameOnly(symbol, writer);
};
// Let the writer know we just wrote out a symbol. The declaration emitter writer uses
// this to determine if an import it has previously seen (and not written out) needs
// to be written to the file once the walk of the tree is complete.
//
// NOTE(cyrusn): This approach feels somewhat unfortunate. A simple pass over the tree
// up front (for example, during checking) could determine if we need to emit the imports
// and we could then access that data during declaration emit.
writer.TrackSymbol(inputSymbol, enclosingDeclaration, inputMeaning);
walkSymbol = (ISymbol symbol, SymbolFlags meaning) =>
{
if (symbol != null)
{
var accessibleSymbolChain = m_checker.GetAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, (flags & SymbolFormatFlags.UseOnlyExternalAliasing) != SymbolFormatFlags.None);
if (accessibleSymbolChain == null ||
m_checker.NeedsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.Count == 1 ? meaning : GetQualifiedLeftMeaning(meaning)))
{
// Go up and add our parent.
walkSymbol(
m_checker.GetParentOfSymbol(accessibleSymbolChain != null ? accessibleSymbolChain[0] : symbol),
GetQualifiedLeftMeaning(meaning));
}
if (accessibleSymbolChain != null)
{
foreach (var accessibleSymbol in accessibleSymbolChain)
{
appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
}
}
else
{
// If we didn't find accessible symbol chain for this symbol, break if this is external module
if (parentSymbol == null && symbol.DeclarationList.Any(n => HasExternalModuleSymbol(n)))
{
return;
}
// if this is anonymous type break
if ((symbol.Flags & SymbolFlags.TypeLiteral) != SymbolFlags.None || (symbol.Flags & SymbolFlags.ObjectLiteral) != SymbolFlags.None)
{
return;
}
appendParentTypeArgumentsAndSymbolName(symbol);
}
}
};
// Get qualified name if the symbol is not a type parameter
// and there is an enclosing declaration or we specifically
// asked for it
var isTypeParameter = inputSymbol.Flags & SymbolFlags.TypeParameter;
var typeFormatFlag = TypeFormatFlags.UseFullyQualifiedType & typeFlags;
if (isTypeParameter == SymbolFlags.None && (enclosingDeclaration != null || typeFormatFlag != TypeFormatFlags.None))
{
walkSymbol(inputSymbol, inputMeaning);
return;
}
appendParentTypeArgumentsAndSymbolName(inputSymbol);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
/// <param name="flags">Symbol flags</param>
public SymbolResult(ulong address, TextInfo text, SymbolFlags flags)
{
Address = address;
Text = text;
Flags = flags;
}
public string GetSymbolFromAddress(ulong address, out SymbolResolveLevel level, out SymbolFlags flags, out string fileName, out string symbolName, out ulong displacement)
{
// Assume failure (and stop the compiler from complaining).
if (address == 0)
{
level = SymbolResolveLevel.Invalid;
flags = 0;
fileName = null;
}
// Allocate some memory for the symbol information.
using (var data = new MemoryAlloc(Marshal.SizeOf(typeof(SymbolInfo)) + _maxNameLen))
{
var info = new SymbolInfo();
info.SizeOfStruct = Marshal.SizeOf(info);
info.MaxNameLen = _maxNameLen - 1;
Marshal.StructureToPtr(info, data, false);
// Hack for drivers, since we don't get their module sizes.
// Preloading modules will fix this.
if (this.PreloadModules)
{
ulong b;
this.GetModuleFromAddress(address, out b);
using (Win32.DbgHelpLock.AcquireContext())
Win32.SymFromAddr(_handle, b, out displacement, data);
Marshal.StructureToPtr(info, data, false);
}
// Get the symbol name.
using (Win32.DbgHelpLock.AcquireContext())
{
if (Win32.SymFromAddr(_handle, address, out displacement, data))
{
info = data.ReadStruct <SymbolInfo>();
}
}
string modFileName;
ulong modBase;
// Get the module name.
if (info.ModBase == 0)
{
modFileName = this.GetModuleFromAddress(address, out modBase);
}
else
{
modBase = info.ModBase;
lock (_modules)
modFileName = _modules.Find(kvp => kvp.Key == info.ModBase).Value;
}
// If we don't have a module name, return an address.
if (modFileName == null)
{
level = SymbolResolveLevel.Address;
flags = 0;
fileName = null;
symbolName = null;
return(Utils.FormatAddress(address));
}
FileInfo fi = null;
fileName = modFileName;
try
{
fi = new FileInfo(modFileName);
fileName = fi.FullName;
}
catch
{ }
// If we have a module name but not a symbol name,
// return a module plus an offset: module+offset.
if (info.NameLen == 0)
{
level = SymbolResolveLevel.Module;
flags = 0;
symbolName = null;
if (fi != null)
{
return(fi.Name + "+0x" + (address - modBase).ToString("x"));
}
else
{
var s = modFileName.Split('\\');
return(s[s.Length - 1] + "+0x" + (address - modBase).ToString("x"));
}
}
// If we have everything, return the full symbol name: module!symbol+offset.
string name = data.ReadAnsiString(SymbolInfo.NameOffset, info.NameLen);
level = SymbolResolveLevel.Function;
flags = info.Flags;
symbolName = name;
if (displacement == 0)
{
return(fi.Name + "!" + name);
}
else
{
return(fi.Name + "!" + name + "+0x" + displacement.ToString("x"));
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
public SymbolResult(ulong address, string text)
{
Address = address;
Text = new TextInfo(text, FormatterOutputTextKind.Label);
Flags = 0;
}
public string GetSymbolFromAddress(ulong address, out SymbolResolveLevel level, out SymbolFlags flags, out string fileName)
{
string symbolName;
ulong displacement;
return this.GetSymbolFromAddress(address, out level, out flags, out fileName, out symbolName, out displacement);
}
public static T WithFlags <T>(this T symbol, SymbolFlags flags) where T : Symbol
{
symbol.Flags |= flags;
return(symbol);
}
public static void Write(this BinaryWriter writer, SymbolFlags flags)
{
int i = (int)flags;
writer.Write(i);
}
public string GetSymbolFromAddress(ulong address, out SymbolResolveLevel level, out SymbolFlags flags, out string fileName, out string symbolName, out ulong displacement)
{
if (address == 0)
{
level = SymbolResolveLevel.Invalid;
flags = 0;
fileName = null;
}
using (var data = new MemoryAlloc(Marshal.SizeOf(typeof(SymbolInfo)) + _maxNameLen))
{
var info = new SymbolInfo();
info.SizeOfStruct = Marshal.SizeOf(info);
info.MaxNameLen = _maxNameLen - 1;
Marshal.StructureToPtr(info, data, false);
if (this.PreloadModules)
{
ulong b;
this.GetModuleFromAddress(address, out b);
using (Win32.DbgHelpLock.AcquireContext())
Win32.SymFromAddr(_handle, b, out displacement, data);
Marshal.StructureToPtr(info, data, false);
}
using (Win32.DbgHelpLock.AcquireContext())
{
if (Win32.SymFromAddr(_handle, address, out displacement, data))
{
info = data.ReadStruct<SymbolInfo>();
}
}
string modFileName;
ulong modBase;
if (info.ModBase == 0)
{
modFileName = this.GetModuleFromAddress(address, out modBase);
}
else
{
modBase = info.ModBase;
lock (_modules)
modFileName = _modules.Find(kvp => kvp.Key == info.ModBase).Value;
}
if (modFileName == null)
{
level = SymbolResolveLevel.Address;
flags = 0;
fileName = null;
symbolName = null;
return Utils.FormatAddress(address);
}
FileInfo fi = null;
fileName = modFileName;
try
{
fi = new FileInfo(modFileName);
fileName = fi.FullName;
}
catch
{ }
if (info.NameLen == 0)
{
level = SymbolResolveLevel.Module;
flags = 0;
symbolName = null;
if (fi != null)
{
return fi.Name + "+0x" + (address - modBase).ToString("x");
}
else
{
var s = modFileName.Split('\\');
return s[s.Length - 1] + "+0x" + (address - modBase).ToString("x");
}
}
string name = Marshal.PtrToStringAnsi(data.Memory.Increment(Win32.SymbolInfoNameOffset), info.NameLen);
level = SymbolResolveLevel.Function;
flags = info.Flags;
symbolName = name;
if (displacement == 0)
return fi.Name + "!" + name;
else
return fi.Name + "!" + name + "+0x" + displacement.ToString("x");
}
}
