static void ReadMutateAndResolve(string sourceLocation)
{
ExtractAndCompile(sourceLocation);
string dllLocation = Path.ChangeExtension(sourceLocation, ".dll");
using (var host = new PeReader.DefaultHost()) {
//Read the Metadata Model from the PE file
var module = host.LoadUnitFrom(dllLocation) as IModule;
if (module == null || module == Dummy.Module || module == Dummy.Assembly)
{
Console.WriteLine(dllLocation + " is not a PE file containing a CLR module or assembly.");
return;
}
//Get a PDB reader if there is a PDB file.
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 = MetadataCopier.DeepCopy(host, module);
module = new MetadataRewriter(host).Rewrite(module);
TestResolution resolver = new TestResolution(host);
resolver.Visit(module);
string result = resolver.Output.ToString();
Assert.True(!result.Contains("Dummy"));
}
}
public override void Initialize()
{
CoreAssembly = Host.LoadAssembly(Host.CoreAssemblySymbolicIdentity);
var host = new PeReader.DefaultHost();
IModule module = OperatorUtils.CompileModuleFromCode(
@"using System;
namespace VisualMutatorGeneratedNamespace
{
public class VisualMutatorGeneratedClass
{
public static int FailOnZero(int x)
{
if(x == 0) throw new InvalidOperationException(""FailOnZero: x"");
return x;
}
}
}", host);
GeneratedType = (NamespaceTypeDefinition)module.GetAllTypes().Single(t => t.Name.Value == "VisualMutatorGeneratedClass");
var methodBody = TypeHelper.GetMethod(GeneratedType,
host.NameTable.GetNameFor("FailOnZero"), host.PlatformType.SystemInt32).Body;
var generatedBody = (SourceMethodBody)methodBody;
GeneratedBlock = generatedBody.Block;
host.Dispose();
}
static void Main(string[] args)
{
if (args == null || args.Length == 0)
{
Console.WriteLine("usage: peToText [path]fileName.ext");
return;
}
using (var host = new PeReader.DefaultHost()) {
IModule /*?*/ module = host.LoadUnitFrom(args[0]) as IModule;
if (module == null || module == Dummy.Module || module == Dummy.Assembly)
{
Console.WriteLine(args[0] + " is not a PE file containing a CLR module or assembly.");
return;
}
PdbReader /*?*/ pdbReader = null;
string pdbFile = Path.ChangeExtension(module.Location, "pdb");
if (File.Exists(pdbFile))
{
Stream pdbStream = File.OpenRead(pdbFile);
pdbReader = new PdbReader(pdbStream, host);
}
using (pdbReader) {
string txtFile = Path.ChangeExtension(pdbFile, "txt");
using (var writer = new StreamWriter(txtFile)) {
SourceEmitter csSourceEmitter = new SourceEmitter(writer, host, pdbReader);
csSourceEmitter.Traverse((INamespaceDefinition)module.UnitNamespaceRoot);
writer.Close();
}
}
}
}
static void Main(string[] args)
{
MetadataReaderHost host = new PeReader.DefaultHost();
string file = null; // yeah i know i'm lazy
Assembly assembly = (Assembly)host.LoadUnitFrom(file);
foreach (var type in assembly.AllTypes)
{
foreach (MethodDefinition method in type.Methods)
{
var arguments = from IParameterDefinition param in method.Parameters
select string.Format("{0} {1}", param.Type.ToString(), param.Name.Value);
string signature = string.Format("{0} {1}::{2}({3})", method.Type.ToString(), type.Name.ToString(), method.Name.ToString(), string.Join(",", arguments.ToArray()));
Block block = new Block();
block = block
[Ops.Ldstr, "]"]
[Ops.Call, () => System.Diagnostics.Trace.WriteLine(null)];
//[Ops.Ldstr, "["];
Injector.Inject(method, block);
}
}
}
public override void Initialize()
{
// CoreAssembly = Host.LoadAssembly(Host.CoreAssemblySymbolicIdentity);
var host = new PeReader.DefaultHost();
IModule module = OperatorUtils.CompileModuleFromCode(
@"public class GenException : Exception
{
public GenException()
{
}
public GenException(object o1)
{
}
public GenException(object o1, object o2)
{
}
}", host);
/* GeneratedType = (NamespaceTypeDefinition)module.GetAllTypes().Single(t => t.Name.Value == "VisualMutatorGeneratedClass");
* var methodBody = TypeHelper.GetMethod(GeneratedType,
* host.NameTable.GetNameFor("FailOnZero"), host.PlatformType.SystemInt32).Body;
* var generatedBody = (SourceMethodBody)methodBody;
* GeneratedBlock = generatedBody.Block;*/
host.Dispose();
}
static void Main(string[] args)
{
const string root = @"..\..\..";
//const string root = @"C:"; // casa
//const string root = @"C:\Users\Edgar\Projects"; // facu
const string input = root + @"\Test\bin\Debug\Test.dll";
using (var host = new PeReader.DefaultHost())
using (var assembly = new Assembly(host))
{
assembly.Load(input);
Types.Initialize(host);
//var extractor = new TypesExtractor(host);
//extractor.Extract(assembly.Module);
var visitor = new MethodVisitor(host, assembly.PdbReader);
visitor.Rewrite(assembly.Module);
}
System.Console.WriteLine("Done!");
System.Console.ReadKey();
}
public Helper(IModule module, PeReader.DefaultHost host, Log.Log logger)
{
this.host = host;
this.logger = logger;
this.module = module;
// get all needed functions and namespaces
this.systemString = UnitHelper.FindType(this.host.NameTable, this.host.LoadAssembly(this.host.CoreAssemblySymbolicIdentity), "System.String");
this.systemIOTextWriter = UnitHelper.FindType(this.host.NameTable, this.host.LoadAssembly(this.host.CoreAssemblySymbolicIdentity), "System.IO.TextWriter");
this.systemIOStreamWriter = UnitHelper.FindType(this.host.NameTable, this.host.LoadAssembly(this.host.CoreAssemblySymbolicIdentity), "System.IO.StreamWriter");
this.systemInt32 = UnitHelper.FindType(this.host.NameTable, this.host.LoadAssembly(this.host.CoreAssemblySymbolicIdentity), "System.Int32");
this.systemObject = UnitHelper.FindType(this.host.NameTable, this.host.LoadAssembly(this.host.CoreAssemblySymbolicIdentity), "System.Object");
this.systemConsole = UnitHelper.FindType(this.host.NameTable, this.host.LoadAssembly(this.host.CoreAssemblySymbolicIdentity), "System.Console");
this.systemRandom = UnitHelper.FindType(this.host.NameTable, this.host.LoadAssembly(this.host.CoreAssemblySymbolicIdentity), "System.Random");
ITypeReference[] concatThreeParameterTypes = { this.host.PlatformType.SystemString, this.host.PlatformType.SystemString, this.host.PlatformType.SystemString };
ITypeReference[] concatTwoParameterTypes = { this.host.PlatformType.SystemString, this.host.PlatformType.SystemString };
ITypeReference[] streamWriterAppendTypes = { this.host.PlatformType.SystemString, this.host.PlatformType.SystemBoolean };
this.stringConcatThree = TypeHelper.GetMethod(systemString, this.host.NameTable.GetNameFor("Concat"), concatThreeParameterTypes);
this.stringConcatTwo = TypeHelper.GetMethod(systemString, this.host.NameTable.GetNameFor("Concat"), concatTwoParameterTypes);
this.textWriterWriteLine = TypeHelper.GetMethod(systemIOTextWriter, this.host.NameTable.GetNameFor("WriteLine"), this.host.PlatformType.SystemString);
this.streamWriterCtor = TypeHelper.GetMethod(systemIOStreamWriter, this.host.NameTable.GetNameFor(".ctor"), this.host.PlatformType.SystemString);
this.streamWriterCtorAppend = TypeHelper.GetMethod(systemIOStreamWriter, this.host.NameTable.GetNameFor(".ctor"), streamWriterAppendTypes);
this.textWriterWrite = TypeHelper.GetMethod(systemIOTextWriter, this.host.NameTable.GetNameFor("Write"), this.host.PlatformType.SystemString);
this.int32ToString = TypeHelper.GetMethod(systemInt32, this.host.NameTable.GetNameFor("ToString"));
this.textWriterClose = TypeHelper.GetMethod(systemIOTextWriter, this.host.NameTable.GetNameFor("Close"));
this.objectGetHashCode = TypeHelper.GetMethod(systemObject, this.host.NameTable.GetNameFor("GetHashCode"));
this.systemConsoleWriteLine = TypeHelper.GetMethod(systemConsole, host.NameTable.GetNameFor("WriteLine"), host.PlatformType.SystemString);
this.objectCtor = TypeHelper.GetMethod(systemObject, this.host.NameTable.GetNameFor(".ctor"));
this.systemRandomCtor = TypeHelper.GetMethod(systemRandom, this.host.NameTable.GetNameFor(".ctor"));
this.systemRandomNext = TypeHelper.GetMethod(systemRandom, this.host.NameTable.GetNameFor("Next"), host.PlatformType.SystemInt32);
}
public InterfaceTransformer(IModule module, PeReader.DefaultHost host, Log.Log logger)
{
this.host = host;
this.logger = logger;
this.module = module;
this.helperClass = new Helper(module, host, logger);
}
public static void RunZeroAnalysisExample()
{
string liveVariableExample = CompileZeroAnalysisExample();
using (var host = new PeReader.DefaultHost())
using (var assembly = new Assembly(host))
{
// load binaries that are gonna be analyzed
Types.Initialize(host);
assembly.Load(liveVariableExample);
// search for the method definition in the assembly
// if you inspect this method definitions they are defined using the .NET IL instructions (aka bytecode)
var allDefinedMethodsInAssembly = assembly.Module.GetAllTypes() // get all defined types in the assembly (these are cci objects)
.SelectMany(typeDefinition => typeDefinition.Methods); /// get all defined methods (these are cci objects)
var targetMethod = allDefinedMethodsInAssembly.Where(m => m.Name.Value.Contains("TestZero")).First();
// transform it into a typed stackless three addres code representation
// this is a result of analysis-net framework
ControlFlowGraph cfg = null;
MethodBody methodBody = Transformations.ThreeAddressCode(targetMethod, host, out cfg);
// on top of the three address representation we apply a live variable analysis
// it is far easier to implement such analysis on this representation
// if you intent to apply it on top of the IL bytecode, you will have to guess what you have in the stack for each instruction
ZeroAnalysis zeroAnalysis = new ZeroAnalysis(cfg);
var r = zeroAnalysis.Analyze();
}
}
static void Run(string sourceName)
{
var path = ExtractAndCompile(sourceName);
try
{
Assembly assembly;
using (var host = new PeReader.DefaultHost())
using (var pdbStream = File.OpenRead(Path.ChangeExtension(path, ".pdb")))
{
var pdbreader = new PdbReader(pdbStream, host);
var loaded = host.LoadAssembly(new AssemblyIdentity(host.NameTable.GetNameFor(Path.GetFileNameWithoutExtension(path)), null, new Version(), null, path));
var dynamicLoader = new DynamicLoader(pdbreader, pdbreader);
assembly = dynamicLoader.Load(loaded);
}
var type = assembly.GetTypes().Single(t => t.Name == sourceName && Attribute.GetCustomAttribute(t, typeof(CompilerGeneratedAttribute)) == null);
var foo = Activator.CreateInstance(type);
var method = type.GetMethod("Run");
var action = (Action)Delegate.CreateDelegate(typeof(Action), foo, method);
action();
}
finally
{
File.Delete(path);
}
}
private static void ReadMethodLocations(Dictionary <string, string> methodLocations, string pdbFixturePath, string peFixturePath)
{
var host = new PeReader.DefaultHost();
var pdbFileStream = File.OpenRead(pdbFixturePath);
var peReader = new PeReader(host);
var pdbReader = new PdbReader(pdbFileStream, host);
var assembly = peReader.OpenAssembly(
BinaryDocument.GetBinaryDocumentForFile(peFixturePath, host)
);
foreach (var type in assembly.GetAllTypes())
{
foreach (var member in type.Members)
{
foreach (var sourceLocation in pdbReader.GetPrimarySourceLocationsFor(member.Locations))
{
var memberName = $"{member}";
if (!methodLocations.ContainsKey(memberName))
{
methodLocations.Add(
memberName,
$"{sourceLocation.SourceDocument.Name}:{sourceLocation.StartLine}"
);
}
}
}
}
}
static void Main(string[] argv)
{
if (argv == null || argv.Length < 1)
{
Console.WriteLine("Usage: Main <assemblys> [<outputPath>]");
}
using (var host = new PeReader.DefaultHost()) {
var module = host.LoadUnitFrom(argv[0]) as IModule;
if (module == null || module == Dummy.Module || module == Dummy.Assembly)
{
throw new Exception(argv[0] + " is not a PE file containing a CLR assembly, or an error occurred when loading it.");
}
PdbReader pdbReader = null;
string pdbFile = Path.ChangeExtension(module.Location, "pdb");
if (File.Exists(pdbFile))
{
using (var pdbStream = File.OpenRead(pdbFile)) {
pdbReader = new PdbReader(pdbStream, host);
}
}
else
{
Console.WriteLine("Could not load the PDB file for '" + module.Name.Value + "' . Proceeding anyway.");
}
using (pdbReader) {
var copy = new MetadataDeepCopier(host).Copy(module);
var shadowFieldsAddedAssembly = new ShadowFieldRewriter(host).Rewrite(copy);
var shadowFieldsAndMethodsAddedAssembly = new ShadowMethodRewriter(host).Rewrite(shadowFieldsAddedAssembly);
var rewrittenAssembly = new FinalizeMethodRewriter(host).Rewrite(shadowFieldsAndMethodsAddedAssembly);
var main = rewrittenAssembly.EntryPoint.ResolvedMethod;
if (main != Dummy.Method)
{
var body = main.Body as MethodBody;
if (body != null)
{
new AddGCWaitForFinalization(host, body).Rewrite();
}
}
var validator = new MetadataValidator(host);
validator.Validate(rewrittenAssembly as IAssembly);
string outputPath = rewrittenAssembly.Location + ".meta";
var outputFileName = Path.GetFileNameWithoutExtension(outputPath);
// Need to not pass in a local scope provider until such time as we have one that will use the mutator
// to remap things (like the type of a scope constant) from the original assembly to the mutated one.
using (var peStream = File.Create(outputPath)) {
using (var pdbWriter = new PdbWriter(outputFileName + ".pdb", pdbReader)) {
PeWriter.WritePeToStream(rewrittenAssembly, host, peStream, pdbReader, null, pdbWriter);
}
}
}
}
}
public CfgManipulator(IModule module, PeReader.DefaultHost host, Log.Log logger, MethodCfg methodCfg)
{
this.host = host;
this.logger = logger;
this.module = module;
this.methodCfg = methodCfg;
}
static int Main(string[] args)
{
if (args == null || args.Length < 1)
{
Console.WriteLine("Usage: ILMutator <assembly> [<outputPath>]");
return(1);
}
using (var host = new PeReader.DefaultHost()) {
IModule /*?*/ module = host.LoadUnitFrom(args[0]) as IModule;
if (module == null || module is Dummy)
{
Console.WriteLine(args[0] + " is not a PE file containing a CLR assembly, or an error occurred when loading it.");
return(1);
}
module = new MetadataDeepCopier(host).Copy(module);
PdbReader /*?*/ pdbReader = null;
string pdbFile = Path.ChangeExtension(module.Location, "pdb");
if (File.Exists(pdbFile))
{
using (var pdbStream = File.OpenRead(pdbFile)) {
pdbReader = new PdbReader(pdbStream, host);
}
}
else
{
Console.WriteLine("Could not load the PDB file for '" + module.Name.Value + "' . Proceeding anyway.");
}
using (pdbReader) {
var localScopeProvider = pdbReader == null ? null : new ILGenerator.LocalScopeProvider(pdbReader);
ILMutator mutator = new ILMutator(host, pdbReader);
module = mutator.Rewrite(module);
string newName;
if (args.Length == 2)
{
newName = args[1];
}
else
{
var loc = module.Location;
var path = Path.GetDirectoryName(loc) ?? "";
var fileName = Path.GetFileNameWithoutExtension(loc);
var ext = Path.GetExtension(loc);
newName = Path.Combine(path, fileName + "1" + ext);
}
using (var peStream = File.Create(newName)) {
using (var pdbWriter = new PdbWriter(Path.ChangeExtension(newName, ".pdb"), pdbReader)) {
PeWriter.WritePeToStream(module, host, peStream, pdbReader, localScopeProvider, pdbWriter);
}
}
}
return(0); // success
}
}
public static Tuple <List <Assembly>, List <Assembly> > LoadAssemblies(PeReader.DefaultHost host, Options options)
{
// First, load all the reference assemblies.
var refs = new List <Assembly>();
foreach (var rassembly in options.ReferenceAssemblies)
{
try
{
//TODO: is this a CCI bug?
if (rassembly.EndsWith("__ScopeCodeGen__.dll"))
{
continue;
}
var rasm = new Assembly(host);
rasm.Load(rassembly);
refs.Add(rasm);
Utils.WriteLine("Successfully loaded reference assembly: " + rassembly);
}
catch (AccessViolationException e)
{
Utils.WriteLine("Warning: perhaps this is a library with unmanaged code?");
}
catch (Exception e)
{
Utils.WriteLine(String.Format("Warning: failed to load reference assembly {0} ({1})", rassembly, e.Message));
}
}
// Now, load the main assemblies.
var assemblies = new List <Assembly>();
foreach (var assembly in options.Assemblies)
{
try
{
var asm = new Assembly(host);
asm.Load(assembly);
assemblies.Add(asm);
Utils.WriteLine("Successfully loaded main assembly: " + assembly);
}
catch (AccessViolationException e)
{
Utils.WriteLine("Warning: perhaps this is a library with unmanaged code?");
}
catch (Exception e)
{
Utils.WriteLine(String.Format("LOAD FAILURE: failed to load main assembly {0} ({1})", assembly, e.Message));
}
}
Types.Initialize(host);
return(new Tuple <List <Assembly>, List <Assembly> >(assemblies, refs));
}
private Tuple <IMetadataHost, Assembly, IEnumerable <Assembly> > Initialize()
{
var options = Options.ParseCommandLineArguments(args);
var host = new PeReader.DefaultHost();
var data = ScopeAnalyzer.Program.LoadAssemblies(host, options);
var mainAssemblies = data.Item1;
Assert.AreEqual(mainAssemblies.Count, 1);
return(new Tuple <IMetadataHost, Assembly, IEnumerable <Assembly> >(host, mainAssemblies[0], data.Item2));
}
public static ScopeAnalysisStats AnalyzeAssemblies(Options options)
{
Utils.IsVerbose = options.Verbose;
var vertexDef = LoadVertexDef(options);
var processorIdMapping = LoadProcessorMapping(options);
var host = new PeReader.DefaultHost();
var assemblies = LoadAssemblies(host, options);
var stats = new ScopeAnalysisStats();
stats.Assemblies = options.Assemblies.Count;
var mainAssemblies = assemblies.Item1;
stats.AssembliesLoaded = mainAssemblies.Count;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
foreach (var mAssembly in mainAssemblies)
{
try
{
Utils.WriteLine("\n====== Analyzing assembly: " + mAssembly.FileName + " =========\n");
// If processor to id mapping and xml with id information are both available,
// then we ask ScopeAnalysis to analyze only those processors mentioned in the mapping.
ScopeAnalysis analysis = new ScopeAnalysis(host, mAssembly, assemblies.Item2,
processorIdMapping == null || vertexDef == null? null : processorIdMapping.Keys);
analysis.Analyze();
//Update the stats.
UpdateStats(analysis.Results, ref stats, vertexDef, processorIdMapping);
Utils.WriteLine("\n====== Done analyzing the assembly =========\n");
}
catch (ScopeAnalysis.MissingScopeMetadataException e)
{
Utils.WriteLine("ASSEMBLY WARNING: " + e.Message);
}
catch (Exception e)
{
Utils.WriteLine("ASSEMBLY FAILURE: " + e.Message);
}
}
stopWatch.Stop();
var ts = stopWatch.Elapsed;
Utils.WriteLine(String.Format("Total analysis time: {0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10));
return(stats);
}
protected override IEnumerable <ITypeDetails> GetTypes(string assemblyPath)
{
var host = new PeReader.DefaultHost();
var assy = host.LoadUnitFrom(assemblyPath) as IAssembly;
if (assy == null || assy == Dummy.Assembly)
{
throw new InvalidOperationException(string.Format("Failed to load assembly from '{0}'", assemblyPath));
}
return(assy.GetAllTypes().Select(x => new CciTypeDetails(x)));
}
private static bool CreateProcessorIdMapping(string subdir, IEnumerable <string> libs, string outpath)
{
var mainDll = subdir + "\\" + Utils.MAIN_DLL_NAME;
if (!libs.Contains(mainDll))
{
Utils.WriteLine("Did not find main scope dll: " + subdir);
return(false);
}
// delete existing processor id mapping file
var directory = Path.GetDirectoryName(outpath);
if (Directory.Exists(directory))
{
File.Delete(outpath);
}
else
{
Directory.CreateDirectory(directory);
}
Assembly asm;
try
{
var host = new PeReader.DefaultHost();
asm = new Assembly(host);
asm.Load(mainDll);
var mappingAnalyzer = new ProcessorMappingAnalyzer(asm);
mappingAnalyzer.Analyze();
var results = mappingAnalyzer.ProcessorIdMapping;
var summary = String.Empty;
foreach (var k in results.Keys)
{
summary += k + "\t" + results[k] + "\r\n";
}
using (StreamWriter file = new StreamWriter(outpath))
{
file.Write(summary);
}
Utils.WriteLine("Successfully extracted processor to id mapping for the main dll: " + subdir);
}
catch (Exception e)
{
Utils.WriteLine("WARNING: failed to extract processor to id mapping the main dll: " + subdir);
Utils.WriteLine("Exception: " + e.Message);
return(false);
}
return(true);
}
static void Main(string[] args)
{
if (args == null || args.Length == 0)
{
Console.WriteLine("usage: FindThrowArgumentNull [path]fileName.ext");
return;
}
using (var host = new PeReader.DefaultHost()) {
var module = host.LoadUnitFrom(args[0]) as IModule;
if (module == null)
{
Console.WriteLine(args[0] + " is not a PE file containing a CLR module or assembly.");
return;
}
var platformType = new MyPlatformType(host);
INamespaceTypeReference systemArgumentNullException = platformType.SystemArgumentNullException;
IName ctor = host.NameTable.Ctor;
//write out the signature of every method that contains the IL equivalent of "throw new System.ArgumentNullException();"
foreach (var type in module.GetAllTypes())
{
foreach (var methodDefinition in type.Methods)
{
var lastInstructionWasNewObjSystemArgumentNull = false;
foreach (var operation in methodDefinition.Body.Operations)
{
if (operation.OperationCode == OperationCode.Newobj)
{
var consRef = operation.Value as IMethodReference;
if (consRef != null && consRef.Name == ctor &&
TypeHelper.TypesAreEquivalent(consRef.ContainingType, systemArgumentNullException))
{
lastInstructionWasNewObjSystemArgumentNull = true;
}
}
else if (lastInstructionWasNewObjSystemArgumentNull && operation.OperationCode == OperationCode.Throw)
{
Console.WriteLine(MemberHelper.GetMethodSignature(methodDefinition,
NameFormattingOptions.ReturnType | NameFormattingOptions.TypeParameters | NameFormattingOptions.Signature));
break;
}
else
{
lastInstructionWasNewObjSystemArgumentNull = false;
}
}
}
}
}
}
public static void GenerateEDBFacts(string input)
{
using (var host = new PeReader.DefaultHost())
{
Types.Initialize(host);
var visitor = new ClassAndMethodVisitor(host);
IModule rootModule = GetModule(host, input);
IModule stubsModule = GetModule(host, ConfigParams.StubsPath);
DoRTA(host, visitor, rootModule, stubsModule);
GenerateFacts(visitor);
}
}
public CodeGenerator(IModule module, PeReader.DefaultHost host, Log.Log logger, Random prng, MethodCfg methodCfg,
bool debugging = false, CfgManipulator manipulator = null)
{
this.host = host;
this.logger = logger;
this.module = module;
this.prng = prng;
this.methodCfg = methodCfg;
this.debugging = debugging;
this.manipulator = manipulator;
callableMethods = retrieveCallableMethods();
}
public static IEnumerable <Tuple <string, IEnumerable <string> > > GetUsedColumns(string assemblyPath, string libPath)
{
try
{
var host = new PeReader.DefaultHost();
var referenceAssemblies = Utils.CollectAssemblies(libPath);
var assemblies = LoadAssemblies(host, referenceAssemblies, new string[] { assemblyPath, });
var mainAssemblies = assemblies.Item1;
var a = mainAssemblies[0];
var results = AnalyzeAssembly(host, a, null, assemblies.Item2, null);
return(GetUsedColumns(results));
}
catch { return(Enumerable <Tuple <string, IEnumerable <string> > > .Empty); }
}
/// <summary>
/// Not Even Started.
/// </summary>
/// <param name="filename"> </param>
public static void Load(string filename)
{
MetadataReaderHost _host = new PeReader.DefaultHost();
var module = _host.LoadUnitFrom(filename) as IModule;
if (module == null || module is Dummy)
{
throw new ClrPlusException("{0} is not a PE file containing a CLR module or assembly.".format(filename));
}
var ILOnly = module.ILOnly;
Console.WriteLine("module: {0}", module);
}
static void Main(string[] args)
{
if (args == null || args.Length == 0)
{
Console.WriteLine("usage: EdgeProfiler [path]fileName.ext");
return;
}
using (var host = new PeReader.DefaultHost()) {
IModule /*?*/ module = host.LoadUnitFrom(args[0]) as IModule;
if (module == null || module is Dummy)
{
Console.WriteLine(args[0] + " is not a PE file containing a CLR module or assembly.");
return;
}
var coreIdentity = host.CoreAssemblySymbolicIdentity; //force host to let args[0] determine the target platform
var profiler = (IAssembly)host.LoadUnitFrom(typeof(Program).Assembly.Location);
var logger = (INamespaceTypeDefinition)UnitHelper.FindType(host.NameTable, profiler, "Logger");
PdbReader /*?*/ pdbReader = null;
string pdbFile = Path.ChangeExtension(module.Location, "pdb");
if (File.Exists(pdbFile))
{
using (var pdbStream = File.OpenRead(pdbFile)) {
pdbReader = new PdbReader(pdbStream, host);
}
}
using (pdbReader) {
var instrumentedModule = Instrumenter.GetInstrumented(host, module, pdbReader, logger);
var newRoot = Path.GetFileNameWithoutExtension(module.Location) + ".instrumented";
var newName = newRoot + Path.GetExtension(module.Location);
using (var peStream = File.Create(newName)) {
if (pdbReader == null)
{
PeWriter.WritePeToStream(instrumentedModule, host, peStream);
}
else
{
var localScopeProvider = new ILGenerator.LocalScopeProvider(pdbReader);
using (var pdbWriter = new PdbWriter(newRoot + ".pdb", pdbReader)) {
PeWriter.WritePeToStream(instrumentedModule, host, peStream, pdbReader, localScopeProvider, pdbWriter);
}
}
}
}
}
}
private static MetadataReaderHost GetHostFromOptions(ILGarbageCollectorOptions options)
{
MetadataReaderHost host;
switch (options.profile)
{
case TargetProfile.Phone:
host = new PhoneMetadataHost(GetRootAssemblyParentDirectoriesFromOptions(options));
break;
default:
host = new PeReader.DefaultHost();
break;
}
return(host);
}
public Form1()
{
InitializeComponent();
var console = new ConsoleWidget.ConsoleForm();
using (var dialog = new OpenFileDialog())
{
var res = dialog.ShowDialog();
using (var host = new PeReader.DefaultHost())
{
var x = new VVVV.Core.AssemblyNodeDefinitionCollector(host);
foreach (string assemblyName in dialog.FileNames)
{
var assembly = host.LoadUnitFrom(assemblyName) as IAssembly;
if (assembly == null || assembly == Dummy.Assembly)
{
Console.WriteLine("The file '" + assemblyName + "' is not a PE file" +
" containing a CLR assembly, or an error occurred when loading it.");
continue;
}
foreach (var n in x.Collect(assembly))
{
Console.WriteLine(n.Systemname);
if (n is IDataflowNodeDefinition)
{
foreach (var p in (n as IDataflowNodeDefinition).Inputs)
{
Console.WriteLine(" " + TypeHelper.GetTypeName(p.Type, NameFormattingOptions.SmartTypeName) + " " + p.Name +
(p.HasDefaultValue ? " = " + p.DefaultValue.Value.ToString() : ""));
}
foreach (var p in (n as IDataflowNodeDefinition).Outputs)
{
Console.WriteLine(" out " + TypeHelper.GetTypeName(p.Type, NameFormattingOptions.SmartTypeName) + " " + p.Name);
}
}
}
}
}
}
console.Show();
}
public CodeMutator(IModule module, PeReader.DefaultHost host, Log.Log logger, Random prng, MethodCfg methodCfg,
CfgManipulator manipulator, bool debugging = false)
{
this.host = host;
this.logger = logger;
this.module = module;
this.prng = prng;
this.methodCfg = methodCfg;
this.debugging = debugging;
this.manipulator = manipulator;
returnBlock = new BasicBlock();
var exitBranch = new ExitBranchTarget();
returnBlock.exitBranch = exitBranch;
returnBlock.operations.Add(createNewOperation(OperationCode.Ret));
methodCfg.basicBlocks.Add(returnBlock);
}
public TinyBCTHost()
{
host = new PeReader.DefaultHost();
Assembly coreLib = new Assembly(host);
var pathToSelf = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
var assemblyPath = Path.Combine(pathToSelf, "..", "..", "..", "DLLs");
//var assemblyPath = @"C:\Windows\Microsoft.NET\Framework\v4.0.30319";
var systemCoreDll = Path.Combine(assemblyPath, "System.Core.dll");
if (!File.Exists(systemCoreDll))
{
throw new FileNotFoundException("System.Core.dll not found: " + systemCoreDll);
}
coreLib.Load(systemCoreDll);
this.LoadAssembly(coreLib.Module.ContainingAssembly.AssemblyIdentity);
}
public void DoStuff()
{
var host = new PeReader.DefaultHost();
foreach (string file in Directory.GetFiles(Directory.GetCurrentDirectory(), "*.exe"))
{
Console.WriteLine(file);
IAssembly assembly = host.LoadUnitFrom(file) as IAssembly;
if (assembly != null)
{
foreach (INamedTypeDefinition type in assembly.GetAllTypes())
{
foreach (IMethodDefinition method in type.Methods)
{
Console.WriteLine(String.Format("{0}::{1}", type.Name, method.Name));
}
}
}
}
}
