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);
}
