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