[Feature]: Trimmable DotNet Project

AsmResolver.sln

@@ -84,6 +84,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		README.md = README.md
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AsmResolver.DotNet.Dynamic.Tests", "test\AsmResolver.DotNet.Dynamic.Tests\AsmResolver.DotNet.Dynamic.Tests.csproj", "{C089D0AB-B428-4136-89CC-7974CB590513}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AsmResolver.DotNet.Dynamic", "src\AsmResolver.DotNet.Dynamic\AsmResolver.DotNet.Dynamic.csproj", "{62420213-67AD-40FC-B451-BD05C2437CE3}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -422,6 +426,30 @@ Global
 		{2D1DF5DA-7367-4490-B3F0-B996348E150B}.Release|x64.Build.0 = Release|Any CPU
 		{2D1DF5DA-7367-4490-B3F0-B996348E150B}.Release|x86.ActiveCfg = Release|Any CPU
 		{2D1DF5DA-7367-4490-B3F0-B996348E150B}.Release|x86.Build.0 = Release|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Debug|x64.Build.0 = Debug|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Debug|x86.Build.0 = Debug|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Release|x64.ActiveCfg = Release|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Release|x64.Build.0 = Release|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Release|x86.ActiveCfg = Release|Any CPU
+		{C089D0AB-B428-4136-89CC-7974CB590513}.Release|x86.Build.0 = Release|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Debug|x64.Build.0 = Debug|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Debug|x86.Build.0 = Debug|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Release|Any CPU.Build.0 = Release|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Release|x64.ActiveCfg = Release|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Release|x64.Build.0 = Release|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Release|x86.ActiveCfg = Release|Any CPU
+		{62420213-67AD-40FC-B451-BD05C2437CE3}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -459,6 +487,8 @@ Global
 		{40483E28-C703-4933-BA5B-9512EF6E6A21} = {EA971BB0-94BA-44DB-B16C-212D2DB27E17}
 		{CF6A7E02-37DC-4963-AC14-76D74ADCD87A} = {B3AF102B-ABE1-41B2-AE48-C40702F45AB0}
 		{2D1DF5DA-7367-4490-B3F0-B996348E150B} = {B3AF102B-ABE1-41B2-AE48-C40702F45AB0}
+		{C089D0AB-B428-4136-89CC-7974CB590513} = {786C1732-8C96-45DD-97BB-639C9AA7F45B}
+		{62420213-67AD-40FC-B451-BD05C2437CE3} = {34A95168-A162-4F6A-803B-B6F221FE9EA6}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {3302AC79-6D23-4E7D-8C5F-C0C7261044D0}

src/AsmResolver.DotNet.Dynamic/AsmResolver.DotNet.Dynamic.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <Title>AsmResolver.DotNet.Dynamic</Title>
+        <Description>Dynamic method support for the AsmResolver executable file inspection toolsuite.</Description>
+        <PackageTags>exe pe directories imports exports resources dotnet cil inspection manipulation assembly disassembly dynamic</PackageTags>
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+        <NoWarn>1701;1702;NU5105</NoWarn>
+        <TargetFrameworks>net6.0;netcoreapp3.1;netstandard2.0</TargetFrameworks>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+      <DocumentationFile>bin\Debug\AsmResolver.DotNet.xml</DocumentationFile>
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+      <DocumentationFile>bin\Release\AsmResolver.DotNet.xml</DocumentationFile>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\AsmResolver.DotNet\AsmResolver.DotNet.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Nullable" Version="1.3.0">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
+      <PackageReference Include="System.Text.Json" Version="6.0.3" />
+    </ItemGroup>
+
+</Project>

src/AsmResolver.DotNet/Code/Cil/DynamicCilOperandResolver.cs → src/AsmResolver.DotNet.Dynamic/DynamicCilOperandResolver.cs

@@ -1,13 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using AsmResolver.DotNet.Code.Cil;
 using AsmResolver.DotNet.Serialized;
 using AsmResolver.DotNet.Signatures;
 using AsmResolver.IO;
 using AsmResolver.PE.DotNet.Cil;
 using AsmResolver.PE.DotNet.Metadata.Tables;
 
-namespace AsmResolver.DotNet.Code.Cil
+namespace AsmResolver.DotNet.Dynamic
 {
     /// <summary>
     /// Provides an implementation of <see cref="ICilOperandResolver"/> that resolves operands based on
@@ -34,13 +35,13 @@ public DynamicCilOperandResolver(SerializedModuleDefinition contextModule, CilMe
             switch (token.Table)
             {
                 case TableIndex.TypeDef:
-                    object? type = _tokens[(int) token.Rid];
+                    object? type = _tokens[(int)token.Rid];
                     if (type is RuntimeTypeHandle runtimeTypeHandle)
                         return _importer.ImportType(Type.GetTypeFromHandle(runtimeTypeHandle));
                     break;
 
                 case TableIndex.Field:
-                    object? field = _tokens[(int) token.Rid];
+                    object? field = _tokens[(int)token.Rid];
 
                     if (field is null)
                         return null;
@@ -61,7 +62,7 @@ public DynamicCilOperandResolver(SerializedModuleDefinition contextModule, CilMe
 
                 case TableIndex.Method:
                 case TableIndex.MemberRef:
-                    object? obj = _tokens[(int) token.Rid];
+                    object? obj = _tokens[(int)token.Rid];
 
                     if (obj is null)
                         return null;
@@ -94,7 +95,7 @@ public DynamicCilOperandResolver(SerializedModuleDefinition contextModule, CilMe
                     break;
 
                 case TableIndex.StandAloneSig:
-                    var reader = ByteArrayDataSource.CreateReader((byte[]) _tokens[(int) token.Rid]!);
+                    var reader = ByteArrayDataSource.CreateReader((byte[])_tokens[(int)token.Rid]!);
                     return CallingConventionSignature.FromReader(new BlobReadContext(_readerContext), ref reader);
             }
 
@@ -104,7 +105,7 @@ public DynamicCilOperandResolver(SerializedModuleDefinition contextModule, CilMe
         /// <inheritdoc />
         public override object? ResolveString(MetadataToken token)
         {
-            return _tokens[(int) token.Rid] as string;
+            return _tokens[(int)token.Rid] as string;
         }
     }
 }

src/AsmResolver.DotNet.Dynamic/DynamicMethodDefinition.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using AsmResolver.DotNet.Code.Cil;
+using AsmResolver.DotNet.Serialized;
+using AsmResolver.DotNet.Signatures;
+using AsmResolver.DotNet.Signatures.Types;
+using AsmResolver.IO;
+using AsmResolver.PE.DotNet.Cil;
+using AsmResolver.PE.DotNet.Metadata.Tables;
+using MethodAttributes = AsmResolver.PE.DotNet.Metadata.Tables.Rows.MethodAttributes;
+
+namespace AsmResolver.DotNet.Dynamic
+{
+    /// <summary>
+    /// Represents a single method in a type definition of a .NET module.
+    /// </summary>
+    public class DynamicMethodDefinition : MethodDefinition
+    {
+        /// <summary>
+        /// Create a Dynamic Method Definition
+        /// </summary>
+        /// <param name="module">Target Module</param>
+        /// <param name="dynamicMethodObj">Dynamic Method / Delegate / DynamicResolver</param>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Calls ResolveDynamicResolver and FromDynamicMethod")]
+        public DynamicMethodDefinition(ModuleDefinition module, object dynamicMethodObj) :
+            base(new MetadataToken(TableIndex.Method, 0))
+        {
+            dynamicMethodObj = DynamicMethodHelper.ResolveDynamicResolver(dynamicMethodObj);
+            var methodBase = FieldReader.ReadField<MethodBase>(dynamicMethodObj, "m_method");
+            if (methodBase is null)
+            {
+                throw new ArgumentException(
+                    "Could not get the underlying method base in the provided dynamic method object.");
+            }
+
+            Module = module;
+            Name = methodBase.Name;
+            Attributes = (MethodAttributes)methodBase.Attributes;
+            Signature = new ReferenceImporter(module).ImportMethodSignature(ResolveSig(methodBase, module));
+            CilMethodBody = ToCilMethodBody(this, dynamicMethodObj);
+        }
+
+        private MethodSignature ResolveSig(MethodBase methodBase, ModuleDefinition module)
+        {
+            var imp = new ReferenceImporter(module);
+            var returnType = methodBase is MethodInfo info
+                ? imp.ImportTypeSignature(info.ReturnType)
+                : module.CorLibTypeFactory.Void;
+
+            var parameters = methodBase.GetParameters();
+
+            var parameterTypes = new TypeSignature[parameters.Length];
+            for (int i = 0; i < parameterTypes.Length; i++)
+                parameterTypes[i] = imp.ImportTypeSignature(parameters[i].ParameterType);
+
+            return new MethodSignature(
+                methodBase.IsStatic ? 0 : CallingConventionAttributes.HasThis,
+                returnType, parameterTypes);
+        }
+
+        /// <inheritdoc />
+        public override ModuleDefinition Module { get; }
+
+        /// <summary>
+        ///     Creates a CIL method body from a dynamic method.
+        /// </summary>
+        /// <param name="method">The method that owns the method body.</param>
+        /// <param name="dynamicMethodObj">The Dynamic Method/Delegate/DynamicResolver.</param>
+        /// <returns>The method body.</returns>
+        public static CilMethodBody ToCilMethodBody(MethodDefinition method, object dynamicMethodObj)
+        {
+            if (!(method.Module is SerializedModuleDefinition module))
+                throw new ArgumentException("Method body should reference a serialized module.");
+
+            var result = new CilMethodBody(method);
+            dynamicMethodObj = DynamicMethodHelper.ResolveDynamicResolver(dynamicMethodObj);
+
+            //Get Runtime Fields
+            byte[] code = FieldReader.ReadField<byte[]>(dynamicMethodObj, "m_code")!;
+            object scope = FieldReader.ReadField<object>(dynamicMethodObj, "m_scope")!;
+            var tokenList = FieldReader.ReadField<List<object?>>(scope, "m_tokens")!;
+            byte[] localSig = FieldReader.ReadField<byte[]>(dynamicMethodObj, "m_localSignature")!;
+            byte[] ehHeader = FieldReader.ReadField<byte[]>(dynamicMethodObj, "m_exceptionHeader")!;
+            var ehInfos = FieldReader.ReadField<IList<object>>(dynamicMethodObj, "m_exceptions")!;
+
+            //Local Variables
+            DynamicMethodHelper.ReadLocalVariables(result, method, localSig);
+
+            // Read raw instructions.
+            var reader = ByteArrayDataSource.CreateReader(code);
+            var disassembler = new CilDisassembler(reader, new DynamicCilOperandResolver(module, result, tokenList));
+            result.Instructions.AddRange(disassembler.ReadInstructions());
+
+            //Exception Handlers
+            DynamicMethodHelper.ReadReflectionExceptionHandlers(result, ehInfos, ehHeader, new ReferenceImporter(module));
+
+            return result;
+        }
+    }
+}

src/AsmResolver.DotNet/DynamicMethodHelper.cs → src/AsmResolver.DotNet.Dynamic/DynamicMethodHelper.cs

@@ -9,7 +9,7 @@
 using AsmResolver.IO;
 using AsmResolver.PE.DotNet.Cil;
 
-namespace AsmResolver.DotNet
+namespace AsmResolver.DotNet.Dynamic
 {
     internal static class DynamicMethodHelper
     {
@@ -34,10 +34,10 @@ public static void ReadReflectionExceptionHandlers(CilMethodBody methodBody,
             IList<object>? ehInfos, byte[] ehHeader, ReferenceImporter importer)
         {
             //Sample needed!
-            if (ehHeader is {Length: > 4})
+            if (ehHeader is { Length: > 4 })
                 throw new NotImplementedException("Exception handlers from ehHeader not supported yet.");
 
-            if (ehInfos is {Count: > 0})
+            if (ehInfos is { Count: > 0 })
             {
                 foreach (var ehInfo in ehInfos)
                     InterpretEHInfo(methodBody, importer, ehInfo);
@@ -61,7 +61,7 @@ private static void InterpretEHInfo(CilMethodBody methodBody, ReferenceImporter
                 int handlerStart = FieldReader.ReadField<int[]>(ehInfo, "m_catchAddr")![i];
                 int handlerEnd = FieldReader.ReadField<int[]>(ehInfo, "m_catchEndAddr")![i];
                 var exceptionType = FieldReader.ReadField<Type?[]>(ehInfo, "m_catchClass")![i];
-                var handlerType = (CilExceptionHandlerType) FieldReader.ReadField<int[]>(ehInfo, "m_type")![i];
+                var handlerType = (CilExceptionHandlerType)FieldReader.ReadField<int[]>(ehInfo, "m_type")![i];
 
                 var endTryLabel = instructions.GetByOffset(tryEnd)?.CreateLabel() ?? new CilOffsetLabel(tryEnd);
 
@@ -81,7 +81,6 @@ private static void InterpretEHInfo(CilMethodBody methodBody, ReferenceImporter
             }
         }
 
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Calls GetTypes")]
         public static object ResolveDynamicResolver(object dynamicMethodObj)
         {
             //Convert dynamicMethodObj to DynamicResolver
@@ -111,7 +110,7 @@ public static object ResolveDynamicResolver(object dynamicMethodObj)
                     .Invoke(dynamicMethodObj, null);
 
                 //Create instance of dynamicResolver
-                dynamicMethodObj = Activator.CreateInstance(dynamicResolver, (BindingFlags) (-1), null, new[]
+                dynamicMethodObj = Activator.CreateInstance(dynamicResolver, (BindingFlags)(-1), null, new[]
                 {
                     ilGenerator
                 }, null)!;

src/AsmResolver.DotNet/AsmResolver.DotNet.csproj

@@ -8,6 +8,7 @@
         <NoWarn>1701;1702;NU5105</NoWarn>
         <Nullable>enable</Nullable>
         <TargetFrameworks>net6.0;netcoreapp3.1;netstandard2.0</TargetFrameworks>
+        <IsTrimmable>true</IsTrimmable>
     </PropertyGroup>
 
     <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">

src/AsmResolver.DotNet/Code/Cil/CilMethodBody.cs

@@ -130,43 +130,6 @@ public bool VerifyLabelsOnBuild
                                 | (value ? CilMethodBodyBuildFlags.VerifyLabels : 0);
         }
 
-        /// <summary>
-        ///     Creates a CIL method body from a dynamic method.
-        /// </summary>
-        /// <param name="method">The method that owns the method body.</param>
-        /// <param name="dynamicMethodObj">The Dynamic Method/Delegate/DynamicResolver.</param>
-        /// <returns>The method body.</returns>
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Calls ResolveDynamicResolver")]
-        public static CilMethodBody FromDynamicMethod(MethodDefinition method, object dynamicMethodObj)
-        {
-            if (!(method.Module is SerializedModuleDefinition module))
-                throw new ArgumentException("Method body should reference a serialized module.");
-
-            var result = new CilMethodBody(method);
-            dynamicMethodObj = DynamicMethodHelper.ResolveDynamicResolver(dynamicMethodObj);
-
-            //Get Runtime Fields
-            byte[] code = FieldReader.ReadField<byte[]>(dynamicMethodObj, "m_code")!;
-            object scope = FieldReader.ReadField<object>(dynamicMethodObj, "m_scope")!;
-            var tokenList = FieldReader.ReadField<List<object?>>(scope, "m_tokens")!;
-            byte[] localSig = FieldReader.ReadField<byte[]>(dynamicMethodObj, "m_localSignature")!;
-            byte[] ehHeader = FieldReader.ReadField<byte[]>(dynamicMethodObj, "m_exceptionHeader")!;
-            var ehInfos = FieldReader.ReadField<IList<object>>(dynamicMethodObj, "m_exceptions")!;
-
-            //Local Variables
-            DynamicMethodHelper.ReadLocalVariables(result, method, localSig);
-
-            // Read raw instructions.
-            var reader = ByteArrayDataSource.CreateReader(code);
-            var disassembler = new CilDisassembler(reader, new DynamicCilOperandResolver(module, result, tokenList));
-            result.Instructions.AddRange(disassembler.ReadInstructions());
-
-            //Exception Handlers
-            DynamicMethodHelper.ReadReflectionExceptionHandlers(result, ehInfos, ehHeader, new ReferenceImporter(module));
-
-            return result;
-        }
-
         /// <summary>
         /// Creates a CIL method body from a raw CIL method body.
         /// </summary>