public static AssemblyDefinition GetAssemblyDef(string assemblyPath) { if (assemblies.ContainsKey(assemblyPath)) return assemblies[assemblyPath]; var assemblyResolver = new DefaultAssemblyResolver(); var assemblyLocation = Path.GetDirectoryName(assemblyPath); assemblyResolver.AddSearchDirectory(assemblyLocation); var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver }; var pdbName = Path.ChangeExtension(assemblyPath, "pdb"); if (File.Exists(pdbName)) { var symbolReaderProvider = new PdbReaderProvider(); readerParameters.SymbolReaderProvider = symbolReaderProvider; readerParameters.ReadSymbols = true; } var assemblyDef = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters); assemblies.Add(assemblyPath,assemblyDef); return assemblyDef; }
public MemberReference GetMemberReference(IAssemblyResolver resolver) { if (resolver == null) throw new ArgumentNullException("resolver"); if (memberReference != null) return memberReference; // reload from filename ReaderParameters readerParameters = new ReaderParameters(); // Use new assembly resolver instance so that the AssemblyDefinitions can be garbage-collected // once the code is decompiled. readerParameters.AssemblyResolver = resolver; string typeName; if (GetAssemblyAndType(FileName.ToString(), out assemblyFile, out typeName)) { ModuleDefinition module = ModuleDefinition.ReadModule(assemblyFile, readerParameters); TypeDefinition typeDefinition = module.GetType(typeName); if (typeDefinition == null) throw new InvalidOperationException("Could not find type"); memberReference = typeDefinition; } return memberReference; }
/// <summary> /// Reads the assembly from the given path, or else loads it from cache. /// </summary> /// <param name="path">The patch to read the assembly from.</param> /// <param name="readSymbols">Whether or not to read symbols.</param> /// <returns></returns> public AssemblyDefinition ReadAssembly(string path, bool readSymbols = false) { var fileInfo = new FileInfo(path); fileInfo.Refresh(); if (_cache.ContainsKey(path)) { if (DoesCacheMatch(fileInfo, _cache[path].Metadata)) { return _cache[path].Assembly; } } var defAssemblyResolver = new ExpandedAssemblyResolver(); defAssemblyResolver.AddSearchDirectory(Path.GetDirectoryName(path)); var rdrParams = new ReaderParameters() { AssemblyResolver = defAssemblyResolver, ReadSymbols = readSymbols }; var read = AssemblyDefinition.ReadAssembly(path, rdrParams); var assemblyResolver = read.MainModule.AssemblyResolver as BaseAssemblyResolver; //Cecil doesn't add the assembly's original directory as a search path by default. var dir = Path.GetDirectoryName(path); var entry = new AssemblyCacheEntry() { Assembly = read, Metadata = new FileMetadata() { Length = fileInfo.Length, LastWriteTime = fileInfo.LastWriteTimeUtc, CreationTime = fileInfo.CreationTimeUtc }, Path = path }; _cache[path] = entry; return read; }
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters) { if (string.IsNullOrEmpty(fullName)) throw new ArgumentException("fullName is null or empty"); return Resolve(AssemblyNameReference.Parse(fullName), parameters); }
static void Main(string[] args) { try { var path = args.Length >= 1 ? args[0] : "Ibasa.dll"; var symbolReader = new Mono.Cecil.Pdb.PdbReaderProvider(); var readerParameters = new ReaderParameters() { SymbolReaderProvider = symbolReader, ReadSymbols = true, }; var writerParameters = new WriterParameters() { WriteSymbols = true, }; AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(path, readerParameters); Console.WriteLine("Loaded {0}.", path); GenerateMemoryType(assembly.MainModule); Console.WriteLine("Saving new dll."); assembly.Write(path, writerParameters); } catch (Exception e) { Console.WriteLine("InteropBuilder failed with: {0}", e); } }
public virtual void ReadModule() { string symbolsPath; if (pdbFound) { symbolsPath = pdbPath; } else { symbolsPath = mdbPath; } var tempAssembly = $"{AssemblyFilePath}.tmp"; var tempSymbols = $"{symbolsPath}.tmp"; File.Copy(AssemblyFilePath, tempAssembly,true); File.Copy(symbolsPath, tempSymbols, true); SymbolStream = File.OpenRead(tempSymbols); var readerParameters = new ReaderParameters { AssemblyResolver = this, ReadSymbols = true, SymbolReaderProvider = debugReaderProvider, SymbolStream = SymbolStream, }; ModuleDefinition = ModuleDefinition.ReadModule(tempAssembly, readerParameters); }
public void ReadModule() { if (pdbFound) { using (var symbolStream = File.OpenRead(pdbPath)) { var readerParameters = new ReaderParameters { AssemblyResolver = this, ReadSymbols = pdbFound || mdbFound, SymbolReaderProvider = debugReaderProvider, SymbolStream = symbolStream }; ModuleDefinition = ModuleDefinition.ReadModule(AssemblyFilePath, readerParameters); } } else { var readerParameters = new ReaderParameters { AssemblyResolver = this, ReadSymbols = pdbFound || mdbFound, SymbolReaderProvider = debugReaderProvider, }; ModuleDefinition = ModuleDefinition.ReadModule(AssemblyFilePath, readerParameters); } }
public static AssemblyDefinition Load(string fileName) { var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(new FileInfo(fileName).DirectoryName); var parameters = new ReaderParameters { SymbolReaderProvider = new PdbReaderProvider(), ReadingMode = ReadingMode.Immediate, AssemblyResolver = resolver }; AssemblyDefinition assemblyDef; try { assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters); } catch (FileNotFoundException) { // Perhaps we have an MDB file (Mono), or there is no symbol file to load. // Try MDB first! parameters.SymbolReaderProvider = new MdbReaderProvider(); try { assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters); } catch (FileNotFoundException) { parameters.SymbolReaderProvider = null; assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters); } } return assemblyDef; }
public WeaverHelper(string projectPath) { this.projectPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\TestAssemblies", projectPath)); GetAssemblyPath(); AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll"); File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true); var assemblyResolver = new TestAssemblyResolver(BeforeAssemblyPath, this.projectPath); var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver }; var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, readerParameters); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver }; weavingTask.Execute(); moduleDefinition.Write(AfterAssemblyPath); Assembly = Assembly.LoadFile(AfterAssemblyPath); }
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) { lock (resolutionCache) { string key = name.FullName; AssemblyDefinition result; if (resolutionCache.TryGetValue(key, out result)) return result; } if (!name.Name.StartsWith("System", StringComparison.OrdinalIgnoreCase) && !name.Name.StartsWith("mscorlib", StringComparison.OrdinalIgnoreCase)) return null; var asm = Assembly.Load(name.ToString()); var asmDef = AssemblyDefinition.ReadAssembly( asm.Location, parameters ?? new ReaderParameters(ReadingMode.Deferred) { AssemblyResolver = this }); lock (resolutionCache) { string key = name.FullName; AssemblyDefinition result; if (resolutionCache.TryGetValue(key, out result)) return result; resolutionCache[key] = asmDef; } return asmDef; }
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters) { var dllName = fullName.Split(',')[0] + ".dll"; var fullPath = _targetAssemblyDirs.Select(x => Path.Combine(x, dllName)).FirstOrDefault(x => File.Exists(x)); if (fullPath == null) { dllName = fullName.Split(',')[0] + ".winmd"; fullPath = _targetAssemblyDirs.Select(x => Path.Combine(x, dllName)).FirstOrDefault(x => File.Exists(x)); } // NB: This hacks WinRT's weird mscorlib to just use the regular one // We forget why this was needed, maybe it's not needed anymore? if (fullName.Contains("mscorlib") && fullName.Contains("255")) { fullPath = Environment.ExpandEnvironmentVariables( @"%SystemRoot%\Microsoft.NET\Framework\v4.0.30319\mscorlib.dll"); } if (fullPath == null) { var errorMessage = $"Failed to resolve!!! {fullName}"; Log.Error(errorMessage); throw new Exception(errorMessage); } return AssemblyDefinition.ReadAssembly(fullPath, parameters); }
public static AssemblyNode ReadAssembly (string filename) { var readerParameters = new ReaderParameters (); AssemblyDefinition definition = AssemblyDefinition.ReadAssembly (filename, readerParameters); return new AssemblyNode (definition); }
/// <summary> /// Patches the specified input PDB file. /// </summary> /// <param name="inputExeFile">The input PDB file.</param> /// <param name="outputPdbFile">The output PDB file.</param> /// <param name="sourcePathRewriter">The source path modifier.</param> /// <exception cref="System.ArgumentNullException">inputExeFile</exception> public static void Patch(string inputExeFile, string outputPdbFile, SourcePathRewriterDelegate sourcePathRewriter) { if (inputExeFile == null) throw new ArgumentNullException("inputExeFile"); if (outputPdbFile == null) throw new ArgumentNullException("outputPdbFile"); if (sourcePathRewriter == null) throw new ArgumentNullException("sourcePathRewriter"); // Copy PDB from input assembly to output assembly if any var inputPdbFile = Path.ChangeExtension(inputExeFile, "pdb"); if (!File.Exists(inputPdbFile)) { ShowMessage(string.Format("Warning file [{0}] does not exist", inputPdbFile), ConsoleColor.Yellow); return; } var symbolReaderProvider = new PdbReaderProvider(); var readerParameters = new ReaderParameters { SymbolReaderProvider = symbolReaderProvider, ReadSymbols = true }; // Read Assembly var assembly = AssemblyDefinition.ReadAssembly(inputExeFile, readerParameters); // Write back the assembly and pdb assembly.Write(inputExeFile, new WriterParameters {WriteSymbols = true, SourcePathRewriter = sourcePathRewriter}); }
public ObfuscationContext(bool symbols = false) { _resolver = new AssemblyResolver(); Symbols = symbols; _readerParameters = new ReaderParameters() { ReadSymbols = Symbols }; Filter = new DefaultFilter(); }
public IEnumerable<MSpecTestCase> DiscoverSpecs(string assemblyFilePath) { if (!this.AssemblyContainsMSpecReference(assemblyFilePath) || !this.SourceDirectoryContainsMSpec(assemblyFilePath)) return new List<MSpecTestCase>(); assemblyFilePath = Path.GetFullPath(assemblyFilePath); if (!File.Exists(assemblyFilePath)) { throw new ArgumentException("Could not find file: " + assemblyFilePath); } this.AssemblyFilename = assemblyFilePath; // make sure that cecil looks in the assembly path for mspec (+ related assemblies) first this.AssemblyResolver = new ScopedAssemblyResolver(Path.GetDirectoryName(assemblyFilePath)); this.ReaderParameters = new ReaderParameters() { ReadSymbols = true, AssemblyResolver = AssemblyResolver }; List<MSpecTestCase> list = new List<MSpecTestCase>(); List<IDelegateFieldScanner> fieldScanners = new List<IDelegateFieldScanner>(); fieldScanners.Add(new ItDelegateFieldScanner()); fieldScanners.Add(new CustomDelegateFieldScanner()); // statically inspect the types in the assembly using mono.cecil var assembly = AssemblyDefinition.ReadAssembly(this.AssemblyFilename, this.ReaderParameters); foreach (TypeDefinition type in GetNestedTypes(assembly.MainModule.Types)) { // if a type is an It delegate generate some test case info for it foreach (FieldDefinition fieldDefinition in type.Fields.Where(x => !x.Name.Contains("__Cached"))) { foreach (IDelegateFieldScanner scanner in fieldScanners) { if (scanner.ProcessFieldDefinition(fieldDefinition)) { string typeName = NormalizeCecilTypeName(type.Name); string typeFullName = NormalizeCecilTypeName(type.FullName); MSpecTestCase testCase = new MSpecTestCase() { ClassName = typeName, ContextFullType = typeFullName, SpecificationName = fieldDefinition.Name, ContextDisplayName = GetContextDisplayName(type), SpecificationDisplayName = fieldDefinition.Name.Replace("_", " "), }; // get the source code location for the It delegate from the PDB file using mono.cecil.pdb this.UpdateTestCaseWithLocation(type, testCase); list.Add(testCase); break; } } } } return list.Select(x => x); }
public IAssemblyTracker CreateTracker() { if (_whiteList == null || _whiteList.Count == 0) throw new InvalidOperationException ("Initialize options first. (AssemblyTracker: target files have to be set!)"); var readPDB = new ReaderParameters { ReadSymbols = true }; var ignorePDB = new ReaderParameters { ReadSymbols = false }; var allFiles = BuildTargetFilesList(); List<AssemblyDefinition> assemblies = new List<AssemblyDefinition> (); foreach (var doc in allFiles) { try { if (_fileSystem.FileExists (doc.Substring (0, doc.Length-3) + "pdb")) assemblies.Add (_fileSystem.ReadAssembly (doc, readPDB)); else assemblies.Add (_fileSystem.ReadAssembly (doc, ignorePDB)); } catch (BadImageFormatException e) { Console.WriteLine (" WARNING :: '" + doc + "' is not a valid .NET assembly! [is ignored]"); } } ((BaseAssemblyResolver) GlobalAssemblyResolver.Instance).AddSearchDirectory (_workingDirectory); return new AssemblyTracker (assemblies, new TypeDefinitionCache()); }
public virtual AssemblyDefinition Resolve (string fullName, ReaderParameters parameters) { if (fullName == null) throw new ArgumentNullException ("fullName"); return Resolve (AssemblyNameReference.Parse (fullName), parameters); }
public AssemblyLoader(IEnumerable<NPath> searchDirectories, [Optional, DefaultParameterValue(false)] bool readSymbols, [Optional, DefaultParameterValue(false)] bool applyWindowsRuntimeProjections) { this._resolver = new AssemblyResolver(this); foreach (NPath path in searchDirectories) { if (path != null) { this._resolver.AddSearchDirectory(path); } } ReaderParameters parameters = new ReaderParameters { AssemblyResolver = this._resolver, MetadataResolver = new WindowsRuntimeAwareMetadataResolver(this._resolver), ReadSymbols = readSymbols, SymbolReaderProvider = !readSymbols ? null : new MdbReaderProvider(), ApplyWindowsRuntimeProjections = applyWindowsRuntimeProjections }; this._readerParameters = parameters; parameters = new ReaderParameters { ApplyWindowsRuntimeProjections = this._readerParameters.ApplyWindowsRuntimeProjections, AssemblyResolver = this._readerParameters.AssemblyResolver, MetadataImporterProvider = this._readerParameters.MetadataImporterProvider, MetadataResolver = this._readerParameters.MetadataResolver, ReadingMode = this._readerParameters.ReadingMode, ReadSymbols = false, SymbolReaderProvider = null, ReflectionImporterProvider = this._readerParameters.ReflectionImporterProvider, SymbolStream = this._readerParameters.SymbolStream }; this._readerWithoutSymbolsParameters = parameters; }
public AssemblyWeaver(string assemblyPath, List<string> referenceAssemblyPaths = null) { if (referenceAssemblyPaths == null) { referenceAssemblyPaths = new List<string>(); } assemblyPath = FixAssemblyPath(assemblyPath); var newAssembly = assemblyPath.Replace(".dll", "2.dll"); File.Copy(assemblyPath, newAssembly, true); var assemblyResolver = new MockAssemblyResolver(); foreach (var referenceAssemblyPath in referenceAssemblyPaths) { var directoryName = Path.GetDirectoryName(referenceAssemblyPath); assemblyResolver.AddSearchDirectory(directoryName); } var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver }; var moduleDefinition = ModuleDefinition.ReadModule(newAssembly, readerParameters); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogError = LogError, ReferenceCopyLocalPaths = referenceAssemblyPaths }; weavingTask.Execute(); moduleDefinition.Write(newAssembly); Assembly = Assembly.LoadFrom(newAssembly); }
public void LoadAssemblyAndGetMethods() { var readerParameters = new ReaderParameters { ReadSymbols = true }; assembly = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters); methods = assembly.MainModule.Types. SelectMany(type => type.Methods); }
public static string Weave(string assemblyPath) { var newAssembly = assemblyPath.Replace(".dll", "2.dll"); var oldPdb = assemblyPath.Replace(".dll", ".pdb"); var newPdb = assemblyPath.Replace(".dll", "2.pdb"); File.Copy(assemblyPath, newAssembly, true); File.Copy(oldPdb, newPdb, true); var assemblyResolver = new MockAssemblyResolver { Directory = Path.GetDirectoryName(assemblyPath) }; using (var symbolStream = File.OpenRead(newPdb)) { var readerParameters = new ReaderParameters { ReadSymbols = true, SymbolStream = symbolStream, SymbolReaderProvider = new PdbReaderProvider() }; var moduleDefinition = ModuleDefinition.ReadModule(newAssembly, readerParameters); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver }; weavingTask.Execute(); moduleDefinition.Write(newAssembly); return newAssembly; } }
AssemblyDefinition LoadAssembly() { // runs on background thread ReaderParameters p = new ReaderParameters(); p.AssemblyResolver = new MyAssemblyResolver(this); return AssemblyDefinition.ReadAssembly(fileName, p); }
public override AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) { if (name == null) throw new ArgumentNullException("name"); return Cache.GetOrCreate(name.FullName, () => base.Resolve(name, parameters)); }
public void CompileIfRequired(ilspy::Mono.Cecil.AssemblyDefinition assembly, bool stopBeforeGeneratingCode = false) { if (_compiler != null && _previousAssembly == assembly && (_isFullyCompiled || stopBeforeGeneratingCode)) return; CompilationErrors = null; _compiler = null; #if DEBUG var framework = Frameworks.Instance.GetBySdkVersion(15); #else var framework = Frameworks.Instance.GetNewestVersion(); #endif string frameworkFolder = framework.Folder; var refFolders = new List<string> { frameworkFolder }; var module = new XModule(); var classLoader = new AssemblyClassLoader(module.OnClassLoaded); var resolver = new AssemblyResolver(refFolders, classLoader, module.OnAssemblyLoaded); var parameter = new ReaderParameters(ReadingMode.Immediate) { AssemblyResolver = resolver,ReadSymbols = true}; var assemblies = new[] { resolver.Load(assembly.MainModule.FullyQualifiedName, parameter) }.ToList(); List<AssemblyDefinition> references = new List<AssemblyDefinition>(); if(assembly.MainModule.Name != "dot42.dll") references = new[] { resolver.Load(AssemblyConstants.SdkAssemblyName, parameter) }.ToList(); foreach (var a in assemblies) references.Remove(a); var c = new AssemblyCompiler(CompilationMode.All, assemblies, references, new Table("pkg.name"), new NameConverter("pkg.name", ""), true, new AssemblyClassLoader(file => { }), definition => null, new DexMethodBodyCompilerCache(), new HashSet<string>(), module, _generateSetNextInstructionCode); c.StopCompilationBeforeGeneratingCode = stopBeforeGeneratingCode; c.StopAtFirstError = false; try { c.Compile(); } catch (AggregateException ex) { CompilationErrors = ex.Flatten().InnerExceptions.Select(e => e.Message.Replace(": ", "\n// ").Replace("; ", "\n// & ")).ToList(); } if (c.MapFile != null) { c.MapFile.Optimize(); MapFile = new MapFileLookup(c.MapFile); } _compiler = c; _previousAssembly = assembly; _isFullyCompiled = !stopBeforeGeneratingCode; }
void Run (Config config) { if (config.ShowHelp) { Console.WriteLine ("Netjs compiler, Copyright 2014 Frank A. Krueger"); Console.WriteLine ("netjs [options] assembly-file"); Console.WriteLine (" -help Lists all compiler options (short: -?)"); return; } if (string.IsNullOrEmpty (config.MainAssembly)) { throw new Exception ("No assembly specified."); } var asmPath = Path.GetFullPath (config.MainAssembly); asmDir = Path.GetDirectoryName (asmPath); var outPath = Path.ChangeExtension (asmPath, ".ts"); Step ("Reading IL"); var parameters = new ReaderParameters { AssemblyResolver = this, }; var asm = AssemblyDefinition.ReadAssembly (asmPath, parameters); mscorlib = AssemblyDefinition.ReadAssembly (typeof(String).Assembly.Location, parameters); system = AssemblyDefinition.ReadAssembly (typeof(INotifyPropertyChanged).Assembly.Location, parameters); systemCore = AssemblyDefinition.ReadAssembly (typeof(Enumerable).Assembly.Location, parameters); systemDrawing = AssemblyDefinition.ReadAssembly (typeof(System.Drawing.Bitmap).Assembly.Location, parameters); Step ("Decompiling IL to C#"); var context = new DecompilerContext (asm.MainModule); context.Settings.ForEachStatement = false; context.Settings.ObjectOrCollectionInitializers = false; context.Settings.UsingStatement = false; context.Settings.AsyncAwait = false; context.Settings.AutomaticProperties = true; context.Settings.AutomaticEvents = true; context.Settings.QueryExpressions = false; context.Settings.AlwaysGenerateExceptionVariableForCatchBlocks = true; context.Settings.UsingDeclarations = false; context.Settings.FullyQualifyAmbiguousTypeNames = true; context.Settings.YieldReturn = false; var builder = new AstBuilder (context); builder.AddAssembly (asm); foreach (var a in referencedAssemblies.Values) { if (a != null) builder.AddAssembly (a); } builder.RunTransformations (); Step ("Translating C# to TypeScript"); new CsToTs ().Run (builder.SyntaxTree); Step ("Writing"); using (var outputWriter = new StreamWriter (outPath)) { var output = new PlainTextOutput (outputWriter); builder.GenerateCode (output, (s, e) => new TsOutputVisitor (s, e)); } Step ("Done"); }
public void ProcessAssemblyFromStream(Stream inputStream, ReaderParameters readerParams, Stream outputStream, WriterParameters writerParams) { var assemblyDef = AssemblyDefinition.ReadAssembly(inputStream, readerParams); Process(assemblyDef); if (outputStream != null) { assemblyDef.Write(outputStream, writerParams); } }
/// <summary> /// Load an assembly for compiler from the given path and record it in the references. /// </summary> public AssemblyDefinition Load(string path, ReaderParameters parameter) { var fullPath = ResolvePath(path); if (fullPath == null) throw new FileNotFoundException(path); return Load(null, fullPath, parameter); }
void readFile() { var assemblyResolver = AssemblyResolver.Instance; var readerParameters = new ReaderParameters(ReadingMode.Deferred); readerParameters.AssemblyResolver = assemblyResolver; module = ModuleDefinition.ReadModule(filename, readerParameters, dumpedMethods); assemblyResolver.addModule(module); }
public string ResolveProjectFilePath(Assembly assembly) { var readerParameters = new ReaderParameters {ReadSymbols = true, ReadingMode = ReadingMode.Deferred}; var definition = AssemblyDefinition.ReadAssembly(assembly.Location, readerParameters); var methodDefinition = GetMethodWithBody(definition); var document = GetMethodDocument(methodDefinition); return document.Url; }
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) { var assembly = ResolveInFolder(localFolder, name, parameters); if (assembly != null) return assembly; assembly = ResolveInFolder(frameworkFolder, name, parameters); if (assembly != null) return assembly; throw new AssemblyResolutionException(name); }
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters) { throw new NotImplementedException(); }
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters) { return(null); }
public static TestResult ExecuteTestRun( this BaseModuleWeaver weaver, string assemblyPath, bool runPeVerify = true, Action <ModuleDefinition> afterExecuteCallback = null, Action <ModuleDefinition> beforeExecuteCallback = null, string assemblyName = null, IEnumerable <string> ignoreCodes = null) { assemblyPath = Path.Combine(CodeBaseLocation.CurrentDirectory, assemblyPath); var fodyTempDir = Path.Combine(Path.GetDirectoryName(assemblyPath), "fodytemp"); Directory.CreateDirectory(fodyTempDir); IoHelper.PurgeDirectory(fodyTempDir); string targetFileName; if (assemblyName == null) { assemblyName = Path.GetFileNameWithoutExtension(assemblyPath); targetFileName = Path.GetFileName(assemblyPath); } else { targetFileName = assemblyName + ".dll"; } var targetAssemblyPath = Path.Combine(fodyTempDir, targetFileName); using (var assemblyResolver = new MockAssemblyResolver()) { var typeCache = CacheTypes(weaver, assemblyResolver); var testStatus = new TestResult(); weaver.LogDebug = text => testStatus.AddMessage(text, MessageImportanceDefaults.Debug); weaver.LogInfo = text => testStatus.AddMessage(text, MessageImportanceDefaults.Info); weaver.LogMessage = (text, messageImportance) => testStatus.AddMessage(text, messageImportance); weaver.LogWarning = text => testStatus.AddWarning(text, null); weaver.LogWarningPoint = (text, sequencePoint) => testStatus.AddWarning(text, sequencePoint); weaver.LogError = text => testStatus.AddError(text, null); weaver.LogErrorPoint = (text, sequencePoint) => testStatus.AddError(text, sequencePoint); weaver.AssemblyFilePath = assemblyPath; weaver.FindType = typeCache.FindType; weaver.TryFindType = typeCache.TryFindType; weaver.ResolveAssembly = assemblyResolver.Resolve; var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver, SymbolReaderProvider = new SymbolReaderProvider(), ReadWrite = false, ReadSymbols = true, }; using (var module = ModuleDefinition.ReadModule(assemblyPath, readerParameters)) { module.Assembly.Name.Name = assemblyName; weaver.ModuleDefinition = module; weaver.TypeSystem = new TypeSystem(typeCache.FindType, module); beforeExecuteCallback?.Invoke(module); weaver.Execute(); ReferenceCleaner.CleanReferences(module, weaver, weaver.LogDebug); afterExecuteCallback?.Invoke(module); var writerParameters = new WriterParameters { WriteSymbols = true }; module.Write(targetAssemblyPath, writerParameters); } if (runPeVerify) { List <string> ignoreList; if (ignoreCodes == null) { ignoreList = new List <string>(); } else { ignoreList = ignoreCodes.ToList(); } ignoreList.Add("0x80070002"); PeVerifier.ThrowIfDifferent(assemblyPath, targetAssemblyPath, ignoreList, Path.GetDirectoryName(assemblyPath)); } testStatus.Assembly = Assembly.Load(File.ReadAllBytes(targetAssemblyPath)); testStatus.AssemblyPath = targetAssemblyPath; return(testStatus); } }
protected override AssemblyDefinition SearchDirectory(AssemblyNameReference name, IEnumerable <string> directories, ReaderParameters parameters) { if (_dependencyContext != null) { var library = _dependencyContext.RuntimeLibraries.FirstOrDefault(c => { return(c.Name == name.Name); }); if (library != null) { foreach (var runtimeAssemblyGroup in library.RuntimeAssemblyGroups) { foreach (var runtimeAssemblyPath in runtimeAssemblyGroup.AssetPaths) { foreach (var directory in directories) { var file = directory; if (!string.IsNullOrEmpty(library.Path)) { file = Path.Combine(file, Path.Combine(library.Path.Split("/"))); } file = Path.Combine(file, Path.Combine(runtimeAssemblyPath.Split("/"))); Console.WriteLine($"Try to load file {file}"); if (File.Exists(file)) { try { return(GetAssembly(file, parameters)); } catch (BadImageFormatException) { Console.WriteLine($"BadImageFormatException!"); continue; } } } } } } else { Console.WriteLine($"DependencyContext.RuntimeLibraries. No information about assebmly {name.Name}!"); } } else { Console.WriteLine("Dependency context is null!"); } Console.WriteLine("base SearchDirectory"); return(base.SearchDirectory(name, directories, parameters)); }
public ModuleWeaverTestHelper( string inputAssembly, string inputAssemblyDirectory = null, bool modifyOriginalBinaries = false) { if (inputAssemblyDirectory == null) { inputAssemblyDirectory = @"..\..\..\" + Path.GetFileNameWithoutExtension(inputAssembly) + @"\bin\"; } #if (DEBUG) _beforeAssemblyPath = Path.GetFullPath(Path.Combine(inputAssemblyDirectory, "Debug", inputAssembly)); #else _beforeAssemblyPath = Path.GetFullPath(Path.Combine(inputAssemblyDirectory, "Release", inputAssembly)); #endif _afterAssemblyPath = _beforeAssemblyPath.Replace(".dll", "2.dll"); string oldPdb = _beforeAssemblyPath.Replace(".dll", ".pdb"); string newPdb = null; if (modifyOriginalBinaries) { newPdb = oldPdb; _afterAssemblyPath = _beforeAssemblyPath; } else { newPdb = oldPdb.Replace(".pdb", "2.pdb"); File.Copy(oldPdb, newPdb, true); File.Copy(_beforeAssemblyPath, _afterAssemblyPath, true); } Errors = new List <string>(); InfoMessages = new List <string>(); var assemblyResolver = new MockAssemblyResolver { Directory = Path.GetDirectoryName(_afterAssemblyPath) }; using (var symbolStream = File.OpenRead(newPdb)) { var readerParameters = new ReaderParameters { ReadSymbols = true, SymbolStream = symbolStream, SymbolReaderProvider = new PdbReaderProvider() }; var moduleDefinition = ModuleDefinition.ReadModule(_afterAssemblyPath, readerParameters); dynamic weavingTask = new TModuleWeaver(); Action <string> errorAction = s => Errors.Add(s); Action <string> infoAction = s => InfoMessages.Add(s); weavingTask.ModuleDefinition = moduleDefinition; weavingTask.AssemblyResolver = assemblyResolver; weavingTask.LogError = errorAction; weavingTask.LogInfo = infoAction; weavingTask.Execute(); moduleDefinition.Write(_afterAssemblyPath); ModuleDefinition = moduleDefinition; } }
public static void MethodInstrument(string targetAssembly, string src, string dst) { var inputAssembly = targetAssembly; var path = Path.GetDirectoryName(inputAssembly); var assemblyResolver = new DefaultAssemblyResolver(); var assemblyLocation = Path.GetDirectoryName(inputAssembly); assemblyResolver.AddSearchDirectory(assemblyLocation); var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver }; var writerParameters = new WriterParameters(); var origPdb = Path.ChangeExtension(inputAssembly, "pdb"); bool existpdb = false; if (File.Exists(origPdb)) { existpdb = true; var symbolReaderProvider = new PdbReaderProvider(); readerParameters.SymbolReaderProvider = symbolReaderProvider; readerParameters.ReadSymbols = true; //var symbolWriterProvider = new PdbWriterProvider(); //writerParameters.SymbolWriterProvider = symbolWriterProvider; writerParameters.WriteSymbols = true; } else { Logger.Debug(".pdb file is unavailable."); } var assemblyDefinition = AssemblyDefinition.ReadAssembly(inputAssembly, readerParameters); var module = assemblyDefinition.MainModule; //Mono.Collections.Generic.Collection<ModuleDefinition> modules = assemblyDefinition.Modules; //var module2 = ModuleDefinition.ReadModule(inputAssembly, readerParameters); //---------------------- bool isChanged = false; //---------------------------- foreach (var typeDefinition in module.Types) { if (typeDefinition.IsInterface) { continue; } foreach (var methodDefinition in typeDefinition.Methods) { ILProcessor ilprocessor = methodDefinition.Body.GetILProcessor(); Mono.Collections.Generic.Collection <Mono.Cecil.Cil.Instruction> allinstructions = methodDefinition.Body.Instructions; int instructioncnt = allinstructions.Count; for (int i = 0; i < instructioncnt; i++) { Mono.Cecil.Cil.Instruction instruction = allinstructions[i]; string instructpresent = instruction.ToString(); OpCode code = instruction.OpCode; string codepresent = code.Name; var operand = instruction.Operand; string methodname = ""; if (operand != null) { methodname = operand.ToString(); //with parameter } if ((code == OpCodes.Callvirt || code == OpCodes.Call) && //codepresent.Contains("call") (isSameMethod(methodname, src))) //or (operand as MethodReference == module.Import(src as MethodInfo)) { Logger.Debug(codepresent + " " + methodname); //debug //---------------------- remove --------------------------// /**** remove instruction in case of no replacing method is provided ****/ //TODO: 1. I note the stack depth after the call and start removing instructions, beginning with the Code.Call // and moving backward until I get to that stack depth again. // 2. return value handling ilprocessor.Remove(instruction); instructioncnt--; if (allinstructions[i].OpCode == OpCodes.Pop) //TODO: just for test { ilprocessor.Remove(allinstructions[i]); instructioncnt--; } i--; if (dst == "") { continue; } //---------------------- replace (remove + insert) ------------------------// /**** create new MethodInfo ****/ string m_type = getNamespace(dst); string m_name = getMethodName(dst); string [] m_para = getParameters(dst); MethodInfo writeLineMethod; //e.g. MethodInfo writeLineMethod = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }); if (m_para != null) { int paraCnt = m_para.Length; Type[] m_para_type = new Type[paraCnt]; for (int k = 0; k < paraCnt; k++) { m_para_type[k] = Type.GetType(m_para[k]); } writeLineMethod = Type.GetType(m_type).GetMethod(m_name, m_para_type); } else //the method does not have input parameters { writeLineMethod = Type.GetType(m_type).GetMethod(m_name, new Type[] { }); } if (writeLineMethod == null) { throw new InvalidFileFormatException("no MethodInfo is created -- possibly a wrong method delaration."); } /*** Import the new (e.g. Console.WriteLine() method) ***/ MethodReference writeLine; writeLine = module.Import(writeLineMethod); //convert "MethodInfo/MethodDefinition" to "MethodReference" /*** Creates the CIL instruction for calling the new method (e.g. Console.WriteLine(string value) method) ***/ Mono.Cecil.Cil.Instruction callWriteLine; callWriteLine = ilprocessor.Create(OpCodes.Call, writeLine); /*** replace old instruction ***/ //TODO: 1. for simple-type parameters, create one instance and push to stack; // otherwise just a null object?!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // 2. return value handling ilprocessor.InsertAfter(allinstructions[i], callWriteLine); //----------------------------------------------// isChanged = true; } } //foreach instruction of a method } //foreach method of a type/class } //foreach type/class of loaded assembly if (isChanged) { var temporaryFileName = Path.Combine(path, string.Format("{0}_temp{1}", Path.GetFileNameWithoutExtension(inputAssembly), Path.GetExtension(inputAssembly))); var backupFileName = Path.Combine(path, string.Format("{0}_orig{1}", Path.GetFileNameWithoutExtension(inputAssembly), Path.GetExtension(inputAssembly))); var tmpPdb = Path.Combine(path, string.Format("{0}_temp{1}", Path.GetFileNameWithoutExtension(inputAssembly), ".pdb")); var backupPdb = Path.Combine(path, string.Format("{0}_orig{1}", Path.GetFileNameWithoutExtension(inputAssembly), ".pdb")); //write an assembly with symbol file being rewritten //module.Write(temporaryFileName, writerParameters); assemblyDefinition.Write(temporaryFileName, writerParameters); File.Replace(temporaryFileName, inputAssembly, backupFileName); if (existpdb) { File.Replace(tmpPdb, origPdb, backupPdb); } //TODO: add snkfile in configuration file and parse ([email protected]) // If you have access to the key pair, you can ask Cecil to sign it directly. //if (snkFile != "") //{ //sn -R inputAssembly snkFile //} } }
public DirectoryAssemblyResolver(Action <string, object[]> logWarnings, bool loadDebugSymbols, ReaderParameters loadReaderParameters = null) { if (logWarnings == null) { throw new ArgumentNullException(nameof(logWarnings)); } cache = new Dictionary <string, AssemblyDefinition> (); this.loadDebugSymbols = loadDebugSymbols; this.logWarnings = logWarnings; SearchDirectories = new List <string> (); this.loadReaderParameters = loadReaderParameters ?? DefaultLoadReaderParameters; }
static void Main(string[] args) { string input = null; string output = null; string keyPairContainer = null; var options = new Mono.Options.OptionSet() { { "i|input=", i => input = i }, { "o|output:", o => output = o }, { "k|key:", k => keyPairContainer = k }, }; try { var extra = options.Parse(args); var pdb = Path.ChangeExtension(input, "pdb"); var mdb = Path.ChangeExtension(input, "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(); } var assemblyResolver = new DefaultAssemblyResolver(); assemblyResolver.AddSearchDirectory(System.IO.Path.GetDirectoryName(input)); var readParameters = new ReaderParameters() { AssemblyResolver = assemblyResolver, ReadingMode = ReadingMode.Immediate, ReadSymbols = true, SymbolReaderProvider = provider, }; var writeParameters = new WriterParameters() { WriteSymbols = true, }; if (keyPairContainer != null) { writeParameters.StrongNameKeyPair = new System.Reflection.StrongNameKeyPair(keyPairContainer); } if (output == null) { output = input; } Console.WriteLine("CilTK Rewriter"); Console.WriteLine("Reading assembly from {0}", input); Console.WriteLine("Writing assembly to {0}", output); InputAssembly = input; var assembly = Mono.Cecil.AssemblyDefinition.ReadAssembly(input, readParameters); var labelReplace = new LabelReplacer(); labelReplace.Visit(assembly); var infoReplace = new InfoReplacer(); infoReplace.Visit(assembly); var cilReplacer = new CilReplacer(labelReplace); cilReplacer.Visit(assembly); //remove references to Silk foreach (var module in assembly.Modules) { int index = -1; for (int i = 0; i < module.AssemblyReferences.Count; ++i) { if (module.AssemblyReferences[i].Name == "Silk") { index = i; break; } } if (index != -1) { module.AssemblyReferences.RemoveAt(index); } } //write to a temp file then copy to output to assist with debugging var temp = System.IO.Path.GetTempFileName(); assembly.Write(temp, writeParameters); System.IO.File.Copy(temp, output, true); } catch (Mono.Options.OptionException) { options.WriteOptionDescriptions(Console.Out); System.Environment.Exit(1); } }
public override AssemblyDefinition Resolve(string fullName, ReaderParameters parameters, TargetArchitecture platform, bool bubbleToUserIfFailed = true) { return(base.Resolve(fullName, parameters, platform, bubbleToUserIfFailed: false)); }
/// <summary>Resolve an assembly reference.</summary> /// <param name="name">The assembly name.</param> /// <param name="parameters">The assembly reader parameters.</param> public override AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) => this.ResolveName(name.Name) ?? base.Resolve(name, parameters);
public override bool Execute(out IList <Exception> thrownExceptions) { thrownExceptions = null; LoggingHelper.LogMessage(Normal, $"{new string(' ', 0)}Compiling Xaml, assembly: {Assembly}"); var skipassembly = !DefaultCompile; bool success = true; if (!File.Exists(Assembly)) { LoggingHelper.LogMessage(Normal, $"{new string(' ', 2)}Assembly file not found. Skipping XamlC."); return(true); } using (var fallbackResolver = DefaultAssemblyResolver == null ? new XamlCAssemblyResolver() : null) { var resolver = DefaultAssemblyResolver ?? fallbackResolver; if (resolver is XamlCAssemblyResolver xamlCResolver) { if (ReferencePath != null) { var paths = ReferencePath.Select(p => IOPath.GetDirectoryName(p.Replace("//", "/"))).Distinct(); foreach (var searchpath in paths) { LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Adding searchpath {searchpath}"); xamlCResolver.AddSearchDirectory(searchpath); } } } else { LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Ignoring dependency and reference paths due to an unsupported resolver"); } var debug = DebugSymbols || (!string.IsNullOrEmpty(DebugType) && DebugType.ToLowerInvariant() != "none"); var readerParameters = new ReaderParameters { AssemblyResolver = resolver, ReadWrite = !ValidateOnly, ReadSymbols = debug && !ValidateOnly, // We don't need symbols for ValidateOnly, since we won't be writing }; using (var assemblyDefinition = AssemblyDefinition.ReadAssembly(IOPath.GetFullPath(Assembly), readerParameters)) { CustomAttribute xamlcAttr; if (assemblyDefinition.HasCustomAttributes && (xamlcAttr = assemblyDefinition.CustomAttributes.FirstOrDefault( ca => ca.AttributeType.FullName == "Microsoft.Maui.Controls.Xaml.XamlCompilationAttribute")) != null) { var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value; if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip) { skipassembly = true; } if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile) { skipassembly = false; } } foreach (var module in assemblyDefinition.Modules) { var skipmodule = skipassembly; if (module.HasCustomAttributes && (xamlcAttr = module.CustomAttributes.FirstOrDefault( ca => ca.AttributeType.FullName == "Microsoft.Maui.Controls.Xaml.XamlCompilationAttribute")) != null) { var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value; if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip) { skipmodule = true; } if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile) { skipmodule = false; } } LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Module: {module.Name}"); var resourcesToPrune = new List <EmbeddedResource>(); foreach (var resource in module.Resources.OfType <EmbeddedResource>()) { LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Resource: {resource.Name}"); string classname; if (!resource.IsXaml(module, out classname)) { LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}skipped."); continue; } TypeDefinition typeDef = module.GetType(classname); if (typeDef == null) { LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}no type found... skipped."); continue; } var skiptype = skipmodule; if (typeDef.HasCustomAttributes && (xamlcAttr = typeDef.CustomAttributes.FirstOrDefault( ca => ca.AttributeType.FullName == "Microsoft.Maui.Controls.Xaml.XamlCompilationAttribute")) != null) { var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value; if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip) { skiptype = true; } if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile) { skiptype = false; } } if (Type != null) { skiptype = !(Type == classname); } if (skiptype && !ForceCompile) { LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}has XamlCompilationAttribute set to Skip and not Compile... skipped."); continue; } var initComp = typeDef.Methods.FirstOrDefault(md => md.Name == "InitializeComponent"); if (initComp == null) { LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}no InitializeComponent found... skipped."); continue; } CustomAttribute xamlFilePathAttr; var xamlFilePath = typeDef.HasCustomAttributes && (xamlFilePathAttr = typeDef.CustomAttributes.FirstOrDefault(ca => ca.AttributeType.FullName == "Microsoft.Maui.Controls.Xaml.XamlFilePathAttribute")) != null ? (string)xamlFilePathAttr.ConstructorArguments[0].Value : resource.Name; LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Parsing Xaml"); var rootnode = ParseXaml(resource.GetResourceStream(), typeDef); if (rootnode == null) { LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}failed."); continue; } LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done."); hasCompiledXamlResources = true; LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Replacing {0}.InitializeComponent ()"); Exception e; if (!TryCoreCompile(initComp, rootnode, xamlFilePath, out e)) { success = false; LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}failed."); (thrownExceptions = thrownExceptions ?? new List <Exception>()).Add(e); if (e is BuildException be) { LoggingHelper.LogError("XamlC", be.Code.Code, be.HelpLink, xamlFilePath, be.XmlInfo?.LineNumber ?? 0, be.XmlInfo?.LinePosition ?? 0, 0, 0, ErrorMessages.ResourceManager.GetString(be.Code.ErrorMessageKey), be.MessageArgs); } else if (e is XamlParseException xpe) //shouldn't happen anymore { LoggingHelper.LogError("XamlC", null, xpe.HelpLink, xamlFilePath, xpe.XmlInfo.LineNumber, xpe.XmlInfo.LinePosition, 0, 0, xpe.Message); } else if (e is XmlException xe) { LoggingHelper.LogError("XamlC", null, xe.HelpLink, xamlFilePath, xe.LineNumber, xe.LinePosition, 0, 0, xe.Message); } else { LoggingHelper.LogError("XamlC", null, e.HelpLink, xamlFilePath, 0, 0, 0, 0, e.Message); } LoggingHelper.LogMessage(Low, e.StackTrace); continue; } if (Type != null) { InitCompForType = initComp; } LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done."); if (ValidateOnly) { continue; } if (OptimizeIL) { LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Optimizing IL"); initComp.Body.Optimize(); LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done."); } resourcesToPrune.Add(resource); } if (hasCompiledXamlResources) { LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Changing the module MVID"); module.Mvid = Guid.NewGuid(); LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}done."); } if (!KeepXamlResources) { if (resourcesToPrune.Any()) { LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Removing compiled xaml resources"); } foreach (var resource in resourcesToPrune) { LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Removing {resource.Name}"); module.Resources.Remove(resource); LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done."); } } } if (ValidateOnly) { LoggingHelper.LogMessage(Low, $"{new string(' ', 0)}ValidateOnly=True. Skipping writing assembly."); return(success); } if (!hasCompiledXamlResources) { LoggingHelper.LogMessage(Low, $"{new string(' ', 0)}No compiled resources. Skipping writing assembly."); return(success); } LoggingHelper.LogMessage(Low, $"{new string(' ', 0)}Writing the assembly"); try { assemblyDefinition.Write(new WriterParameters { WriteSymbols = debug, }); LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}done."); } catch (Exception e) { LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}failed."); LoggingHelper.LogErrorFromException(e); (thrownExceptions = thrownExceptions ?? new List <Exception>()).Add(e); LoggingHelper.LogMessage(Low, e.StackTrace); success = false; } } } return(success); }
public void RunRegistrar() { // The static registrar. if (Registrar != RegistrarMode.Static) { throw new ProductException(67, Errors.MT0067, Registrar); // this is only called during our own build } if (RootAssemblies.Count < 1) { throw ErrorHelper.CreateError(130, Errors.MX0130); } var registrar_m = RegistrarOutputLibrary; var RootAssembly = RootAssemblies [0]; var resolvedAssemblies = new Dictionary <string, AssemblyDefinition> (); var resolver = new PlatformResolver() { RootDirectory = Path.GetDirectoryName(RootAssembly), #if MMP CommandLineAssemblies = RootAssemblies, #endif }; if (Platform == ApplePlatform.iOS) { if (Is32Build) { resolver.ArchDirectory = Driver.GetArch32Directory(this); } else { resolver.ArchDirectory = Driver.GetArch64Directory(this); } } var ps = new ReaderParameters(); ps.AssemblyResolver = resolver; foreach (var reference in References) { var r = resolver.Load(reference); if (r == null) { throw ErrorHelper.CreateError(2002, Errors.MT2002, reference); } } var productAssembly = Driver.GetProductAssembly(this); bool foundProductAssembly = false; foreach (var asm in RootAssemblies) { var rootName = Path.GetFileNameWithoutExtension(asm); if (rootName == productAssembly) { foundProductAssembly = true; } try { AssemblyDefinition lastAssembly = ps.AssemblyResolver.Resolve(AssemblyNameReference.Parse(rootName), new ReaderParameters()); if (lastAssembly == null) { ErrorHelper.CreateWarning(7, Errors.MX0007, rootName); continue; } if (resolvedAssemblies.TryGetValue(rootName, out var previousAssembly)) { if (lastAssembly.MainModule.RuntimeVersion != previousAssembly.MainModule.RuntimeVersion) { Driver.Log(2, "Attemping to load an assembly another time {0} (previous {1})", lastAssembly.FullName, previousAssembly.FullName); } continue; } resolvedAssemblies.Add(rootName, lastAssembly); Driver.Log(3, "Loaded {0}", lastAssembly.MainModule.FileName); } catch (Exception ex) { ErrorHelper.Warning(9, ex, Errors.MX0009, $"{rootName}: {ex.Message}"); continue; } } if (!foundProductAssembly) { throw ErrorHelper.CreateError(131, Errors.MX0131, productAssembly, string.Join("', '", RootAssemblies.ToArray())); } #if MONOTOUCH if (SelectAbis(Abis, Abi.SimulatorArchMask).Count > 0) { BuildTarget = BuildTarget.Simulator; } else if (SelectAbis(Abis, Abi.DeviceArchMask).Count > 0) { BuildTarget = BuildTarget.Device; } else { throw ErrorHelper.CreateError(99, Errors.MX0099, "No valid ABI"); } #endif var registrar = new Registrar.StaticRegistrar(this); if (RootAssemblies.Count == 1) { registrar.GenerateSingleAssembly(resolvedAssemblies.Values, Path.ChangeExtension(registrar_m, "h"), registrar_m, Path.GetFileNameWithoutExtension(RootAssembly)); } else { registrar.Generate(resolvedAssemblies.Values, Path.ChangeExtension(registrar_m, "h"), registrar_m); } }
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"); TypeStringArray = mscorlib.MainModule.GetType("System.String").MakeArrayType().Resolve(); 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 AssemblyDefinition Resolve(string fullName, ReaderParameters parameters) { return(AssemblyDefinition.ReadAssembly(Find(fullName))); }
private static void GenerateInterop(String filePath, String keyFilePath) { Console.WriteLine("Generating Interop..."); String pdbFile = Path.Combine(Path.GetDirectoryName(filePath), Path.GetFileNameWithoutExtension(filePath) + ".pdb"); ReaderParameters readerParams = new ReaderParameters(); WriterParameters writerParams = new WriterParameters(); if (keyFilePath != null) { writerParams.StrongNameKeyPair = new StrongNameKeyPair(File.Open(keyFilePath, FileMode.Open)); } if (File.Exists(pdbFile)) { readerParams.SymbolReaderProvider = new PdbReaderProvider(); readerParams.ReadSymbols = true; writerParams.WriteSymbols = true; } AssemblyDefinition assemblyDef = AssemblyDefinition.ReadAssembly(filePath, readerParams); ((BaseAssemblyResolver)assemblyDef.MainModule.AssemblyResolver).AddSearchDirectory(Path.GetDirectoryName(filePath)); AssemblyDefinition mscorLib = null; foreach (AssemblyNameReference assemblyNameReference in assemblyDef.MainModule.AssemblyReferences) { if (assemblyNameReference.Name.ToLower() == "mscorlib") { mscorLib = assemblyDef.MainModule.AssemblyResolver.Resolve(assemblyNameReference); break; } else if (assemblyNameReference.Name == "System.Runtime") { ((BaseAssemblyResolver)assemblyDef.MainModule.AssemblyResolver).AddSearchDirectory(Path.Combine(GetProgramFilesFolder(), @"Reference Assemblies\Microsoft\Framework\.NETCore\v4.5")); mscorLib = assemblyDef.MainModule.AssemblyResolver.Resolve(assemblyNameReference); break; } } if (mscorLib == null) { throw new InvalidOperationException("Missing mscorlib.dll"); } m_mscorLib = mscorLib; for (int i = 0; i < assemblyDef.CustomAttributes.Count; i++) { CustomAttribute attr = assemblyDef.CustomAttributes[i]; if (attr.AttributeType.FullName == typeof(System.Runtime.CompilerServices.CompilationRelaxationsAttribute).FullName) { assemblyDef.CustomAttributes.RemoveAt(i); i--; } } foreach (TypeDefinition typeDef in assemblyDef.MainModule.Types) { PatchType(typeDef); } RemoveInteropClass(assemblyDef); string tempFile = Path.GetTempFileName(); assemblyDef.Write(tempFile, writerParams); assemblyDef.Dispose(); File.Delete(filePath); File.Copy(tempFile, filePath); Console.WriteLine("Interop Generation complete."); }
static void Main(string[] args) { var cli = new CommandLineApplication(); cli.ResponseFileHandling = ResponseFileHandling.ParseArgsAsLineSeparated; cli.HelpOption(); var paths = cli.Argument("paths", "The input dlls or directories of dlls to instrument", true).IsRequired(); var outputOption = cli.Option("-o|--output <DIR>", "The directory where output files will be written", CommandOptionType.SingleValue); var refPathsOption = cli.Option("-r|--reference <DIR>", "Directory to search for references", CommandOptionType.MultipleValue); var exRegexOption = cli.Option("-x|--exclude <REGEX>", "A regular expression used to exclude methods for instrumentation.", CommandOptionType.MultipleValue); var incRegexOption = cli.Option("-i|--include <REGEX>", "A regular expression used to include methods for instrumentation.", CommandOptionType.MultipleValue); cli.OnExecute(() => { var processors = new List <InstrumentationProcessor>(); var directories = new HashSet <string>(); foreach (var path in paths.Values) { if (File.Exists(path)) { if (path.EndsWith(".dll")) { processors.Add(new FileProcessor(path)); string dir = Path.GetDirectoryName(Path.GetFullPath(path)); directories.Add(dir); } else if (path.EndsWith(".zip")) { processors.Add(new ZipProcessor(path)); } } else if (Directory.Exists(path)) { processors.Add(new DirectoryProcessor(path)); directories.Add(path); } } if (processors.Count == 0) { Console.WriteLine("No assemblies found"); return; } string toolsAsmPath = LocateToolsAssembly(); var globalResolver = new DefaultAssemblyResolver(); foreach (var dir in directories) { globalResolver.AddSearchDirectory(dir); } foreach (var refPath in refPathsOption.Values) { globalResolver.AddSearchDirectory(refPath); } #if DEBUG string resolverPaths = Environment.GetEnvironmentVariable("MTGINSTR_RESOLVERPATH"); if (resolverPaths != null) { Console.WriteLine("Adding debugging assembly resolver logic"); foreach (var path in resolverPaths.Split(";")) { Console.WriteLine($"Added resolver path: {path}"); globalResolver.AddSearchDirectory(path); } } #endif var readerParams = new ReaderParameters() { AssemblyResolver = globalResolver }; var toolsAsm = AssemblyDefinition.ReadAssembly(toolsAsmPath, readerParams); string outputDirectory = Environment.CurrentDirectory; if (outputOption.HasValue()) { outputDirectory = outputOption.Value(); Console.WriteLine($"Output directory: {outputDirectory}"); } var toolsContext = new ToolsAssemblyContext(toolsAsm); var opts = new InstrumenterOptions(); opts.Excludes.AddRange(exRegexOption.Values); opts.Includes.AddRange(incRegexOption.Values); var instrumenter = new AssemblyInstrumenter(toolsContext, opts); var processingContext = new ProcessingContext() { OutputDirectory = outputDirectory, Instrumenter = instrumenter, ReaderParams = readerParams }; int success = 0; foreach (var processor in processors) { try { Console.WriteLine($"Processing {processor.DisplayName}"); processor.Process(processingContext); Console.WriteLine($"Done processing {processor.DisplayName}"); success++; } catch (Exception e) { Console.WriteLine($"Error processing {processor.DisplayName}"); Console.WriteLine($"Error details: {e}"); } } if (success > 0) { Console.WriteLine($"Successfully processed {success} items"); } }); cli.Execute(args); }
public void InjectAssembly(string dllPath, string delegatePath, bool isWriteName) { m_IsWriteName = isWriteName; var readerParameters = new ReaderParameters { ReadSymbols = false }; AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(dllPath, readerParameters); m_NameLines.Clear(); foreach (var module in assembly.Modules) { List <TypeDefinition> types = module.Types.ToList(); TypeDefinition FunctionDelegate = types.Find((td) => { return(td.FullName.Contains("LCLFunctionDelegate")); }); if (FunctionDelegate != null) { m_DelegateFunctions = FunctionDelegate.NestedTypes.ToList().FindAll((_type) => { string name = _type.BaseType.Name; return(name == typeof(Delegate).Name || name == typeof(MulticastDelegate).Name); }); if (m_DelegateFunctions != null && m_DelegateFunctions.Count > 0) { break; } } } foreach (var module in assembly.Modules) { List <TypeDefinition> types = module.Types.ToList(); m_FieldDelegateNameTD = types.Find((td) => { return(td.FullName.Contains("LCLFieldDelegateName")); }); if (m_FieldDelegateNameTD != null) { break; } } foreach (var module in assembly.Modules) { foreach (var typ in module.Types) { if (typ.Namespace == null || !typ.Namespace.Contains("LCL")) { continue; } if (isWriteName) { if (!Filter.FilterType(typ)) { continue; } } foreach (var method in typ.Methods) { if (isWriteName) { if (!Filter.FilterMethod(method)) { continue; } } InjectMethod(typ, method); } } } if (!isWriteName) { var writerParameters = new WriterParameters { WriteSymbols = true }; assembly.Write(dllPath, writerParameters); if (assembly.MainModule.SymbolReader != null) { assembly.MainModule.SymbolReader.Dispose(); } } else { ILName.WritedFieldDelegateName(delegatePath, m_NameLines); } }
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters) { return(Resolve(AssemblyNameReference.Parse(fullName), parameters)); }
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) { return(AssemblyDefinition.ReadAssembly(Find(name))); }
AssemblyDefinition SearchDirectory(AssemblyNameReference name, IEnumerable <string> directories, ReaderParameters parameters) { var extensions = new [] { ".dll", ".exe" }; foreach (var directory in directories) { foreach (var extension in extensions) { string file = Path.Combine(directory, name.Name + extension); if (!File.Exists(file)) { continue; } try { return(GetAssembly(file, parameters)); } catch (BadImageFormatException) { continue; } } } return(null); }
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters) { return(ResolveInternal(fullName)); }
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) { return(ResolveInternal(name.Name)); }
public static int Main(string[] args) { for (; null != args;) { try { var fileName = args?[0]; if (null == fileName) { return((int)ExitStatus.UserCanceled); } var dirName = Path.GetDirectoryName(fileName) !; var fileNameShort = Path.GetFileNameWithoutExtension(fileName); var fileNameExt = Path.GetExtension(fileName); var fileName_Original = Path.Combine(dirName, fileNameShort + fileNameExt); var fileName_Modified = Path.Combine(dirName, fileNameShort + @".tmp"); var fileName_Backup = Path.Combine(dirName, fileNameShort + @".bak"); var fullpath = Path.GetFullPath(fileName_Original); var rm = new ReaderParameters() { ThrowIfSymbolsAreNotMatching = true, ReadSymbols = true }; rm.InMemory = true; var assembly = AssemblyDefinition.ReadAssembly(fileName_Original, rm); var module = assembly.MainModule; // ProcessCoreLibByReference(module); var modified = 0; { var OpCodes_fields = typeof(OpCodes).GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static); var asmmap = OpCodes_fields.ToDictionary(x => x.Name.ToUpperInvariant()); asmmap.Add("Ldelem".ToUpperInvariant(), typeof(OpCodes).GetField(nameof(OpCodes.Ldelem_Any), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static) !); asmmap.Add("Stelem".ToUpperInvariant(), typeof(OpCodes).GetField(nameof(OpCodes.Stelem_Any), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static) !); asmmap.Add("Unaligned_".ToUpperInvariant(), typeof(OpCodes).GetField(nameof(OpCodes.Unaligned), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static) !); var int32Converter = new System.ComponentModel.Int32Converter(); var ilAttrName = "ILMethodBodyAttribute"; foreach (var typeref in module.GetTypes()) { if (typeref is TypeDefinition type) { foreach (var method in type.Methods) { if (!method.HasCustomAttributes) { continue; } CustomAttribute?ilAttr = GetCustomAttributeByName(method, ilAttrName); if (null == ilAttr) { continue; } Console.Out.Write($@"Assembling {method.FullName}... "); var ilSource = ilAttr.ConstructorArguments[0].Value as string; using var ilSourceReader = new StringReader(ilSource !); var tts = type.GenericParameters; var ts = method.GenericParameters; if (!method.HasBody) { Console.Out.WriteLine($@"No stub body found. Skipped."); continue; } { var bd = method.Body; var ins = bd.Instructions; var ilg = (ILProcessor?)null; ilg = bd.GetILProcessor(); ilg.Clear(); /* * var insa = ins.ToArray(); * for (var i = 0; insa.Length > i; ++i) { * var inn = insa[i]; * if (null != inn) { * ilg.Remove(inn); * } * } */ { string?ilasmLine; for (; null != (ilasmLine = ilSourceReader.ReadLine());) { var sdfasd = ilasmLine.Split(new[] { ' ', '\t', }, StringSplitOptions.RemoveEmptyEntries); var sdfas = sdfasd.FirstOrDefault(); if (null == sdfas) { continue; } var sdfa = sdfas.Replace('.', '_').ToUpperInvariant(); var safsad = asmmap[sdfa]; var sdfsaf = (safsad.GetValue(null) as OpCode?); if (null == sdfsaf) { throw new Exception("gfghgh"); } var sdfdsa = sdfsaf.Value; switch (sdfdsa.OperandType) { case OperandType.InlineBrTarget: throw new NotImplementedException(); case OperandType.InlineField: throw new NotImplementedException(); case OperandType.InlineI: throw new NotImplementedException(); case OperandType.InlineI8: ilg.Append(ilg.Create(sdfdsa, int.Parse(sdfasd[1]))); break; case OperandType.InlineMethod: throw new NotImplementedException(); case OperandType.InlineNone: ilg.Append(ilg.Create(sdfdsa)); break; case OperandType.InlinePhi: throw new NotImplementedException(); case OperandType.InlineR: throw new NotImplementedException(); case OperandType.InlineSig: throw new NotImplementedException(); case OperandType.InlineString: throw new NotImplementedException(); case OperandType.InlineSwitch: throw new NotImplementedException(); case OperandType.InlineTok: throw new NotImplementedException(); case OperandType.InlineType: if (sdfasd[1].StartsWith("!!")) { ilg.Append(ilg.Create(sdfdsa, ts[int.Parse(sdfasd[1][2..])]));
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) { return(null); }
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) { var aname = name.Name; AssemblyDefinition assembly; if (cache.TryGetValue(aname, out assembly)) { return(assembly); } if (EnableRepl) { var replDir = Path.Combine(FrameworkDirectory, "repl"); if (Directory.Exists(replDir)) { assembly = SearchDirectory(aname, replDir); if (assembly != null) { return(assembly); } } } var facadeDir = Path.Combine(FrameworkDirectory, "Facades"); if (Directory.Exists(facadeDir)) { assembly = SearchDirectory(aname, facadeDir); if (assembly != null) { return(assembly); } } if (ArchDirectory != null) { assembly = SearchDirectory(aname, ArchDirectory); if (assembly != null) { return(assembly); } } assembly = SearchDirectory(aname, FrameworkDirectory); if (assembly != null) { return(assembly); } assembly = SearchDirectory(aname, RootDirectory); if (assembly != null) { return(assembly); } assembly = SearchDirectory(aname, RootDirectory, ".exe"); if (assembly != null) { return(assembly); } return(null); }
public static void HotfixInject(string inject_assembly_path, IEnumerable <string> search_directorys, IEnumerable <Type> cfg_check_types = null) { AssemblyDefinition assembly = null; try { #if HOTFIX_SYMBOLS_DISABLE assembly = AssemblyDefinition.ReadAssembly(inject_assembly_path); #else var readerParameters = new ReaderParameters { ReadSymbols = true }; assembly = AssemblyDefinition.ReadAssembly(inject_assembly_path, readerParameters); #endif init(assembly, search_directorys); if (assembly.MainModule.Types.Any(t => t.Name == "__XLUA_GEN_FLAG")) { Info("had injected!"); return; } assembly.MainModule.Types.Add(new TypeDefinition("__XLUA_GEN", "__XLUA_GEN_FLAG", Mono.Cecil.TypeAttributes.Class, objType)); Config(cfg_check_types); var hotfixDelegateAttributeType = assembly.MainModule.Types.Single(t => t.FullName == "XLua.HotfixDelegateAttribute"); hotfix_delegates = (from module in assembly.Modules from type in module.Types where type.CustomAttributes.Any(ca => ca.AttributeType == hotfixDelegateAttributeType) select type).ToList(); var hotfixAttributeType = assembly.MainModule.Types.Single(t => t.FullName == "XLua.HotfixAttribute"); foreach (var type in (from module in assembly.Modules from type in module.Types select type)) { if (!injectType(assembly, hotfixAttributeType, type)) { return; } } #if HOTFIX_SYMBOLS_DISABLE assembly.Write(inject_assembly_path); Info("hotfix inject finish!(no symbols)"); #else var writerParameters = new WriterParameters { WriteSymbols = true }; assembly.Write(inject_assembly_path, writerParameters); Info("hotfix inject finish!"); #endif } catch (Exception e) { Error("Exception! " + e); } finally { if (assembly != null) { Clean(assembly); } } }
void Run(Config config) { if (config.ShowHelp) { Console.WriteLine("Netjs compiler, Copyright 2014 Frank A. Krueger"); Console.WriteLine("netjs [options] assembly-file"); Console.WriteLine(" -help Lists all compiler options (short: -?)"); return; } if (string.IsNullOrEmpty(config.MainAssembly)) { throw new Exception("No assembly specified."); } var asmPath = Path.GetFullPath(config.MainAssembly); asmDir = Path.GetDirectoryName(asmPath); var outPath = Path.ChangeExtension(asmPath, ".ts"); Step("Reading IL"); var parameters = new ReaderParameters { AssemblyResolver = this, }; var asm = AssemblyDefinition.ReadAssembly(asmPath, parameters); mscorlib = AssemblyDefinition.ReadAssembly(typeof(String).Assembly.Location, parameters); system = AssemblyDefinition.ReadAssembly(typeof(INotifyPropertyChanged).Assembly.Location, parameters); systemCore = AssemblyDefinition.ReadAssembly(typeof(Enumerable).Assembly.Location, parameters); systemDrawing = AssemblyDefinition.ReadAssembly(typeof(System.Drawing.Bitmap).Assembly.Location, parameters); Step("Decompiling IL to C#"); var context = new DecompilerContext(asm.MainModule); context.Settings.ForEachStatement = false; context.Settings.ObjectOrCollectionInitializers = false; context.Settings.UsingStatement = false; context.Settings.AsyncAwait = false; context.Settings.AutomaticProperties = true; context.Settings.AutomaticEvents = true; context.Settings.QueryExpressions = false; context.Settings.AlwaysGenerateExceptionVariableForCatchBlocks = true; context.Settings.UsingDeclarations = false; context.Settings.FullyQualifyAmbiguousTypeNames = true; context.Settings.YieldReturn = false; var builder = new AstBuilder(context); builder.AddAssembly(asm); foreach (var a in referencedAssemblies.Values) { if (a != null) { builder.AddAssembly(a); } } builder.RunTransformations(); Step("Translating C# to TypeScript"); new CsToTs().Run(builder.SyntaxTree); Step("Writing"); using (var outputWriter = new StreamWriter(outPath)) { var output = new PlainTextOutput(outputWriter); builder.GenerateCode(output, (s, e) => new TsOutputVisitor(s, e)); } Step("Done"); }
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters) { //Info ("R4: {0}", fullName); return(null); }
AssemblyDefinition IAssemblyResolver.Resolve(string fullName, ReaderParameters parameters) { var loader = widget.AddReferenceByAssemblyName(fullName); return(loader != null ? loader.Assembly : null); }
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) { throw new NotImplementedException(); }