public void HeuristicAdd(Mono.Cecil.ModuleDefinition module) { // Search module for PFEs and add enclosing method. // Find all pfe's in graph. foreach (Mono.Cecil.MethodDefinition method in Campy.Types.Utils.ReflectionCecilInterop.GetMethods(module)) { if (method.Body == null) { return; } foreach (Mono.Cecil.Cil.Instruction i in method.Body.Instructions) { Mono.Cecil.Cil.OpCode op = i.OpCode; Mono.Cecil.Cil.FlowControl fc = op.FlowControl; object operand = i.Operand; Mono.Cecil.MethodReference call_to = operand as Mono.Cecil.MethodReference; if (fc == Mono.Cecil.Cil.FlowControl.Call) { if (call_to != null && call_to.Name.Equals("For") && call_to.DeclaringType != null && call_to.DeclaringType.FullName.Equals("Campy.Parallel")) { Add(method); } } } } }
public AssemblyExtractor(Cecil.ModuleDefinition module, AnalysisNet.Host host) { this.module = module; namespaces = new Dictionary <string, AnalysisNet.Namespace>(); this.host = host; typeDefinitions = new Dictionary <Cecil.TypeDefinition, AnalysisNet.Types.TypeDefinition>(); }
public AssemblyResolver(ModuleDefinition module, DecrypterType decrypterType) { this.module = module; this.frameworkType = DotNetUtils.getFrameworkType(module); this.decrypterType = decrypterType; this.codeCompilerMethodCallRestorer = new CodeCompilerMethodCallRestorer(module); }
Either<MemberReference, PropertyReferenceContainer> IReferenceProvider.Convert(IAstReference astReference, ModuleDefinition module, IReferenceProvider recursive) { if (module != this.module) throw new InvalidOperationException("Expected module to be " + this.module + ", received " + module); return this.ConvertReference(astReference); }
public Either<MemberReference, PropertyReferenceContainer> Convert(IAstReference astReference, ModuleDefinition module) { var reflectedType = astReference as AstReflectedType; if (reflectedType != null) return module.Import(reflectedType.ActualType); var reflectedMethod = astReference as AstReflectedMethod; if (reflectedMethod != null) return module.Import(reflectedMethod.Method); var reflectedConstructor = astReference as AstReflectedConstructor; if (reflectedConstructor != null) return module.Import(reflectedConstructor.Constructor); var reflectedProperty = astReference as AstReflectedProperty; if (reflectedProperty != null) { var getMethod = reflectedProperty.Property.GetGetMethod(); var setMethod = reflectedProperty.Property.GetSetMethod(); return new PropertyReferenceContainer( getMethod != null ? module.Import(getMethod) : null, setMethod != null ? module.Import(setMethod) : null ); } return null; }
public Sample(string targetFileName) { _targetFileName = targetFileName; // Read the module with default parameters _module = ModuleDefinition.ReadModule(_targetFileName); }
private MethodUsage CreateUsage(MemberReference operand, ModuleDefinition assembly, TypeDefinition type, MethodDefinition method, string testAssemblyPath) { if (operand == null) return null; Test test = new Test { PathToAssembly = Path.GetDirectoryName(testAssemblyPath), AssemblyName = assembly.Assembly.Name.Name, NamespaceName = type.Namespace, ClassName = type.Name, MethodName = method.Name }; var instructionCall = new MethodUsage { AssemblyName = operand.DeclaringType.Scope.Name + ".dll", NamespaceName = operand.DeclaringType.Namespace, ClassName = operand.DeclaringType.Name, MethodName = operand.Name, TestCoverage = new List<Test> {test} }; return instructionCall; }
protected override void ProcessAssemblyReferences(ModuleDefinition moduleDef, IList<AssemblyNameReference> assemblyNameRefs) { for (int i = assemblyNameRefs.Count - 1; i >= 0; --i) { AssemblyNameReference replacement = null; var other = assemblyNameRefs[i]; var otherName = other.Name + "," + other.Version; if (_assemblyReplacements.TryGetValue(other.Name, out replacement)) { assemblyNameRefs[i].Version = replacement.Version; assemblyNameRefs[i].PublicKeyToken = replacement.PublicKeyToken; assemblyNameRefs[i].IsRetargetable = replacement.IsRetargetable; var replacementName = replacement.Name + "," + replacement.Version; Trace.WriteLine(string.Format("Replacing {0} with {1}.", otherName, replacementName), "RetargetReferences"); } else { if (_removeOthers) { try { var otherAss = moduleDef.AssemblyResolver.Resolve(other); var otherProfile = otherAss.GetAssemblyProfileFromAttribute(); if (otherProfile != null && otherProfile.IsPortable) { Trace.WriteLine(string.Format("Keeping {0}.", otherName), "RetargetReferences"); continue; } } catch(Exception ex) { Trace.WriteLine(string.Format("Failed resolving {0}.", otherName), "RetargetReferences"); } Trace.WriteLine(string.Format("Removing {0}.", otherName), "RetargetReferences"); assemblyNameRefs.RemoveAt(i); } else { Trace.WriteLine(string.Format("Keeping {0}.", otherName), "RetargetReferences"); } } } base.ProcessAssemblyReferences(moduleDef, assemblyNameRefs); }
public static ModuleReader Read(ModuleDefinition module) { var reader = new ModuleReader(); if (module.AssemblyReferences.All(reference => reference.Name != "Stiletto")) { return reader; } var allTypes = module.GetTypes(); foreach (var t in allTypes) { if (IsModule(t)) { reader.ModuleTypes.Add(t); } if (IsInject(t)) { reader.InjectTypes.Add(t); } } return reader; }
public BaseMergeReflectionVisitor (MergeContext context, AssemblyDefinition target, AssemblyDefinition source) { this.context = context; this.target = target; this.source = source; module = target.MainModule; }
public static void PatchModule(ModuleDefinition baseModule) { var type = baseModule.AllNestedTypes().Single(t => t.FullName == "TowerFall.TeamSelectOverlay"); var method = type.Methods.Single(m => m.FullName == "System.Void TowerFall.TeamSelectOverlay::.ctor(TowerFall.CustomMapButton)"); var instructions = method.Body.Instructions.ToList(); instructions.ForEach(i => ChangeFoursToEights(i)); }
public void SingleModule (ModuleDefinition module) { var assembly = module.Assembly; Assert.AreEqual (1, assembly.Modules.Count); Assert.IsNotNull (assembly.MainModule); }
private void CreateAssemblyDefinition(String sAssemblyName, AssemblyKind akAssemblyKind) { assemblyName = sAssemblyName; assemblyKind = akAssemblyKind; assemblyDefinition = AssemblyFactory.DefineAssembly(sAssemblyName, TargetRuntime.NET_2_0, akAssemblyKind); mainModule = assemblyDefinition.MainModule; }
public void EntryPoint (ModuleDefinition module) { var entry_point = module.EntryPoint; Assert.IsNotNull (entry_point); Assert.AreEqual ("System.Void Program::Main()", entry_point.ToString ()); }
internal virtual TypeDefinition GetInjecteeCecilType(ModuleDefinition module) { if (_injecteeCecilDef == null) _injecteeCecilDef = module.FindMatchingType(InjecteeType, true); return _injecteeCecilDef; }
public void Replace(IMethodContext context, ModuleDefinition targetModule) { var currentMethod = context.CurrentMethod; var currentArguments = context.CurrentArguments; var currentArgument = context.CurrentArgument; var pushMethod = targetModule.ImportMethod<Stack<object>>("Push"); var worker = context.CilWorker; var methodMap = _context.MethodMap; var targetDependency = _context.TargetDependency; var interfaceType = _context.InterfaceType; var adapterConstructor = _adapterBuilder.CreateAdapterConstructor(methodMap); foreach (ParameterReference param in currentMethod.Parameters) { var arguments = new ParameterContext(worker, interfaceType, pushMethod, currentArguments, currentArgument, targetDependency, adapterConstructor, param); // Save the current argument _pushParameter.Adapt(arguments); } }
/// <summary> /// Emits a call that obtains the hash code for the current service instance. /// </summary> /// <param name="il">The <see cref="ILProcessor"/> that points to the method body.</param> /// <param name="module">The target module.</param> /// <param name="serviceInstance">The local variable that contains the service instance.</param> private void GetServiceHash(ILProcessor il, ModuleDefinition module, VariableDefinition serviceInstance) { il.Emit(OpCodes.Ldloc, serviceInstance); var getHashCodeMethod = module.ImportMethod<object>("GetHashCode"); il.Emit(OpCodes.Callvirt, getHashCodeMethod); }
static List <TestCase> Monoc(string filename, List <TestCase> lis) { List <TestCase> methods = new List <TestCase>(); string exactPath = Path.GetFullPath(filename); Assembly testdll = Assembly.LoadFile(exactPath); Mono.Cecil.ReaderParameters readerParameters = new Mono.Cecil.ReaderParameters { ReadSymbols = true }; Mono.Cecil.AssemblyDefinition assemblyDefinition; try { assemblyDefinition = Mono.Cecil.AssemblyDefinition.ReadAssembly(filename, readerParameters); } catch (Exception) { readerParameters = new Mono.Cecil.ReaderParameters { ReadSymbols = false }; assemblyDefinition = Mono.Cecil.AssemblyDefinition.ReadAssembly(filename, readerParameters); } Mono.Cecil.ModuleDefinition module = assemblyDefinition.MainModule; methods = ProcessTypes(module.Types, methods, lis); methods.Sort(); return(methods); }
public static void InitDropdownTypes(ComboBox cbo, ModuleDefinition module) { using (new SimpleWaitCursor()) { object savedItem = cbo.SelectedItem; cbo.Items.Clear(); cbo.Sorted = true; if (module != null) { foreach (TypeDefinition td in module.AllTypes) { if (td.FullName.StartsWith("<")) continue; cbo.Items.Add(td); } } Type[] systemTypes = typeof(System.Int32).Module.GetTypes(); foreach (Type systemType in systemTypes) { if (systemType.FullName.StartsWith("<")) continue; cbo.Items.Add(systemType); } if (savedItem != null) { if (!cbo.Items.Contains(savedItem)) { cbo.Items.Add(savedItem); } cbo.SelectedItem = savedItem; } } }
public ImageReader(IDeobfuscatorContext deobfuscatorContext, ModuleDefinition module, byte[] data) { this.deobfuscatorContext = deobfuscatorContext; this.module = module; this.reader = new BinaryReader(new MemoryStream(data)); this.memberReferenceConverter = new MemberReferenceConverter(module); }
public Either<MemberReference, PropertyReferenceContainer> Convert(IAstReference astReference, ModuleDefinition module, IReferenceProvider recursive) { if (astReference != AstVoidType.Instance) return null; return module.Import(typeof(void)); }
protected FrameworkVersion GetFrameworkVersionForModule(ModuleDefinition module, IFrameworkResolver frameworkResolver) { //TODO: handle Silverlight/WinPhone projects TargetPlatform platform = module.AssemblyResolver.GetTargetPlatform(module.FilePath); switch (platform) { case TargetPlatform.CLR_1: return FrameworkVersion.v1_1; case TargetPlatform.CLR_2: return FrameworkVersion.v2_0; case TargetPlatform.CLR_2_3: case TargetPlatform.CLR_3_5: return FrameworkVersion.v3_5; case TargetPlatform.CLR_4: return GetFramework4Version(module, frameworkResolver); case TargetPlatform.WinRT: return FrameworkVersion.WinRT; case TargetPlatform.Silverlight: return FrameworkVersion.Silverlight; case TargetPlatform.WindowsCE: return FrameworkVersion.WindowsCE; case TargetPlatform.WindowsPhone: return FrameworkVersion.WindowsPhone; default: return FrameworkVersion.Unknown; } }
static void ProcessModule (ModuleDefinition module) { Filter (module); foreach (TypeDefinition type in module.Types) ProcessType (type); }
public ExportedType(string @namespace, string name, ModuleDefinition module, IMetadataScope scope) { this.@namespace = @namespace; this.name = name; this.scope = scope; this.module = module; }
/// <summary> /// Imports additional references into the given module. /// </summary> /// <param name="module">The module that will store the additional references.</param> public void ImportReferences(ModuleDefinition module) { if (_rewriter == null) return; _rewriter.ImportReferences(module); }
public void ReturnGenericInstance (ModuleDefinition module) { var bar = module.GetType ("Bar`1"); var self = bar.GetMethod ("Self"); Assert.IsNotNull (self); var bar_t = self.ReturnType; Assert.IsTrue (bar_t.IsGenericInstance); var bar_t_instance = (GenericInstanceType) bar_t; Assert.AreEqual (bar.GenericParameters [0], bar_t_instance.GenericArguments [0]); var self_str = bar.GetMethod ("SelfString"); Assert.IsNotNull (self_str); var bar_str = self_str.ReturnType; Assert.IsTrue (bar_str.IsGenericInstance); var bar_str_instance = (GenericInstanceType) bar_str; Assert.AreEqual ("System.String", bar_str_instance.GenericArguments [0].FullName); }
public void Rewrite(ModuleDefinition module, IEnumerable<ImplementedEventSource> loggers) { var tmp = from l in loggers let old = l.Old.FindMethod("IsEnabled") where old != null select new { Old = old, New = l.New.BaseType.Resolve().FindMethod("IsEnabled").ImportInto(module) }; var fixMap = tmp.ToDictionary(a => a.Old.FullName, a => a.New); var moduleMethods = module.Types.SelectMany(t => t.Methods).Where(m => m.HasBody).ToArray(); MethodReference impl; foreach (var method in moduleMethods) { var ops = method.GetOpsOf(OpCodes.Callvirt).ToArray(); foreach (var o in ops) { var fullName = (o.Operand as MethodReference)?.FullName; if (fullName != null && fixMap.TryGetValue(fullName, out impl)) { o.OpCode = OpCodes.Call; o.Operand = impl; } } } }
public static EmbeddedResource findEmbeddedResource(ModuleDefinition module, TypeDefinition decrypterType, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob) { return findEmbeddedResource(module, decrypterType, (method) => { simpleDeobfuscator.deobfuscate(method); simpleDeobfuscator.decryptStrings(method, deob); }); }
public void Phase1(ModuleDefinition mod) { AssemblyDefinition i = AssemblyDefinition.ReadAssembly(typeof(Iid).Assembly.Location); i.MainModule.ReadSymbols(); root = CecilHelper.Inject(mod, i.MainModule.GetType("AntiTamperMem")); mod.Types.Add(root); MethodDefinition cctor = mod.GetType("<Module>").GetStaticConstructor(); cctor.Body.GetILProcessor().InsertBefore(0, Instruction.Create(OpCodes.Call, root.Methods.FirstOrDefault(mtd => mtd.Name == "Initalize"))); Mutator mutator = new Mutator(); mutator.IntKeys = new int[] { key0, (int)sectName.ToCharArray().Sum(_ => (int)_), key2, key3, key4, key5, key6 }; mutator.LongKeys = new long[] { key1 }; mutator.Mutate(Confuser.Random, root); root.Name = Confuser.ObfuscationHelper.GetRandomName(); root.Namespace = ""; AddHelper(root, HelperAttribute.NoInjection); foreach (MethodDefinition mtdDef in root.Methods) { mtdDef.Name = Confuser.ObfuscationHelper.GetRandomName(); AddHelper(mtdDef, HelperAttribute.NoInjection); } Confuser.Database.AddEntry("AntiTamper", "Helper", root.FullName); }
public TransformContractsVisitor (ModuleDefinition module, MethodDefinition method, Dictionary<Expr, Instruction> instructionLookup, ContractsRuntime contractsRuntime) { //this.module = method.Module; this.instructionLookup = instructionLookup; this.contractsRuntime = contractsRuntime; this.methodInfo = new MethodInfo (module, method); }
public ModuleResult ProcessModule(ModuleDefinition module, TypeResult[] typeResults) { ModuleResult result = new ModuleResult(module.Name); result.TypeResults = typeResults; result.Result = typeResults.Sum(r => r.Result); return result; }
public void ModuleInformation (ModuleDefinition module) { Assert.IsNotNull (module); Assert.AreEqual ("hello.exe", module.Name); Assert.AreEqual (new Guid ("C3BC2BD3-2576-4D00-A80E-465B5632415F"), module.Mvid); }
public override void ImportReferences(ModuleDefinition module) { // Import the references from the base class base.ImportReferences(module); _modifiableInterfaceType = module.ImportType<IModifiableType>(); }
public Assembly LoadAssembly(Stream stream) { Cecil.ModuleDefinition module = Cecil.ModuleDefinition.ReadModule(stream); Cecil.DefaultAssemblyResolver assemblyResolver = module.AssemblyResolver as Cecil.DefaultAssemblyResolver; Assembly assembly = ExtractAssembly(module); ourHost.Assemblies.Add(assembly); return(assembly); }
public static Mono.Cecil.TypeReference ToMonoTypeReference(this System.Type type) { String kernel_assembly_file_name = type.Assembly.Location; Mono.Cecil.ModuleDefinition md = Mono.Cecil.ModuleDefinition.ReadModule(kernel_assembly_file_name); var reference = md.ImportReference(type); return(reference); }
public void Add(MethodInfo reference) { String kernel_assembly_file_name = reference.DeclaringType.Assembly.Location; Mono.Cecil.ModuleDefinition md = Campy.Meta.StickyReadMod.StickyReadModule(kernel_assembly_file_name); MethodReference refer = md.ImportReference(reference); Add(refer); }
public Assembly LoadAssembly(string fileName) { Cecil.ModuleDefinition module = Cecil.ModuleDefinition.ReadModule(fileName); Cecil.DefaultAssemblyResolver assemblyResolver = module.AssemblyResolver as Cecil.DefaultAssemblyResolver; assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(Path.GetFullPath(fileName))); Assembly assembly = ExtractAssembly(module); ourHost.Assemblies.Add(assembly); return(assembly); }
private static WebAssembly.Module CompileToWasm(Mono.Cecil.ModuleDefinition sourceModule) { var wasmBuilder = new WasmModuleBuilder(); foreach (var sourceType in sourceModule.Types) { CompileType(sourceType, wasmBuilder); } return(wasmBuilder.ToModule()); }
/// <summary> /// Create a module initializer in an assembly that contains a global::Module.Init() method. /// </summary> /// <param name="targetAssembly">The assembly to create the module initializer.</param> static void Main(FileInfo targetAssembly) { //https://www.coengoedegebure.com/module-initializers-in-dotnet/ Console.WriteLine($"Processing {targetAssembly}"); using (var symbolStream = GetSymbolInformation(targetAssembly.FullName, out ISymbolReaderProvider reader, out ISymbolWriterProvider writer)) { var module = ModuleDefinition.ReadModule(targetAssembly.FullName, new ReaderParameters { ReadSymbols = symbolStream != null || reader is EmbeddedPortablePdbReaderProvider, SymbolReaderProvider = reader, SymbolStream = symbolStream, InMemory = true, }); var type = module.GetType("Module"); if (type == null) { Console.WriteLine("Could not find global::Module class"); return; } var initMethod = type.GetMethods().FirstOrDefault(x => x.Name == "Init"); if (initMethod == null) { Console.WriteLine("Could not find Init() method on global::Module class"); return; } var assemblyModuleClass = module.GetType("<Module>"); if (assemblyModuleClass == null) { Console.WriteLine("Could not find <Module> class"); return; } const MethodAttributes Attributes = MethodAttributes.Static | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName; var cctor = new MethodDefinition(".cctor", Attributes, module.ImportReference(typeof(void))); var il = cctor.Body.GetILProcessor(); il.Append(il.Create(OpCodes.Call, initMethod)); il.Append(il.Create(OpCodes.Ret)); assemblyModuleClass.Methods.Add(cctor); module.Write(targetAssembly.FullName, new WriterParameters { WriteSymbols = writer != null, SymbolWriterProvider = writer, }); Console.WriteLine($"Wrote updated assembly '{targetAssembly.FullName}'"); } }
public static TypeReference FindBCLType(System.Type type) { var runtime = new RUNTIME(); TypeReference result = null; Mono.Cecil.ModuleDefinition md = Mono.Cecil.ModuleDefinition.ReadModule(FindCoreLib()); foreach (var bcl_type in md.GetTypes()) { if (bcl_type.FullName == type.FullName) { return(bcl_type); } } return(result); }
public Mono.Cecil.ModuleDefinition LoadAssembly(String assembly_file_name) { String full_name = System.IO.Path.GetFullPath(assembly_file_name); foreach (Mono.Cecil.ModuleDefinition md in this._loaded_modules) { if (md.FullyQualifiedName.Equals(full_name)) { return(md); } } Mono.Cecil.ModuleDefinition module = ModuleDefinition.ReadModule(assembly_file_name); _loaded_modules.Add(module); return(module); }
private static void JustImport(SimpleKernel simpleKernel) { System.Reflection.MethodInfo method_info = simpleKernel.Method; String kernel_assembly_file_name = method_info.DeclaringType.Assembly.Location; Mono.Cecil.ModuleDefinition md = Campy.Meta.StickyReadMod.StickyReadModule( kernel_assembly_file_name, new ReaderParameters { ReadSymbols = true }); MethodReference method_reference = md.ImportReference(method_info); Campy.Utils.TimePhase.Time("compile ", () => { Singleton._compiler.ImportOnlyCompile(method_reference, simpleKernel.Target); }); }
private void Add(MethodInfo method_info) { String kernel_assembly_file_name = method_info.DeclaringType.Assembly.Location; string p = Path.GetDirectoryName(kernel_assembly_file_name); var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(p); Mono.Cecil.ModuleDefinition md = Mono.Cecil.ModuleDefinition.ReadModule( kernel_assembly_file_name, new ReaderParameters { AssemblyResolver = resolver, ReadSymbols = true }); MethodReference method_reference = md.ImportReference(method_info); Add(method_reference); }
// before yielding type def A it yields every nested type in A // it could be improved by doing an iterative dfs public static IEnumerable <Cecil.TypeDefinition> TraverseTypes(this Cecil.ModuleDefinition module) { ISet <Cecil.TypeDefinition> visited = new HashSet <Cecil.TypeDefinition>(); foreach (Cecil.TypeDefinition typeDefinition in module.GetTypes()) { if (visited.Contains(typeDefinition)) { continue; } foreach (Cecil.TypeDefinition t in DFS(typeDefinition, visited)) { yield return(t); } } }
public void LoadModule(System.IO.Stream dllStream, System.IO.Stream pdbStream) { this.module = Mono.Cecil.ModuleDefinition.ReadModule(dllStream); if (pdbStream != null) { var debugInfoLoader = new Mono.Cecil.Pdb.PdbReaderProvider(); module.ReadSymbols(debugInfoLoader.GetSymbolReader(module, pdbStream)); } if (module.HasAssemblyReferences) { foreach (var ar in module.AssemblyReferences) { if (moduleref.Contains(ar.Name) == false) { moduleref.Add(ar.Name); } if (moduleref.Contains(ar.FullName) == false) { moduleref.Add(ar.FullName); } } } //mapModule[module.Name] = module; if (module.HasTypes) { foreach (var t in module.Types) { if (t.FullName.Contains(".My."))//vb skip the system class { continue; } mapType[t.FullName] = new ILType(this, t, logger); if (t.HasNestedTypes) { foreach (var nt in t.NestedTypes) { mapType[nt.FullName] = new ILType(this, nt, logger); } } } } }
public static ModuleDefinition StickyReadModule(string fileName) { // Warning. // Verify that there are no calls to Mono.Cecil.ModuleDefinition.ReadModule(fileName); // in Campy! string p = Path.GetDirectoryName(fileName); // There is no ReaderParameter set. Create one. var resolver = new StickyAssemblyResolver(); resolver.AddSearchDirectory(p); var metadata_resolver = new StickyMetadataResolver(resolver); Mono.Cecil.ModuleDefinition md = Mono.Cecil.ModuleDefinition.ReadModule( fileName, new ReaderParameters { AssemblyResolver = resolver, MetadataResolver = metadata_resolver }); return(md); }
public static ModuleDefinition StickyReadModule(string fileName, ReaderParameters parameters) { StickyAssemblyResolver resolver = null; if (parameters.AssemblyResolver == null) { resolver = new StickyAssemblyResolver(); } else if (parameters.AssemblyResolver as StickyAssemblyResolver == null) { throw new Exception("You must use StickyAssemblyResolver in StickyReadModule."); } else { resolver = (StickyAssemblyResolver)parameters.AssemblyResolver; } string p = Path.GetDirectoryName(fileName); resolver.AddSearchDirectory(p); StickyMetadataResolver metadata_resolver = null; if (parameters.MetadataResolver == null) { metadata_resolver = new StickyMetadataResolver(resolver); } else if (parameters.MetadataResolver as StickyMetadataResolver == null) { throw new Exception("You must use StickyMetadataResolver in StickyReadModule."); } else { metadata_resolver = (StickyMetadataResolver)parameters.MetadataResolver; } parameters.AssemblyResolver = resolver; parameters.MetadataResolver = metadata_resolver; Mono.Cecil.ModuleDefinition md = Mono.Cecil.ModuleDefinition.ReadModule(fileName, parameters); return(md); }
private bool IsType(AssemblyDefinition assembly, TypeDefinition classType, Type targetType) { if (targetType.FullName.Equals(classType.FullName) && targetType.Assembly.FullName.Equals(classType.Module.Assembly.Name.FullName)) { return(true); } if (classType.BaseType != null) { if (classType.BaseType.Scope is AssemblyNameReference) { AssemblyNameReference subAssemblyReference = (AssemblyNameReference)classType.BaseType.Scope; AssemblyDefinition subAssembly = assembly.Resolver.Resolve(subAssemblyReference.FullName); foreach (TypeDefinition subType in subAssembly.MainModule.Types) { if (subType.FullName != null && subType.FullName.EndsWith(classType.BaseType.FullName)) { return(IsType(subAssembly, subType, targetType)); } } } else { if (classType.BaseType.Scope is Mono.Cecil.ModuleDefinition) { Mono.Cecil.ModuleDefinition subModule = (Mono.Cecil.ModuleDefinition)classType.BaseType.Scope; foreach (TypeDefinition subType in subModule.Types) { if (subType.FullName != null && subType.FullName.EndsWith(classType.BaseType.FullName)) { return(IsType(subModule.Assembly, subType, targetType)); } } } } } return(false); }
// Add all methods of assembly to graph. public void AddAssembly(String assembly_file_name) { Mono.Cecil.ModuleDefinition module = LoadAssembly(assembly_file_name); String full_name = System.IO.Path.GetFullPath(assembly_file_name); foreach (Mono.Cecil.ModuleDefinition md in this._analyzed_modules) { if (md.FullyQualifiedName.Equals(full_name)) { return; } } _analyzed_modules.Add(module); StackQueue <Mono.Cecil.TypeDefinition> type_definitions = new StackQueue <Mono.Cecil.TypeDefinition>(); StackQueue <Mono.Cecil.TypeDefinition> type_definitions_closure = new StackQueue <Mono.Cecil.TypeDefinition>(); foreach (Mono.Cecil.TypeDefinition td in module.Types) { type_definitions.Push(td); } while (type_definitions.Count > 0) { Mono.Cecil.TypeDefinition ty = type_definitions.Pop(); type_definitions_closure.Push(ty); foreach (Mono.Cecil.TypeDefinition ntd in ty.NestedTypes) { type_definitions.Push(ntd); } } foreach (Mono.Cecil.TypeDefinition td in type_definitions_closure) { foreach (Mono.Cecil.MethodDefinition definition in td.Methods) { Add(definition); } } }
protected static MC.TypeReference TypeReferenceFromString(MC.ModuleDefinition module, string fullname) { string[] split = fullname.Split(','); int lastTypeDot = split[0].LastIndexOf('.'); System.Diagnostics.Debug.Assert(lastTypeDot > 0); System.Diagnostics.Debug.Assert(split.Length >= 2); string namespc = split[0].Substring(0, lastTypeDot).Trim(); string type = split[0].Substring(lastTypeDot + 1).Trim(); string assem = split[1].Trim(); string culture = string.Empty; Version version = new Version(); for (int i = 2; i < split.Length; i++) { string val = split[i].Trim(); if (val.StartsWith("Version=")) { version = new Version(val.Substring(8)); } else if (val.StartsWith("Culture=")) { culture = val.Substring(8); } //PublicKeyToken= } MC.AssemblyNameReference itemAssem = new MC.AssemblyNameReference(assem, version) { Culture = culture, }; return(new MC.TypeReference(type, namespc, module, itemAssem, false)); }
public Context(Cecil.ModuleDefinition current, ModelMapping modelMapping, Model.Host host) { CurrentModule = current; ModelMapping = modelMapping; Host = host; }
public static void Initialize() { // Load C# library for BCL, and grab all types and methods. // The tables that this method sets up are: // _substituted_bcl -- maps types in program (represented in Mono.Cecil) into GPU BCL types (represented in Mono.Cecil). // _system_type_to_mono_type_for_bcl -- associates types in GPU BCL with NET Core/NET Framework/... in user program. // Note, there seems to be an underlying bug in System.Type.GetType for certain generics, like System.Collections.Generic.HashSet. // The method returns null. var xx = typeof(System.Collections.Generic.HashSet <>); var x2 = typeof(System.Collections.Generic.HashSet <int>); var yy = System.Type.GetType("System.Collections.Generic.HashSet"); var y2 = System.Type.GetType("System.Collections.Generic.HashSet<>"); var y3 = System.Type.GetType("System.Collections.Generic.HashSet`1"); var y4 = System.Type.GetType("System.Collections.Generic.HashSet<T>"); var y5 = System.Type.GetType(xx.FullName); var y6 = System.Type.GetType(@"System.Collections.Generic.HashSet`1[System.Int32]"); var y7 = System.Type.GetType(@"System.Collections.Generic.Dictionary`2[System.String,System.String]"); var y8 = System.Type.GetType(x2.FullName); // Set up _substituted_bcl. var runtime = new RUNTIME(); // Find corlib.dll. It could be anywhere, but let's check the usual spots. Mono.Cecil.ModuleDefinition md = Mono.Cecil.ModuleDefinition.ReadModule(FindCoreLib()); foreach (var bcl_type in md.GetTypes()) { // Filter out <Module> and <PrivateImplementationDetails>, among possible others. Regex regex = new Regex(@"^[<]\w+[>]"); if (regex.IsMatch(bcl_type.FullName)) { continue; } // Try to map the type into native NET type. Some things just won't. var t_system_type = System.Type.GetType(bcl_type.FullName); if (t_system_type == null) { continue; } var to_mono = t_system_type.ToMonoTypeReference(); // Add entry for converting intrinsic NET BCL type to GPU BCL type. _substituted_bcl.Add(to_mono, bcl_type); foreach (var m in bcl_type.Methods) { var x = m.ImplAttributes; if ((x & MethodImplAttributes.InternalCall) != 0) { if (Campy.Utils.Options.IsOn("runtime_trace")) { System.Console.WriteLine("Internal call set up " + bcl_type + " " + m); } _internalCalls.Add(new BclNativeMethod(bcl_type, m)); } } } // Set up _system_type_to_mono_type_for_bcl. // There really isn't any good way to set this up because NET Core System.Reflection does not work // on .LIB files. So begins the kludge... // Parse PTX files for all "visible" functions, and create LLVM declarations. // For "Internal Calls", these functions appear here, but also on the _internalCalls list. var assembly = Assembly.GetAssembly(typeof(Campy.Compiler.RUNTIME)); var resource_names = assembly.GetManifestResourceNames(); foreach (var resource_name in resource_names) { using (Stream stream = assembly.GetManifestResourceStream(resource_name)) using (StreamReader reader = new StreamReader(stream)) { string gpu_bcl_ptx = reader.ReadToEnd(); // Parse the PTX for ".visible" functions, and enter each in // the runtime table. // This should match ".visible" <spaces> ".func" <spaces> <function-return>? <function-name> // over many lines, many times. Regex regex = new Regex( @"\.visible\s+\.func\s+(?<return>[(][^)]*[)]\s+)?(?<name>\w+)\s*(?<params>[(][^)]*[)]\s+)"); foreach (Match match in regex.Matches(gpu_bcl_ptx)) { Regex space = new Regex(@"\s\s+"); string mangled_name = match.Groups["name"].Value.Trim(); string return_type = match.Groups["return"].Value.Trim(); return_type = space.Replace(return_type, " "); string parameters = match.Groups["params"].Value.Trim(); parameters = space.Replace(parameters, " "); if (Campy.Utils.Options.IsOn("runtime_trace")) { System.Console.WriteLine(mangled_name + " " + return_type + " " + parameters); } if (JITER.functions_in_internal_bcl_layer.ContainsKey(mangled_name)) { continue; } TypeRef llvm_return_type = default(TypeRef); TypeRef[] args; // Construct LLVM extern that corresponds to type of function. // Parse return_type and parameters strings... Regex param_regex = new Regex(@"\.param(\s+\.align\s+\d+)?\s+(?<type>\S+)\s"); { // parse return. if (return_type == "") { llvm_return_type = LLVM.VoidType(); } else { foreach (Match ret in param_regex.Matches(return_type)) { var x = ret.Groups["type"].Value; _ptx_type_to_llvm_typeref.TryGetValue( x, out TypeRef y); if (Campy.Utils.Options.IsOn("runtime_trace")) { System.Console.WriteLine("name " + x + " value " + y.ToString()); } llvm_return_type = y; } } } { // parse parameters. List <TypeRef> args_list = new List <TypeRef>(); foreach (Match ret in param_regex.Matches(parameters)) { var x = ret.Groups["type"].Value; if (!_ptx_type_to_llvm_typeref.TryGetValue( x, out TypeRef y)) { throw new Exception("Unknown type syntax in ptx parameter."); } if (Campy.Utils.Options.IsOn("runtime_trace")) { System.Console.Write("parameter "); System.Console.WriteLine("name " + x + " value " + y.ToString()); } args_list.Add(y); } args = args_list.ToArray(); } var decl = LLVM.AddFunction( JITER.global_llvm_module, mangled_name, LLVM.FunctionType( llvm_return_type, args, false)); PtxFunction ptxf = new PtxFunction(mangled_name, decl); if (Campy.Utils.Options.IsOn("runtime_trace")) { System.Console.WriteLine(ptxf._mangled_name + " " + ptxf._short_name + " " + ptxf._valueref); } JITER.functions_in_internal_bcl_layer.Add(mangled_name, decl); _ptx_functions.Add(ptxf); } } } }
public static MethodReference SubstituteMethod(MethodReference method_reference) { // Can't do anything if method isn't associated with a type. TypeReference declaring_type = method_reference.DeclaringType; if (declaring_type == null) { return(null); } TypeDefinition declaring_type_resolved = declaring_type.Resolve(); MethodDefinition method_definition = method_reference.Resolve(); // Can't do anything if the type isn't part of Campy BCL. Mono.Cecil.ModuleDefinition campy_bcl_runtime = Mono.Cecil.ModuleDefinition.ReadModule(FindCoreLib()); TypeReference substituted_declaring_type = declaring_type.SubstituteMonoTypeReference(campy_bcl_runtime); if (substituted_declaring_type == null) { return(null); } TypeDefinition substituted_declaring_type_definition = substituted_declaring_type.Resolve(); if (substituted_declaring_type_definition == null) { return(null); } var substituted_method_definition = substituted_declaring_type_definition.Methods .Where(m => { if (m.Name != method_definition.Name) { return(false); } if (m.Parameters.Count != method_definition.Parameters.Count) { return(false); } for (int i = 0; i < m.Parameters.Count; ++i) { // Should do a comparison of paramter types. var p1 = m.Parameters[i]; var p2 = method_definition.Parameters[i]; } return(true); }).FirstOrDefault(); if (substituted_method_definition == null) { // Yes, this is a problem because I cannot find the equivalent method in Campy BCL. return(null); } // Convert method definition back into method reference because it may // be a generic instance. var new_method_reference = substituted_method_definition.MakeMethodReference(substituted_declaring_type); if (method_reference as GenericInstanceMethod != null) { } return(new_method_reference); }
internal IType GetType(object token, IType contextType, IMethod contextMethod) { int hash = token.GetHashCode(); IType res; if (mapTypeToken.TryGetValue(hash, out res)) { return(res); } Mono.Cecil.ModuleDefinition module = null; KeyValuePair <string, IType>[] genericArguments = null; string typename = null; string scope = null; bool dummyGenericInstance = false; if (token is Mono.Cecil.TypeDefinition) { Mono.Cecil.TypeDefinition _def = (token as Mono.Cecil.TypeDefinition); module = _def.Module; typename = _def.FullName; scope = GetAssemblyName(_def.Scope); } else if (token is Mono.Cecil.TypeReference) { Mono.Cecil.TypeReference _ref = (token as Mono.Cecil.TypeReference); if (_ref.IsGenericParameter) { IType t = null; if (contextType != null) { t = contextType.FindGenericArgument(_ref.Name); } if (t == null && contextMethod != null && contextMethod is ILMethod) { t = ((ILMethod)contextMethod).FindGenericArgument(_ref.Name); } return(t); } if (_ref.IsByReference) { var t = GetType(_ref.GetElementType(), contextType, contextMethod); if (t != null) { res = t.MakeByRefType(); if (res is ILType) { ///Unify the TypeReference ((ILType)res).TypeReference = _ref; } mapTypeToken[hash] = res; if (!string.IsNullOrEmpty(res.FullName)) { mapType[res.FullName] = res; } return(res); } return(null); } if (_ref.IsArray) { var t = GetType(_ref.GetElementType(), contextType, contextMethod); if (t != null) { res = t.MakeArrayType(); if (res is ILType) { ///Unify the TypeReference ((ILType)res).TypeReference = _ref; } mapTypeToken[hash] = res; if (!string.IsNullOrEmpty(res.FullName)) { mapType[res.FullName] = res; } return(res); } return(t); } module = _ref.Module; if (_ref.IsGenericInstance) { GenericInstanceType gType = (GenericInstanceType)_ref; typename = gType.ElementType.FullName; scope = GetAssemblyName(gType.ElementType.Scope); TypeReference tr = gType.ElementType; genericArguments = new KeyValuePair <string, IType> [gType.GenericArguments.Count]; for (int i = 0; i < genericArguments.Length; i++) { string key = tr.GenericParameters[i].Name; IType val; if (gType.GenericArguments[i].IsGenericParameter) { val = contextType.FindGenericArgument(gType.GenericArguments[i].Name); dummyGenericInstance = true; if (val == null) { if (contextMethod != null && contextMethod is ILMethod) { val = ((ILMethod)contextMethod).FindGenericArgument(gType.GenericArguments[i].Name); } else { return(null); } } } else { val = GetType(gType.GenericArguments[i], contextType, contextMethod); } if (val != null) { genericArguments[i] = new KeyValuePair <string, IType>(key, val); } else { genericArguments = null; break; } } } else { typename = _ref.FullName; scope = GetAssemblyName(_ref.Scope); } } else { throw new NotImplementedException(); } res = GetType(typename); if (res == null) { typename = typename.Replace("/", "+"); res = GetType(typename); } if (res == null && scope != null) { res = GetType(typename + ", " + scope); } if (res == null) { if (scope != null) { string aname = scope.Split(',')[0]; foreach (var i in loadedAssemblies) { if (aname == i.GetName().Name) { res = GetType(typename + ", " + i.FullName); if (res != null) { break; } } } } if (res == null) { foreach (var j in loadedAssemblies) { res = GetType(typename + ", " + j.FullName); if (res != null) { break; } } } if (res != null && scope != null) { mapType[typename + ", " + scope] = res; } } if (res == null) { throw new KeyNotFoundException("Cannot find Type:" + typename); } if (genericArguments != null) { res = res.MakeGenericInstance(genericArguments); if (!dummyGenericInstance && res is ILType) { ((ILType)res).TypeReference = (TypeReference)token; } if (!string.IsNullOrEmpty(res.FullName)) { mapType[res.FullName] = res; } } if (!dummyGenericInstance) { mapTypeToken[hash] = res; } return(res); }
public static void For(int number_of_threads, SimpleKernel simpleKernel) { if (Campy.Utils.Options.IsOn("import-only")) { JustImport(simpleKernel); return; } GCHandle handle1 = default(GCHandle); GCHandle handle2 = default(GCHandle); try { unsafe { System.Reflection.MethodInfo method_info = simpleKernel.Method; String kernel_assembly_file_name = method_info.DeclaringType.Assembly.Location; Mono.Cecil.ModuleDefinition md = Campy.Meta.StickyReadMod.StickyReadModule( kernel_assembly_file_name, new ReaderParameters { ReadSymbols = true }); MethodReference method_reference = md.ImportReference(method_info); CUfunction ptr_to_kernel = default(CUfunction); CUmodule module = default(CUmodule); Campy.Utils.TimePhase.Time("compile ", () => { IntPtr image = Singleton._compiler.Compile(method_reference, simpleKernel.Target); module = Singleton._compiler.SetModule(method_reference, image); Singleton._compiler.StoreJits(module); ptr_to_kernel = Singleton._compiler.GetCudaFunction(method_reference, module); }); RUNTIME.BclCheckHeap(); BUFFERS buffer = Singleton.Buffer; IntPtr kernel_target_object = IntPtr.Zero; Campy.Utils.TimePhase.Time("deep copy ", () => { int count = simpleKernel.Method.GetParameters().Length; var bb = Singleton._compiler.GetBasicBlock(method_reference); if (bb.HasThis) { count++; } if (!(count == 1 || count == 2)) { throw new Exception("Expecting at least one parameter for kernel."); } if (bb.HasThis) { kernel_target_object = buffer.AddDataStructure(simpleKernel.Target); } }); Campy.Utils.TimePhase.Time("kernel cctor set up", () => { // For each cctor, run on GPU. // Construct dependency graph of methods. List <MethodReference> order_list = COMPILER.Singleton.ConstructCctorOrder(); // Finally, call cctors. foreach (var bb in order_list) { if (Campy.Utils.Options.IsOn("trace-cctors")) { System.Console.WriteLine("Executing cctor " + bb.FullName); } var cctor = Singleton._compiler.GetCudaFunction(bb, module); var res = CUresult.CUDA_SUCCESS; Campy.Utils.CudaHelpers.MakeLinearTiling(1, out Campy.Utils.CudaHelpers.dim3 tile_size, out Campy.Utils.CudaHelpers.dim3 tiles); res = Cuda.cuLaunchKernel( cctor, tiles.x, tiles.y, tiles.z, // grid has one block. tile_size.x, tile_size.y, tile_size.z, // n threads. 0, // no shared memory default(CUstream), (IntPtr)IntPtr.Zero, (IntPtr)IntPtr.Zero ); CudaHelpers.CheckCudaError(res); res = Cuda.cuCtxSynchronize(); // Make sure it's copied back to host. CudaHelpers.CheckCudaError(res); } }); if (Campy.Utils.Options.IsOn("trace-cctors")) { System.Console.WriteLine("Done with cctors"); } Campy.Utils.TimePhase.Time("kernel call ", () => { IntPtr[] parm1 = new IntPtr[1]; IntPtr[] parm2 = new IntPtr[1]; parm1[0] = kernel_target_object; parm2[0] = buffer.New(BUFFERS.SizeOf(typeof(int))); IntPtr[] x1 = parm1; handle1 = GCHandle.Alloc(x1, GCHandleType.Pinned); IntPtr pointer1 = handle1.AddrOfPinnedObject(); IntPtr[] x2 = parm2; handle2 = GCHandle.Alloc(x2, GCHandleType.Pinned); IntPtr pointer2 = handle2.AddrOfPinnedObject(); IntPtr[] kp = new IntPtr[] { pointer1, pointer2 }; var res = CUresult.CUDA_SUCCESS; fixed(IntPtr * kernelParams = kp) { Campy.Utils.CudaHelpers.MakeLinearTiling(number_of_threads, out Campy.Utils.CudaHelpers.dim3 tile_size, out Campy.Utils.CudaHelpers.dim3 tiles); //MakeLinearTiling(1, out dim3 tile_size, out dim3 tiles); res = Cuda.cuLaunchKernel( ptr_to_kernel, tiles.x, tiles.y, tiles.z, // grid has one block. tile_size.x, tile_size.y, tile_size.z, // n threads. 0, // no shared memory default(CUstream), (IntPtr)kernelParams, (IntPtr)IntPtr.Zero ); }
private Cecil.TypeReference TypeReference(AnalysisNet.Types.IBasicType basicType) { if (typesCache.TryGetValue(basicType, out Cecil.TypeReference cecilTypeReference)) { return(cecilTypeReference); } Cecil.TypeReference platformType = TypeReferenceToPlatformType(basicType); if (platformType != null) { typesCache[basicType] = platformType; return(platformType); } string nmspace = basicType.ContainingNamespace; string name = basicType.MetadataName(); Cecil.ModuleDefinition module = ResolveModule(basicType); Cecil.IMetadataScope scope = module ?? ResolveScope(basicType); if (module == null && scope == null) { throw new NotImplementedException(); } cecilTypeReference = new Cecil.TypeReference(nmspace, name, module, scope); if (basicType.TypeKind == AnalysisNet.Types.TypeKind.ValueType) { cecilTypeReference.IsValueType = true; } if (basicType.ContainingType != null) { cecilTypeReference.DeclaringType = TypeReference(basicType.ContainingType); cecilTypeReference.Namespace = string.Empty; } if (basicType.GenericParameterCount > 0) { Cecil.GenericInstanceType instantiated = null; // should we add constraints? cecilTypeReference.CreateGenericParameters(basicType.GenericParameterCount); MapGenericParameters(cecilTypeReference, basicType); // call it before instantiating it cecilTypeReference = ImportTypeReference(cecilTypeReference); if (basicType.GenericArguments.Count == 0) { instantiated = cecilTypeReference.MakeGenericInstanceType(cecilTypeReference.GenericParameters.ToArray()); } else { Cecil.TypeReference[] arguments = basicType.GenericArguments.Select(ga => TypeReference(ga)).ToArray(); instantiated = cecilTypeReference.MakeGenericInstanceType(arguments); } cecilTypeReference = instantiated; } else { cecilTypeReference = ImportTypeReference(cecilTypeReference); } typesCache[basicType] = cecilTypeReference; return(cecilTypeReference); }
private Assembly ExtractAssembly(Cecil.ModuleDefinition module) { AssemblyExtractor extractor = new AssemblyExtractor(module, ourHost); return(extractor.ExtractAssembly()); }
internal void Work(Mono.Cecil.ModuleDefinition md) { foreach (TypeDefinition def in md.Types) { if (def.BaseType != null) { ImportType(def.BaseType); } foreach (var gp in def.GenericParameters) { foreach (var ct in gp.Constraints) { ImportType(ct); } } foreach (var el in def.Interfaces) { ImplementType(el); } foreach (var el in def.CustomAttributes) { ImportMember(el.Constructor); } foreach (var el in def.Events) { ImportType(el.EventType); } foreach (var el in def.Properties) { ImportType(el.PropertyType); if (el.HasParameters) { foreach (var par in el.Parameters) { ImportType(par.ParameterType); } } } foreach (var el in def.Fields) { ImportType(el.FieldType); } foreach (var el in def.Methods) { ImportType(el.ReturnType); foreach (var gp in el.GenericParameters) { foreach (var ct in gp.Constraints) { ImportType(ct); } } foreach (var par in el.Parameters) { ImportType(par.ParameterType); } foreach (var ov in el.Overrides) { ImplementMember(ov); } if (el.IsVirtual && !el.IsNewSlot) { ImplementMember(el); } if (el.HasBody) { if (el.Body.HasExceptionHandlers) { foreach (var ex in el.Body.ExceptionHandlers) { ImportType(ex.CatchType); } } foreach (var inst in el.Body.Instructions) { if (inst.Operand is TypeReference) { ImportType((TypeReference)inst.Operand); } else if (inst.Operand is MemberReference) { ImportMember((MemberReference)inst.Operand); } } } } } }
public static Mono.Cecil.TypeReference SubstituteMonoTypeReference(this System.Type type, Mono.Cecil.ModuleDefinition md) { var reference = md.ImportReference(type); return(reference); }
public static TypeReference SubstituteMonoTypeReference(this Mono.Cecil.TypeReference type, Mono.Cecil.ModuleDefinition md) { // ImportReference does not work as expected because the scope of the type found isn't in the module. foreach (var tt in md.Types) { if (type.Name == tt.Name && type.Namespace == tt.Namespace) { if (type as GenericInstanceType != null) { TypeReference[] args = (type as GenericInstanceType).GenericArguments.ToArray(); GenericInstanceType de = tt.MakeGenericInstanceType(args); return(de); } return(tt); } } return(null); }