public void SafeReadSymbols(AssemblyDefinition assembly)
{
if (!_linkSymbols)
{
return;
}
if (assembly.MainModule.HasSymbols)
{
return;
}
try {
if (_symbolReaderProvider != null)
{
var symbolReader = _symbolReaderProvider.GetSymbolReader(
assembly.MainModule,
assembly.MainModule.FileName);
_annotations.AddSymbolReader(assembly, symbolReader);
assembly.MainModule.ReadSymbols(symbolReader);
}
else
{
assembly.MainModule.ReadSymbols();
}
} catch {}
}
public virtual void SafeReadSymbols(AssemblyDefinition assembly)
{
if (assembly.MainModule.HasSymbols)
{
return;
}
if (_symbolReaderProvider == null)
{
throw new ArgumentNullException(nameof(_symbolReaderProvider));
}
try {
var symbolReader = _symbolReaderProvider.GetSymbolReader(
assembly.MainModule,
assembly.MainModule.FileName);
if (symbolReader == null)
{
return;
}
_annotations.AddSymbolReader(assembly, symbolReader);
assembly.MainModule.ReadSymbols(symbolReader);
} catch { }
}
public virtual void SafeReadSymbols(AssemblyDefinition assembly)
{
if (assembly.MainModule.HasSymbols)
{
return;
}
if (_symbolReaderProvider == null)
{
throw new ArgumentNullException(nameof(_symbolReaderProvider));
}
try {
var symbolReader = _symbolReaderProvider.GetSymbolReader(
assembly.MainModule,
assembly.MainModule.FileName);
if (symbolReader == null)
{
return;
}
try {
assembly.MainModule.ReadSymbols(symbolReader);
} catch {
symbolReader.Dispose();
return;
}
// Add symbol reader to annotations only if we have successfully read it
_annotations.AddSymbolReader(assembly, symbolReader);
} catch { }
}
public virtual void SafeReadSymbols(AssemblyDefinition assembly)
{
if (assembly.MainModule.HasSymbols)
{
return;
}
if (_symbolReaderProvider == null)
{
throw new InvalidOperationException("Symbol provider is not set");
}
try {
var symbolReader = _symbolReaderProvider.GetSymbolReader(
assembly.MainModule,
GetAssemblyLocation(assembly));
if (symbolReader == null)
{
return;
}
try {
assembly.MainModule.ReadSymbols(symbolReader);
} catch {
symbolReader.Dispose();
return;
}
// Add symbol reader to annotations only if we have successfully read it
_annotations.AddSymbolReader(assembly, symbolReader);
} catch { }
}
public void ReadSymbols()
{
if (string.IsNullOrEmpty(this.fq_name))
{
throw new InvalidOperationException();
}
ISymbolReaderProvider platformReaderProvider = SymbolProvider.GetPlatformReaderProvider();
if (platformReaderProvider == null)
{
throw new InvalidOperationException();
}
this.ReadSymbols(platformReaderProvider.GetSymbolReader(this, this.fq_name));
}
private static void ReadSymbols(ModuleDefinition module, ReaderParameters parameters)
{
ISymbolReaderProvider symbolReaderProvider = parameters.SymbolReaderProvider;
if (symbolReaderProvider == null && parameters.ReadSymbols)
{
symbolReaderProvider = SymbolProvider.GetPlatformReaderProvider();
}
if (symbolReaderProvider != null)
{
module.SymbolReaderProvider = symbolReaderProvider;
module.ReadSymbols((parameters.SymbolStream != null ? symbolReaderProvider.GetSymbolReader(module, parameters.SymbolStream) : symbolReaderProvider.GetSymbolReader(module, module.FullyQualifiedName)));
}
}
/// <summary>
/// 从流加载Assembly,以及symbol符号文件(pdb)
/// </summary>
/// <param name="stream">Assembly Stream</param>
/// <param name="symbol">symbol Stream</param>
/// <param name="symbolReader">symbol 读取器</param>
public void LoadAssembly(System.IO.Stream stream, System.IO.Stream symbol, ISymbolReaderProvider symbolReader)
{
var module = ModuleDefinition.ReadModule(stream); //从MONO中加载模块
if (symbolReader != null && symbol != null)
{
module.ReadSymbols(symbolReader.GetSymbolReader(module, symbol)); //加载符号表
}
if (module.HasAssemblyReferences) //如果此模块引用了其他模块
{
foreach (var ar in module.AssemblyReferences)
{
/*if (moduleref.Contains(ar.Name) == false)
* moduleref.Add(ar.Name);
* if (moduleref.Contains(ar.FullName) == false)
* moduleref.Add(ar.FullName);*/
}
}
if (module.HasTypes)
{
List <ILType> types = new List <ILType>();
foreach (var t in module.GetTypes()) //获取所有此模块定义的类型
{
ILType type = new ILType(t, this);
mapType[t.FullName] = type;
types.Add(type);
}
}
if (voidType == null)
{
voidType = GetType("System.Void");
intType = GetType("System.Int32");
longType = GetType("System.Int64");
boolType = GetType("System.Boolean");
floatType = GetType("System.Single");
doubleType = GetType("System.Double");
objectType = GetType("System.Object");
}
module.AssemblyResolver.ResolveFailure += AssemblyResolver_ResolveFailure;
#if DEBUG
debugService.NotifyModuleLoaded(module.Name);
#endif
}
public void LoadAssembly(System.IO.Stream stream, System.IO.Stream symbol, ISymbolReaderProvider symbolReader)
{
var module = ModuleDefinition.ReadModule(stream);
if (symbolReader != null && symbol != null)
{
module.ReadSymbols(symbolReader.GetSymbolReader(module, symbol));
}
if (module.HasAssemblyReferences)
{
foreach (var ar in module.AssemblyReferences)
{
/*if (moduleref.Contains(ar.Name) == false)
* moduleref.Add(ar.Name);
* if (moduleref.Contains(ar.FullName) == false)
* moduleref.Add(ar.FullName);*/
}
}
if (module.HasTypes)
{
List <ILType> types = new List <ILType>();
foreach (var t in module.GetTypes())
{
ILType type = new ILType(t, this);
mapType[t.FullName] = type;
types.Add(type);
}
}
voidType = GetType("System.Void");
intType = GetType("System.Int32");
longType = GetType("System.Int64");
boolType = GetType("System.Boolean");
floatType = GetType("System.Single");
doubleType = GetType("System.Double");
objectType = GetType("System.Object");
module.AssemblyResolver.ResolveFailure += AssemblyResolver_ResolveFailure;
}
public void LoadModule(Stream dllStream, Stream pdbStream, ISymbolReaderProvider debugInfoLoader)
{
ModuleDefinition moduleDefinition = ModuleDefinition.ReadModule(dllStream);
bool flag = debugInfoLoader != null && pdbStream != null;
if (flag)
{
moduleDefinition.ReadSymbols(debugInfoLoader.GetSymbolReader(moduleDefinition, pdbStream));
}
bool hasAssemblyReferences = moduleDefinition.HasAssemblyReferences;
if (hasAssemblyReferences)
{
foreach (AssemblyNameReference current in moduleDefinition.AssemblyReferences)
{
bool flag2 = !this.moduleref.Contains(current.Name);
if (flag2)
{
this.moduleref.Add(current.Name);
}
bool flag3 = !this.moduleref.Contains(current.FullName);
if (flag3)
{
this.moduleref.Add(current.FullName);
}
}
}
bool hasTypes = moduleDefinition.HasTypes;
if (hasTypes)
{
foreach (TypeDefinition current2 in moduleDefinition.Types)
{
this.mapType[current2.FullName] = new Type_Common_CLRSharp(this, current2);
}
}
}
/// <summary>
/// Load, if available, the debugging symbols associated with the module. This first
/// try to load a MDB file (symbols from the Mono:: runtime) and then, if not present
/// and running on MS.NET, try to load a PDB file (symbols from MS runtime).
/// </summary>
/// <param name="self"></param>
public static void LoadDebuggingSymbols(this ModuleDefinition self)
{
if (self == null)
{
return;
}
// don't create a new reader if the symbols are already loaded
if (self.HasSymbols)
{
return;
}
string image_name = self.FullyQualifiedName;
string symbol_name = image_name + ".mdb";
Type reader_type = null;
// we can always load Mono symbols (whatever the runtime we're using)
// so we start by looking for it's debugging symbol file
if (File.Exists(symbol_name))
{
// "always" if we can find Mono.Cecil.Mdb
reader_type = Type.GetType("Mono.Cecil.Mdb.MdbReaderProvider, Mono.Cecil.Mdb, Version=0.9.4.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756");
// load the assembly from the current folder if
// it is here, or fallback to the gac
}
// if we could not load Mono's symbols then we try, if not running on Mono,
// to load MS symbols (PDB files)
if ((reader_type == null) && !RunningOnMono)
{
// assume we're running on MS.NET
symbol_name = Path.ChangeExtension(image_name, ".pdb");
if (File.Exists(symbol_name))
{
reader_type = Type.GetType("Mono.Cecil.Pdb.PdbReaderProvider, Mono.Cecil.Pdb");
}
}
// no symbols are available to load
if (reader_type == null)
{
return;
}
ISymbolReaderProvider provider = (ISymbolReaderProvider)Activator.CreateInstance(reader_type);
try {
self.ReadSymbols(provider.GetSymbolReader(self, image_name));
}
catch (FileNotFoundException) {
// this happens if a MDB file is missing
}
catch (TypeLoadException) {
// this happens if a Mono.Cecil.Mdb.dll is not found
}
catch (COMException) {
// this happens if a PDB file is missing
}
catch (FormatException) {
// Mono.Cecil.Mdb wrap MonoSymbolFileException inside a FormatException
// This makes it possible to catch such exception without a reference to the
// Mono.CompilerServices.SymbolWriter.dll assembly
}
catch (InvalidOperationException) {
// this happens if the PDB is out of sync with the actual DLL (w/new PdbCciReader)
}
// in any case (of failure to load symbols) Gendarme can continue its analysis (but some rules
// can be affected). The HasDebuggingInformation extension method let them adjust themselves
}