void GetSymbolProviders()
{
switch (DebugSymbols)
{
case DebugSymbolsType.None:
{
Logger.LogInfo("Debug symbols disabled.");
return;
}
case DebugSymbolsType.Embedded:
{
debugReaderProvider = new EmbeddedPortablePdbReaderProvider();
debugWriterProvider = new EmbeddedPortablePdbWriterProvider();
return;
}
default:
{
FindPdb();
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
Logger.LogWarning("No debug symbols found. It is recommended to build with debug symbols enabled.");
return;
}
}
}
void GetSymbolProviders()
{
if (!DebugSymbols)
{
// Log something about building without symbols?
return;
}
FindPdb();
FindMdb();
ChooseNewest();
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
if (mdbFound)
{
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
return;
}
Logger.LogWarning("No debug symbols found. It is recommended to build with debug symbols enabled.");
}
private void loadAssembly(Stream assembly, Stream symbol = null, ISymbolReaderProvider symbolReaderProvider = null)
{
if (mAssemblyStream != null)
{
mAssemblyStream.Dispose();
}
if (mSymbolStream != null)
{
mSymbolStream.Dispose();
}
mAssemblyStream = assembly;
mSymbolStream = symbol;
if (symbol == null)
{
mAppDomain.LoadAssembly(mAssemblyStream);
}
else
{
if (symbolReaderProvider == null)
{
mAppDomain.LoadAssembly(mAssemblyStream, mSymbolStream, new PdbReaderProvider());
}
else
{
mAppDomain.LoadAssembly(mAssemblyStream, mSymbolStream, symbolReaderProvider);
}
}
}
void GetSymbolProviders()
{
FindPdb();
FindMdb();
ThrowIfFoundBoth();
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
if (mdbFound)
{
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
return;
}
Logger.LogDebug("Found no debug symbols.");
}
//stripped down version of: https://github.com/Keboo/AutoDI/blob/master/AutoDI.Build/AssemblyRewriteTask.cs
private static Stream GetSymbolInformation(string assemblyFile, out ISymbolReaderProvider symbolReaderProvider,
out ISymbolWriterProvider symbolWriterProvider)
{
string pdbPath = FindPdbPath();
if (pdbPath != null)
{
symbolReaderProvider = new PdbReaderProvider();
symbolWriterProvider = new PdbWriterProvider();
string tempPath = pdbPath + ".tmp";
File.Copy(pdbPath, tempPath, true);
return(new FileStream(tempPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
}
symbolReaderProvider = null;
symbolWriterProvider = null;
return(null);
string FindPdbPath()
{
string path = Path.ChangeExtension(assemblyFile, "pdb");
if (File.Exists(path))
{
return(path);
}
return(null);
}
}
void GetSymbolProviders()
{
FindPdb();
FindMdb();
ThrowIfFoundBoth();
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
if (mdbFound)
{
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
return;
}
Logger.LogDebug("Found no debug symbols.");
}
private ISymbolReader ResolveSymbolReader()
{
string symbolLocation = null;
string pdbLocation = Path.ChangeExtension(AssemblyLocation, "pdb");
string mdbLocation = AssemblyLocation + ".mdb";
ISymbolReaderProvider provider = null;
if (File.Exists(pdbLocation))
{
symbolLocation = pdbLocation;
provider = new PdbReaderProvider();
}
else if (File.Exists(mdbLocation))
{
symbolLocation = AssemblyLocation;
provider = new MdbReaderProvider();
}
if (provider == null)
{
return(null);
}
var reader = provider.GetSymbolReader(Definition, symbolLocation);
return(reader);
}
void GetSymbolProviders()
{
if (!DebugSymbols)
{
Logger.LogInfo("DebugSymbols disabled. No symbols file will be processed.");
return;
}
FindPdb();
FindMdb();
ChooseNewest();
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
if (mdbFound)
{
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
return;
}
Logger.LogWarning("No debug symbols found. It is recommended to build with debug symbols enabled.");
}
public Executor(IAssemblyResolver assemblyResolver, ISymbolReaderProvider symbolReaderProvider, IReadOnlyCollection <IAssemblyRewriter> rewriters, RecyclableMemoryStreamManager memoryStreamManager, IMonitor monitor)
{
_assemblyResolver = assemblyResolver;
_symbolReaderProvider = symbolReaderProvider;
_rewriters = rewriters;
_memoryStreamManager = memoryStreamManager;
_monitor = monitor;
}
public static ISymbolReaderProvider GetPlatformReaderProvider()
{
if (reader_provider != null)
{
return(reader_provider);
}
Type platformType = GetPlatformType(GetProviderTypeName("ReaderProvider"));
return((platformType != null) ? (reader_provider = (ISymbolReaderProvider)Activator.CreateInstance(platformType)) : null);
}
public ContainerExecutor(
IAssemblyResolver assemblyResolver,
ISymbolReaderProvider symbolReaderProvider,
IReadOnlyCollection <IContainerAssemblyRewriter> rewriters,
RecyclableMemoryStreamManager memoryStreamManager,
IContainerClient client
)
{
_assemblyResolver = assemblyResolver;
_symbolReaderProvider = symbolReaderProvider;
_rewriters = rewriters;
_memoryStreamManager = memoryStreamManager;
_client = client;
}
public static ISymbolReaderProvider GetPlatformReaderProvider()
{
if (SymbolProvider.reader_provider != null)
{
return(SymbolProvider.reader_provider);
}
Type platformType = SymbolProvider.GetPlatformType(SymbolProvider.GetProviderTypeName("ReaderProvider"));
if (platformType == null)
{
return(null);
}
return(SymbolProvider.reader_provider = (ISymbolReaderProvider)Activator.CreateInstance(platformType));
}
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)));
}
}
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));
}
/// <summary>
/// Creates a new modifier that can insert resources and code into an assembly.
/// </summary>
/// <param name="logger"></param>
/// <param name="inputAssembly"></param>
/// <param name="outputAssembly"></param>
/// <param name="searchDirectories"></param>
/// <param name="debugSymbolType">Determines which (if any) debug symbols are read.</param>
/// <param name="signingKey">Optional signing key to be applied to the output assembly.</param>
public CecilBasedAssemblyModifier(ILogger logger, string inputAssembly, string outputAssembly, string[] searchDirectories = null, DebugSymbolType debugSymbolType = DebugSymbolType.Full, StrongNameKeyPair signingKey = null)
{
if (logger == null)
{
logger = new DummyLogger();
}
if (!File.Exists(inputAssembly))
{
throw new FileNotFoundException(inputAssembly);
}
if (string.IsNullOrEmpty(outputAssembly))
{
throw new ArgumentNullException("outputAssembly");
}
_logger = logger;
_signingKey = signingKey;
// cecil 0.10 has a lock on the read file now so need to copy it
_tempFilePath = Path.ChangeExtension(Path.GetFullPath(inputAssembly), ".tmp");
File.Copy(inputAssembly, _tempFilePath, true);
_symbolExtension = "pdb";
var existingSymbolsPath = Path.ChangeExtension(inputAssembly, _symbolExtension);
if (!File.Exists(existingSymbolsPath))
{
_symbolExtension = "mdb";
existingSymbolsPath = Path.ChangeExtension(inputAssembly, _symbolExtension);
}
// symbols are optional
if (File.Exists(existingSymbolsPath))
{
_tempSymbolFilePath = $"{Path.ChangeExtension(Path.GetFullPath(existingSymbolsPath), ".tmp")}.{_symbolExtension}";
File.Copy(existingSymbolsPath, _tempSymbolFilePath, true);
}
InputAssembly = inputAssembly = _tempFilePath;
OutputAssembly = Path.GetFullPath(outputAssembly);
ISymbolReaderProvider symbolReader = GetSymbolReader(_tempSymbolFilePath, debugSymbolType);
_symbolsWriter = GetSymbolWriter(_tempSymbolFilePath, debugSymbolType);
var rp = GetReaderParameters(inputAssembly, searchDirectories, symbolReader);
_assemblyDefinition = AssemblyDefinition.ReadAssembly(inputAssembly, rp);
_resourceEmbedder = new CecilBasedResourceEmbedder(logger);
_codeInjector = new CecilBasedCodeInjector(logger);
}
/// <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 static ISymbolReaderProvider GetPlatformReaderProvider()
{
if (reader_provider != null)
{
return(reader_provider);
}
var type = GetPlatformType(GetProviderTypeName("ReaderProvider"));
if (type == null)
{
return(null);
}
return(reader_provider = (ISymbolReaderProvider)Activator.CreateInstance(type));
}
public static ISymbolReaderProvider GetPlatformReaderProvider()
{
if (reader_provider != null)
{
return(reader_provider);
}
var type = GetPlatformType("Mono.Cecil." + symbol_kind + ".ReaderProvider");
if (type == null)
{
return(null);
}
return(reader_provider = (ISymbolReaderProvider)Activator.CreateInstance(type));
}
void GetSymbolProviders()
{
pdbPath = Path.ChangeExtension(AssemblyFilePath, "pdb");
if (File.Exists(pdbPath))
{
pdbFound = true;
Logger.LogDebug(string.Format("Found debug symbols at '{0}'.", pdbPath));
}
mdbPath = AssemblyFilePath + ".mdb";
if (File.Exists(mdbPath))
{
mdbFound = true;
Logger.LogDebug(string.Format("Found debug symbols at '{0}'.", mdbPath));
}
if (pdbFound && mdbFound)
{
if (File.GetLastWriteTimeUtc(pdbPath) >= File.GetLastWriteTimeUtc(mdbPath))
{
mdbFound = false;
Logger.LogDebug("Found mdb and pdb debug symbols. Selected pdb (newer).");
}
else
{
pdbFound = false;
Logger.LogDebug("Found mdb and pdb debug symbols. Selected mdb (newer).");
}
}
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
if (mdbFound)
{
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
return;
}
Logger.LogDebug("Found no debug symbols.");
}
void GetSymbolProviders()
{
pdbPath = Path.ChangeExtension(AssemblyFilePath, "pdb");
if (File.Exists(pdbPath))
{
pdbFound = true;
Logger.LogDebug(string.Format("Found debug symbols at '{0}'.", pdbPath));
}
mdbPath = AssemblyFilePath + ".mdb";
if (File.Exists(mdbPath))
{
mdbFound = true;
Logger.LogDebug(string.Format("Found debug symbols at '{0}'.", mdbPath));
}
if (pdbFound && mdbFound)
{
if (File.GetLastWriteTimeUtc(pdbPath) >= File.GetLastWriteTimeUtc(mdbPath))
{
mdbFound = false;
Logger.LogDebug("Found mdb and pdb debug symbols. Selected pdb (newer).");
}
else
{
pdbFound = false;
Logger.LogDebug("Found mdb and pdb debug symbols. Selected mdb (newer).");
}
}
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
if (mdbFound)
{
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
return;
}
Logger.LogDebug("Found no debug symbols.");
}
public Executor(
IAssemblyResolver assemblyResolver,
ISymbolReaderProvider symbolReaderProvider,
ApiPolicy apiPolicy,
IReadOnlyCollection <IAssemblyRewriter> rewriters,
RecyclableMemoryStreamManager memoryStreamManager,
ExecutionResultSerializer serializer,
IMonitor monitor
)
{
_assemblyResolver = assemblyResolver;
_symbolReaderProvider = symbolReaderProvider;
_guardSettings = CreateGuardSettings(apiPolicy);
_rewriters = rewriters;
_memoryStreamManager = memoryStreamManager;
_serializer = serializer;
_monitor = monitor;
}
public Executor(
IAssemblyResolver assemblyResolver,
ISymbolReaderProvider symbolReaderProvider,
ApiPolicy apiPolicy,
IReadOnlyCollection <IAssemblyRewriter> rewriters,
RecyclableMemoryStreamManager memoryStreamManager,
ExecutionResultSerializer serializer,
IMonitor monitor
) : base(
assemblyResolver,
symbolReaderProvider,
apiPolicy,
rewriters,
memoryStreamManager,
serializer,
monitor
)
{
}
void GetSymbolProviders()
{
pdbPath = Path.ChangeExtension(AssemblyFilePath, "pdb");
if (File.Exists(pdbPath))
{
pdbFound = true;
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
Logger.LogInfo(string.Format("Found debug symbols at '{0}'.", pdbPath));
}
mdbPath = AssemblyFilePath + ".mdb";
if (File.Exists(mdbPath))
{
mdbFound = true;
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
Logger.LogInfo(string.Format("Found debug symbols at '{0}'.", mdbPath));
}
Logger.LogInfo("Found no debug symbols.");
}
private static void ReadSymbols(ModuleDefinition module, ReaderParameters parameters)
{
ISymbolReaderProvider symbolReaderProvider = parameters.SymbolReaderProvider;
if (symbolReaderProvider == null && parameters.ReadSymbols)
{
symbolReaderProvider = new DefaultSymbolReaderProvider();
}
if (symbolReaderProvider != null)
{
module.SymbolReaderProvider = symbolReaderProvider;
ISymbolReader symbolReader = (parameters.SymbolStream != null) ? symbolReaderProvider.GetSymbolReader(module, parameters.SymbolStream) : symbolReaderProvider.GetSymbolReader(module, module.FileName);
if (symbolReader != null)
{
module.ReadSymbols(symbolReader, parameters.ThrowIfSymbolsAreNotMatching);
}
}
if (module.Image.HasDebugTables())
{
module.ReadSymbols(new PortablePdbReader(module.Image, module));
}
}
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;
}
void GetSymbolProviders()
{
pdbPath = Path.ChangeExtension(AssemblyFilePath, "pdb");
if (File.Exists(pdbPath))
{
pdbFound = true;
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
Logger.LogInfo(string.Format("Found debug symbols at '{0}'.", pdbPath));
}
mdbPath = AssemblyFilePath + ".mdb";
if (File.Exists(mdbPath))
{
mdbFound = true;
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
Logger.LogInfo(string.Format("Found debug symbols at '{0}'.", mdbPath));
return;
}
Logger.LogInfo("Found no debug symbols.");
}
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);
}
}
}
void GetSymbolProviders()
{
FindPdb();
FindMdb();
ChooseNewest();
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
if (mdbFound)
{
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
return;
}
throw new WeavingException("Found no debug symbols.");
}
void GetSymbolProviders()
{
FindPdb();
FindMdb();
ChooseNewest();
if (pdbFound)
{
debugReaderProvider = new PdbReaderProvider();
debugWriterProvider = new PdbWriterProvider();
return;
}
if (mdbFound)
{
debugReaderProvider = new MdbReaderProvider();
debugWriterProvider = new MdbWriterProvider();
return;
}
throw new WeavingException("Found no debug symbols.");
}
public static ISymbolReaderProvider GetPlatformReaderProvider()
{
if (reader_provider != null)
return reader_provider;
var type = GetPlatformType (GetProviderTypeName ("ReaderProvider"));
if (type == null)
return null;
return reader_provider = (ISymbolReaderProvider) Activator.CreateInstance (type);
}
public SymbolFile(string symbolFile, ISymbolReaderProvider symbolReaderProvider)
{
SymbolFilename = symbolFile;
SymbolReaderProvider = symbolReaderProvider;
}
public static ISymbolReaderProvider GetPlatformReaderProvider()
{
if (reader_provider != null)
return reader_provider;
var type = GetPlatformType ("Mono.Cecil." + symbol_kind + ".ReaderProvider");
if (type == null)
return null;
return reader_provider = (ISymbolReaderProvider) Activator.CreateInstance (type);
}
void Rewrite(string file, string keyfile, IEnumerable <string> options)
{
// Specify assembly read and write parameters
// We want to keep a valid symbols file (pdb or mdb)
var read_params = new ReaderParameters();
var write_params = new WriterParameters();
var pdb = Path.ChangeExtension(file, "pdb");
var mdb = Path.ChangeExtension(file, "mdb");
ISymbolReaderProvider provider = null;
if (File.Exists(pdb))
{
provider = new Mono.Cecil.Pdb.PdbReaderProvider();
}
else if (File.Exists(mdb))
{
provider = new Mono.Cecil.Mdb.MdbReaderProvider();
}
read_params.SymbolReaderProvider = provider;
read_params.ReadSymbols = true;
write_params.WriteSymbols = true;
if (!String.IsNullOrEmpty(keyfile) && File.Exists(keyfile))
{
keyfile = Path.GetFullPath(keyfile);
var fs = new FileStream(keyfile, FileMode.Open);
var keypair = new System.Reflection.StrongNameKeyPair(fs);
fs.Close();
write_params.StrongNameKeyPair = keypair;
}
else
{
Console.Error.WriteLine("No keyfile specified or keyfile missing.");
}
// Load assembly and process all modules
var assembly = AssemblyDefinition.ReadAssembly(file, read_params);
var rewritten = assembly.CustomAttributes.FirstOrDefault(a => a.AttributeType.Name == "RewrittenAttribute");
if (rewritten == null)
{
foreach (var module in assembly.Modules)
{
foreach (var reference in module.AssemblyReferences)
{
var resolved = module.AssemblyResolver.Resolve(reference);
if (reference.Name == "mscorlib")
{
mscorlib = resolved;
}
}
}
if (mscorlib == null)
{
Console.Error.WriteLine("Failed to locate mscorlib");
return;
}
TypeMarshal = mscorlib.MainModule.GetType("System.Runtime.InteropServices.Marshal");
TypeStringBuilder = mscorlib.MainModule.GetType("System.Text.StringBuilder");
TypeVoid = mscorlib.MainModule.GetType("System.Void");
TypeIntPtr = mscorlib.MainModule.GetType("System.IntPtr");
TypeInt32 = mscorlib.MainModule.GetType("System.Int32");
TypeBindingsBase = assembly.Modules.Select(m => m.GetType("OpenTK.BindingsBase")).First();
foreach (var module in assembly.Modules)
{
foreach (var type in module.Types)
{
Rewrite(type, options);
}
}
}
else
{
Console.Error.WriteLine("Error: assembly has already been rewritten");
}
// Save rewritten assembly
assembly.Write(file, write_params);
}
public SymbolFolder(string targetFolder, ISymbolReaderProvider symbolReaderProvider)
{
TargetFolder = targetFolder;
SymbolReaderProvider = symbolReaderProvider;
}
public ILDecompiler(ISymbolReaderProvider symbolReaderProvider, Func <Stream, IDisposableDebugInfoProvider> debugInfoFactory)
{
_symbolReaderProvider = symbolReaderProvider;
_debugInfoFactory = debugInfoFactory;
}
/// <summary>
/// Helper to create the correct reader parameter construct based on the parameters.
/// </summary>
/// <returns></returns>
public static ReaderParameters GetReaderParameters(string inputAssembly, IEnumerable <string> searchDirectories, ISymbolReaderProvider symbolReader)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(new FileInfo(inputAssembly).DirectoryName);
if (searchDirectories != null)
{
foreach (var dir in searchDirectories)
{
resolver.AddSearchDirectory(dir);
}
}
var rp = new ReaderParameters
{
AssemblyResolver = resolver,
ReadSymbols = symbolReader != null,
SymbolReaderProvider = symbolReader
};
return(rp);
}
protected BaseAssemblyResolver()
{
directories = new List<string> { ".", "bin" };
gac_paths = GetGacPaths();
this.provider = GetPlatformReaderProvider();
}
/// <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
}
