public CciModuleSource(ProjectFilesClone filesClone) : this() { foreach (var assembliesPath in filesClone.Assemblies) { var sss = new CodeDeepCopier(Host); var m = DecompileFile(assembliesPath.Path); var copied = sss.Copy(m.Module); m.Module = copied; _moduleInfoList.Add(m); } }
public static void Process(ILoggerContext logger, ProjectDetails assemblyDetails, string tempFolder = null) { if (!assemblyDetails.Verify(logger)) return; tempFolder = tempFolder ?? Path.GetTempPath(); string pdbFile = Path.ChangeExtension(assemblyDetails.AssemblyPath, ".pdb"); var newAssemblyPath = Path.Combine(tempFolder, String.Format("{0}.weavr{1}", Path.GetFileNameWithoutExtension(assemblyDetails.AssemblyPath), Path.GetExtension(assemblyDetails.AssemblyPath))); var newPdbPath = File.Exists(pdbFile) ? Path.ChangeExtension(newAssemblyPath, ".pdb") : null; using (var host = new PeReader.DefaultHost()) { var targetAssembly = (IAssembly)host.LoadUnitFrom(assemblyDetails.AssemblyPath); using (var pdbStream = newPdbPath != null ? File.OpenRead(pdbFile) : null) using (var pdbReader = newPdbPath != null ? new PdbReader(pdbStream, host) : null) { var decompiled = Decompiler.GetCodeModelFromMetadataModel(host, targetAssembly, pdbReader); decompiled = new CodeDeepCopier(host, pdbReader).Copy(decompiled); var engine = new Engine(logger, host); engine.Process(assemblyDetails, decompiled); using (var peStream = File.Create(newAssemblyPath)) { if (pdbReader == null) { PeWriter.WritePeToStream(decompiled, host, peStream); } else { using (var pdbWriter = new PdbWriter(newPdbPath, pdbReader)) { PeWriter.WritePeToStream(decompiled, host, peStream, pdbReader, pdbReader, pdbWriter); } } } } } File.Delete(assemblyDetails.AssemblyPath); File.Move(newAssemblyPath, assemblyDetails.AssemblyPath); if (!string.IsNullOrEmpty(newPdbPath)) { File.Delete(pdbFile); File.Move(newPdbPath, pdbFile); } }
public void Test00() { const string code = @"using System; namespace Ns { public class Test { public int Method1(int a, int b) { return a + b; } } }"; var cci = new CciModuleSource(TestProjects.DsaPath); var cci2 = new CciModuleSource(TestProjects.DsaPath); var type = cci.Modules.Single().Module.GetAllTypes().Single(t => t.Name.Value == "Deque") as NamedTypeDefinition; var method = type.Methods.Single(m => m.Name.Value == "EnqueueFront"); var cci3 = MutationTestsHelper.CreateModuleFromCode(code); var choices = new MutationSessionChoices { Filter = new MutationFilter( new List<TypeIdentifier>(), new MethodIdentifier(method).InList()), //Filter = MutationFilter.AllowAll(), SelectedOperators = new AOR_ArithmeticOperatorReplacement().InList<IMutationOperator>(), }; // var type = cci.Modules.Single().Module.GetAllTypes().Single(t => t.Name.Value == "Test") as NamedTypeDefinition; // var method = type.Methods.Single(m => m.Name.Value == "Method1"); var exec = new MutationExecutor(null, choices, null); var container = new MutantsContainer(exec, new OriginalCodebase(cci.InList(), new List<string>())); IList<AssemblyNode> assemblies = container.InitMutantsForOperators(ProgressCounter.Inactive()); var mut = assemblies.Cast<CheckedNode>() .SelectManyRecursive(n => n.Children ?? new NotifyingCollection<CheckedNode>()) .OfType<Mutant>().ElementAt(4); MutationResult executeMutation = exec.ExecuteMutation(mut, cci2).Result; var c = new CodeDeepCopier(cci.Host); MethodDefinition methodDefinition = c.Copy(mut.MutationTarget.MethodRaw); var vis = new CodeVisualizer(null, null); var s = vis.Visualize(CodeLanguage.CSharp, cci2); var v = new MutantsCache.Viss(cci2.Host, methodDefinition); var modClean = v.Rewrite(cci2.Modules.Single().Module); cci2.ReplaceWith(modClean); var debug = new DebugOperatorCodeVisitor(); var debug2 = new DebugOperatorCodeVisitor(); new DebugCodeTraverser(debug).Traverse(cci.Modules.Single().Module); new DebugCodeTraverser(debug2).Traverse(cci2.Modules.Single().Module); File.WriteAllText(@"C:\PLIKI\tree1.txt", debug.ToString()); File.WriteAllText(@"C:\PLIKI\tree2.txt", debug2.ToString()); // Console.WriteLine(debug); // Console.WriteLine(debug2); // cci.ReplaceWith(executeMutation.MutatedModules.Modules.Single().Module); // var s2 = vis.Visualize(CodeLanguage.CSharp, cci2); // Console.WriteLine(s); // Console.WriteLine(s2); // var viss = new Viss(cci2.Host, sourceMethod); // IModule newMod = viss.Rewrite(executeMutation.MutatedModules.Modules.Single().Module); // cci2.ReplaceWith(executeMutation.MutatedModules.Modules.Single().Module); // MutationResult executeMutation2 = exec.ExecuteMutation(mut, cci2).Result; }
private void GenerateIL() { IEnumerable<ILocalDefinition> localVariables; ushort maxStack; IEnumerable<ILocalScope> iteratorScopes; IEnumerable<ILocalScope> localScopes; IEnumerable<INamespaceScope> namespaceScopes; IEnumerable<IOperation> operations; IEnumerable<IOperationExceptionInformation> operationExceptionInformation; List<ITypeDefinition>/*?*/ privateHelperTypes = this.privateHelperTypes; var isNormalized = this.isNormalized; NormalizationChecker checker = null; if (!isNormalized) { //Assuming that most methods are not iterators and do not contain anonymous delegates, it is worth our while to check if this is really the case. checker = new NormalizationChecker(); checker.TraverseChildren(this.Block); isNormalized = !checker.foundAnonymousDelegate && !checker.foundYield; } if (isNormalized) { var converter = new CodeModelToILConverter(this.host, this.MethodDefinition, this.sourceLocationProvider, this.iteratorLocalCount); converter.ConvertToIL(this.Block); iteratorScopes = converter.GetIteratorScopes(); localScopes = converter.GetLocalScopes(); localVariables = converter.GetLocalVariables(); maxStack = converter.MaximumStackSizeNeeded; namespaceScopes = converter.GetNamespaceScopes(); operations = converter.GetOperations(); operationExceptionInformation = converter.GetOperationExceptionInformation(); } else { //This object might already be immutable and we are just doing delayed initialization, so make a copy of this.Block. var mutableBlock = new CodeDeepCopier(this.host).Copy(this.Block); if (checker.foundAnonymousDelegate) { var remover = new AnonymousDelegateRemover(this.host, this.sourceLocationProvider); remover.RemoveAnonymousDelegates(this.MethodDefinition, mutableBlock); privateHelperTypes = remover.closureClasses; } var normalizer = new MethodBodyNormalizer(this.host, this.sourceLocationProvider); var normalizedBody = (SourceMethodBody)normalizer.GetNormalizedSourceMethodBodyFor(this.MethodDefinition, mutableBlock); normalizedBody.isNormalized = true; iteratorScopes = normalizedBody.IteratorScopes; localScopes = normalizedBody.LocalScopes; localVariables = normalizedBody.LocalVariables; maxStack = normalizedBody.MaxStack; namespaceScopes = normalizedBody.NamespaceScopes; operations = normalizedBody.Operations; operationExceptionInformation = normalizedBody.OperationExceptionInformation; if (privateHelperTypes == null) privateHelperTypes = normalizedBody.PrivateHelperTypes; else //this can happen when this source method body has already been partially normalized, for instance by the removal of yield statements. privateHelperTypes.AddRange(normalizedBody.PrivateHelperTypes); } lock (this) { if (this.ilWasGenerated) return; this.ilWasGenerated = true; this.iteratorScopes = iteratorScopes; this.localScopes = localScopes; this.localVariables = localVariables; this.maxStack = maxStack; this.namespaceScopes = namespaceScopes; this.operations = operations; this.operationExceptionInformation = operationExceptionInformation; this.privateHelperTypes = privateHelperTypes; } }
public static Bpl.Program/*?*/ TranslateAssembly(List<string> assemblyNames, HeapFactory heapFactory, Options options, List<Regex> exemptionList, bool whiteList) { Contract.Requires(assemblyNames != null); Contract.Requires(heapFactory != null); var libPaths = options.libpaths; var wholeProgram = options.wholeProgram; var/*?*/ stubAssemblies = options.stub; var phoneControlsConfigFile = options.phoneControls; var doPhoneNav = options.phoneNavigationCode; var doPhoneFeedback = options.phoneFeedbackCode; var host = new CodeContractAwareHostEnvironment(libPaths != null ? libPaths : Enumerable<string>.Empty, true, true); Host = host; Bpl.CommandLineOptions.Install(new Bpl.CommandLineOptions()); #region Assemlies to translate (via cmd line) modules = new List<IModule>(); var contractExtractors = new Dictionary<IUnit, IContractProvider>(); var pdbReaders = new Dictionary<IUnit, PdbReader>(); #region Load *all* of the assemblies before doing anything else so that they can all vote on unification matters foreach (var a in assemblyNames) { var module = host.LoadUnitFrom(a) as IModule; if (module == null || module == Dummy.Module || module == Dummy.Assembly) { Console.WriteLine(a + " is not a PE file containing a CLR module or assembly, or an error occurred when loading it."); Console.WriteLine("Skipping it, continuing with other input assemblies"); continue; } modules.Add(module); } #endregion #region Decompile all of the assemblies var decompiledModules = new List<IModule>(); foreach (var m in modules) { PdbReader/*?*/ pdbReader = null; string pdbFile = Path.ChangeExtension(m.Location, "pdb"); if (File.Exists(pdbFile)) { Stream pdbStream = File.OpenRead(pdbFile); pdbReader = new PdbReader(pdbStream, host); } var m2 = Decompiler.GetCodeModelFromMetadataModel(host, m, pdbReader, DecompilerOptions.Unstack) as IModule; // The decompiler does not turn calls to Assert/Assume into Code Model nodes m2 = new Microsoft.Cci.MutableContracts.ContractExtractor.AssertAssumeExtractor(host, pdbReader).Rewrite(m2); decompiledModules.Add(m2); host.RegisterAsLatest(m2); contractExtractors.Add(m2, host.GetContractExtractor(m2.UnitIdentity)); pdbReaders.Add(m2, pdbReader); } modules = decompiledModules; #endregion #endregion #region Assemblies to translate (stubs) if (stubAssemblies != null) { foreach (var s in stubAssemblies) { var module = host.LoadUnitFrom(s) as IModule; if (module == null || module == Dummy.Module || module == Dummy.Assembly) { Console.WriteLine(s + " is not a PE file containing a CLR module or assembly, or an error occurred when loading it."); Console.WriteLine("Skipping it, continuing with other input assemblies"); } PdbReader/*?*/ pdbReader = null; string pdbFile = Path.ChangeExtension(module.Location, "pdb"); if (File.Exists(pdbFile)) { Stream pdbStream = File.OpenRead(pdbFile); pdbReader = new PdbReader(pdbStream, host); } module = Decompiler.GetCodeModelFromMetadataModel(host, module, pdbReader, DecompilerOptions.Unstack) as IModule; var copier = new CodeDeepCopier(host); var mutableModule = copier.Copy(module); var mscorlib = TypeHelper.GetDefiningUnit(host.PlatformType.SystemObject.ResolvedType); //var mutator = new ReparentModule(host, mscorlib, mutableModule); //module = mutator.Rewrite(mutableModule); //modules.Add(Tuple.Create(module, pdbReader)); RewriteUnitReferences renamer = new RewriteUnitReferences(host, mutableModule); var mscorlibAssembly = (IAssembly)mscorlib; renamer.targetAssembly = mscorlibAssembly; renamer.originalAssemblyIdentity = mscorlibAssembly.AssemblyIdentity; renamer.RewriteChildren(mutableModule); modules.Add((IModule)mutableModule); contractExtractors.Add(module, host.GetContractExtractor(module.UnitIdentity)); pdbReaders.Add(module, pdbReader); } } #endregion if (modules.Count == 0) { throw new TranslationException("No input assemblies to translate."); } var primaryModule = modules[0]; Sink sink= new Sink(host, heapFactory, options, exemptionList, whiteList); TranslationHelper.tmpVarCounter = 0; // TODO move away, get all plugin and translators from a config file or alike #region Plugged translators List<Translator> translatorsPlugged = new List<Translator>(); ITranslationPlugin bctPlugin= new BytecodeTranslatorPlugin(wholeProgram); Translator bcTranslator = bctPlugin.getTranslator(sink, contractExtractors, pdbReaders); translatorsPlugged.Add(bcTranslator); if (phoneControlsConfigFile != null && phoneControlsConfigFile != "") { // TODO this should be part of the translator initialziation PhoneCodeHelper.initialize(host); PhoneCodeHelper.instance().PhonePlugin = new PhoneControlsPlugin(phoneControlsConfigFile); if (doPhoneNav) { // TODO this should be part of the translator initialziation PhoneCodeHelper.instance().PhoneNavigationToggled = true; ITranslationPlugin phoneInitPlugin = new PhoneInitializationPlugin(); ITranslationPlugin phoneNavPlugin = new PhoneNavigationPlugin(); Translator phInitTranslator = phoneInitPlugin.getTranslator(sink, contractExtractors, pdbReaders); Translator phNavTranslator = phoneNavPlugin.getTranslator(sink, contractExtractors, pdbReaders); translatorsPlugged.Add(phInitTranslator); translatorsPlugged.Add(phNavTranslator); } if (doPhoneFeedback) { // TODO this should be part of the translator initialziation PhoneCodeHelper.instance().PhoneFeedbackToggled = true; ITranslationPlugin phoneFeedbackPlugin = new PhoneFeedbackPlugin(); Translator phFeedbackTranslator = phoneFeedbackPlugin.getTranslator(sink, contractExtractors, pdbReaders); translatorsPlugged.Add(phFeedbackTranslator); } } #endregion sink.TranslationPlugins = translatorsPlugged; /* if (phoneControlsConfigFile != null && phoneControlsConfigFile != "") { // TODO send this all way to initialization of phone plugin translator PhoneCodeHelper.initialize(host); PhoneCodeHelper.instance().PhonePlugin = new PhoneControlsPlugin(phoneControlsConfigFile); // TODO these parameters will eventually form part of plugin configuration if (doPhoneNav) { PhoneCodeHelper.instance().PhoneNavigationToggled = true; PhoneInitializationMetadataTraverser initTr = new PhoneInitializationMetadataTraverser(host); initTr.InjectPhoneCodeAssemblies(modules); PhoneNavigationMetadataTraverser navTr = new PhoneNavigationMetadataTraverser(host); navTr.InjectPhoneCodeAssemblies(modules); } if (doPhoneFeedback) { PhoneCodeHelper.instance().PhoneFeedbackToggled = true; PhoneControlFeedbackMetadataTraverser fbMetaDataTraverser= new PhoneControlFeedbackMetadataTraverser(host); fbMetaDataTraverser.Visit(modules); } } */ // TODO replace the whole translation by a translator initialization and an orchestrator calling back for each element // TODO for the current BC translator it will possibly just implement onMetadataElement(IModule) // TODO refactor this away, handle priorities between plugged translators IOrderedEnumerable<Translator> prioritizedTranslators = translatorsPlugged.OrderBy(t => t.getPriority()); foreach (Translator t in prioritizedTranslators) { t.initialize(); if (t.isOneShot()) t.TranslateAssemblies(modules); } foreach (var pair in sink.delegateTypeToDelegates.Values) { CreateDispatchMethod(sink, pair.Item1, pair.Item2); CreateDelegateCreateMethod(sink, pair.Item1, pair.Item2); CreateDelegateAddMethod(sink, pair.Item1, pair.Item2); CreateDelegateRemoveMethod(sink, pair.Item1, pair.Item2); } // Subtyping for extern types if(sink.Options.typeInfo > 0) sink.DeclareExternTypeSubtyping(); string outputFileName = primaryModule.Name + ".bpl"; callPostTranslationTraversers(modules, sink, phoneControlsConfigFile, outputFileName); if (PhoneCodeHelper.instance().PhoneNavigationToggled) { finalizeNavigationAnalysisAndBoogieCode(phoneControlsConfigFile, sink, outputFileName); } //sink.CreateIdentifierCorrespondenceTable(primaryModule.Name.Value); //var rc = new Bpl.ResolutionContext((Bpl.IErrorSink)null); //foreach (var decl in sink.TranslatedProgram.TopLevelDeclarations) { // decl.Register(rc); //} //sink.TranslatedProgram.Resolve(rc); //var goodDecls = new List<Bpl.Declaration>(); //var tc = new Bpl.TypecheckingContext(null); //foreach (var decl in sink.TranslatedProgram.TopLevelDeclarations) { // var impl = decl as Bpl.Implementation; // if (impl == null) { // goodDecls.Add(decl); // continue; // } // try { // //var tc = new Bpl.TypecheckingContext(null); // impl.Typecheck(tc); // goodDecls.Add(impl); // } catch { // Console.WriteLine("Deleting implementation for: " + impl.Name); // // nothing to do, just continue // } //} //sink.TranslatedProgram.TopLevelDeclarations = goodDecls; return sink.TranslatedProgram; }
bool isEnumerable; // true if return type of method is IEnumerable, false if return type of method is IEnumerator /// <summary> /// Compile the method body, represented by <paramref name="block"/>. It creates the closure class and all its members /// and creates a new body for the iterator method. /// </summary> internal BlockStatement CompileIterator(IBlockStatement block) { var copier = new CodeDeepCopier(this.host, this.sourceLocationProvider); var copiedBlock = copier.Copy(block); var localCollector = new LocalCollector(); new CodeTraverser() { PreorderVisitor = localCollector }.Traverse(copiedBlock); this.allLocals = localCollector.allLocals; IteratorClosureInformation iteratorClosure = this.CreateIteratorClosure(copiedBlock); var result = this.CreateNewIteratorMethodBody(iteratorClosure); return result; }
public static IExpression MakeEnsures(IMetadataHost host, IMethodDefinition getter, IExpression expression) { var e = new CodeDeepCopier(host).Copy(expression); var rewriter = new ReplaceAutoPropGetter(host, getter, null); return rewriter.Rewrite(e); }