Add ldftn and DelegateShim

src/Platforms/Echo.Platforms.AsmResolver/Emulation/CilVirtualMachine.cs

@@ -43,6 +43,7 @@ public CilVirtualMachine(ModuleDefinition contextModule, bool is32Bit)
             ValueFactory = new ValueFactory(contextModule, is32Bit);
             ObjectMapMemory = new ObjectMapMemory(this, 0x1000_0000);
             ObjectMarshaller = new ObjectMarshaller(this);
+            FunctionMarshaller = new FunctionMarshaller(this);
 
             if (is32Bit)
             {
@@ -179,6 +180,15 @@ public IObjectMarshaller ObjectMarshaller
             get;
             set;
         }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public IFunctionMarshaller FunctionMarshaller
+        {
+            get;
+            set;
+        }
 
         /// <summary>
         /// Gets a collection of threads that are currently active in the machine.

src/Platforms/Echo.Platforms.AsmResolver/Emulation/Dispatch/Pointers/LdftnHandler.cs

@@ -0,0 +1,26 @@
+using System;
+using AsmResolver.DotNet;
+using AsmResolver.PE.DotNet.Cil;
+
+namespace Echo.Platforms.AsmResolver.Emulation.Dispatch.Pointers;
+
+/// <summary>
+/// Implements a CIL instruction handler for <c>ldftn</c> instruction.
+/// </summary>
+[DispatcherTableEntry(CilCode.Ldftn)]
+public class LdftnHandler: FallThroughOpCodeHandler
+{
+    /// <inheritdoc/>
+    protected override CilDispatchResult DispatchInternal(CilExecutionContext context, CilInstruction instruction)
+    {
+        var stack = context.CurrentFrame.EvaluationStack;
+        var factory = context.Machine.ValueFactory;
+        var marshaller = context.Machine.FunctionMarshaller;
+        var type = context.Machine.ContextModule.CorLibTypeFactory.IntPtr;
+
+        var functionPointer = marshaller.GetFunctionPointer((IMethodDescriptor)instruction.Operand!);
+        stack.Push(factory.CreateNativeInteger((long)functionPointer), type);
+
+        return CilDispatchResult.Success();
+    }
+}

src/Platforms/Echo.Platforms.AsmResolver/Emulation/FunctionMarshaller.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AsmResolver.DotNet;
+
+namespace Echo.Platforms.AsmResolver.Emulation;
+
+/// <inheritdoc/>
+public class FunctionMarshaller : IFunctionMarshaller
+{
+    private readonly Dictionary<nuint, IMethodDescriptor> mappedPointers = new();
+    private nuint pointer = 13;
+
+    /// <summary>
+    /// Creates a new marshaller for the provided virtual machine.
+    /// </summary>
+    /// <param name="machine"></param>
+    public FunctionMarshaller(CilVirtualMachine machine)
+    {
+        Machine = machine;
+    }
+
+    /// <inheritdoc/>
+    public CilVirtualMachine Machine
+    {
+        get;
+    }
+
+    /// <inheritdoc/>
+    public nuint GetFunctionPointer(IMethodDescriptor method)
+    {
+        foreach (var pair in mappedPointers)
+        {
+            if (pair.Value == method)
+                return pair.Key;
+        }
+        mappedPointers.Add(pointer, method);
+        return pointer++;
+    }
+
+    /// <inheritdoc/>
+    public IMethodDescriptor? ResolveMethodPointer(nuint pointer)
+    {
+        if (mappedPointers.TryGetValue(pointer, out var result))
+            return result;
+        return null;
+    }
+}

src/Platforms/Echo.Platforms.AsmResolver/Emulation/IFunctionMarshaller.cs

@@ -0,0 +1,26 @@
+using AsmResolver.DotNet;
+
+namespace Echo.Platforms.AsmResolver.Emulation;
+/// <summary>
+/// Provides methods for marshalling functions into pointers
+/// </summary>
+public interface IFunctionMarshaller
+{
+    /// <summary>
+    /// Gets the machine the marshaller is targeting.
+    /// </summary>
+    CilVirtualMachine Machine
+    {
+        get;
+    }
+
+    /// <summary>
+    /// Returns pointer for method descriptor
+    /// </summary>
+    nuint GetFunctionPointer(IMethodDescriptor method);
+
+    /// <summary>
+    /// Returns method descriptor for pointer
+    /// </summary>
+    IMethodDescriptor? ResolveMethodPointer(nuint pointer);
+}

src/Platforms/Echo.Platforms.AsmResolver/Emulation/Invocation/DefaultInvokers.cs

@@ -53,6 +53,11 @@ public static class DefaultInvokers
         /// </summary>
         public static UnsafeInvoker UnsafeShim => UnsafeInvoker.Instance;
 
+        /// <summary>
+        /// Gets the default shim for the <see cref="System.Delegate"/> class.
+        /// </summary>
+        public static DelegateInvoker DelegateShim => DelegateInvoker.Instance;
+
         /// <summary>
         /// Gets the default shim for the <see cref="System.Runtime.CompilerServices.RuntimeHelpers"/> class.
         /// </summary>
@@ -96,7 +101,8 @@ public static IMethodInvoker CreateDefaultShims() => StringShim
             .WithFallback(UnsafeShim)
             .WithFallback(RuntimeHelpersShim)
             .WithFallback(IntrinsicsShim)
-            .WithFallback(MemoryMarshalShim);
+            .WithFallback(MemoryMarshalShim)
+            .WithFallback(DelegateShim);
 
         /// <summary>
         /// Chains the first method invoker with the provided method invoker in such a way that if the result of the

src/Platforms/Echo.Platforms.AsmResolver/Emulation/Invocation/DelegateInvoker.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using AsmResolver.DotNet;
+using AsmResolver.DotNet.Signatures;
+using AsmResolver.PE.DotNet.Cil;
+using Echo.Memory;
+using Echo.Platforms.AsmResolver.Emulation.Dispatch;
+
+namespace Echo.Platforms.AsmResolver.Emulation.Invocation;
+/// <summary>
+/// Wrapper for Delegates
+/// </summary>
+public class DelegateInvoker : IMethodInvoker
+{
+    /// <summary>
+    /// Instance
+    /// </summary>
+    public static DelegateInvoker Instance { get; } = new();
+
+    /// <inheritdoc />
+    public InvocationResult Invoke(CilExecutionContext context, IMethodDescriptor method, IList<BitVector> arguments)
+    {
+        if (method is not { Name: { } name, DeclaringType: { } declaringType, Signature: { } signature })
+            return InvocationResult.Inconclusive();
+
+        if (declaringType.Resolve()?.BaseType?.IsTypeOf("System", "MulticastDelegate") == false)
+            return InvocationResult.Inconclusive();
+
+        if (method.Name == ".ctor")
+        {
+            return ConstructDelegate(context, arguments);
+        }
+
+        if (method.Name == "Invoke")
+        {
+            return InvokeDelegate(context, arguments);
+        }
+
+        return InvocationResult.Inconclusive();
+    }
+
+    private InvocationResult ConstructDelegate(CilExecutionContext context, IList<BitVector> arguments)
+    {
+        var vm = context.Machine;
+        var corlib = vm.ContextModule.CorLibTypeFactory;
+
+        var self = arguments[0].AsObjectHandle(vm);
+        var obj = arguments[1];
+        var methodPtr = arguments[2];
+
+        var _delegate = self.GetObjectType().Resolve()!.BaseType!.Resolve()!.BaseType;
+        IFieldDescriptor _target = new MemberReference(_delegate, "_target", new FieldSignature(corlib.Object));
+        IFieldDescriptor _methodPtr = new MemberReference(_delegate, "_methodPtr", new FieldSignature(corlib.IntPtr));
+
+        if (obj.IsFullyKnown && obj.AsObjectHandle(vm).IsNull)
+            self.WriteField(_target, obj);
+
+        self.WriteField(_methodPtr, methodPtr);
+
+        //var methodBase = vm.FunctionMarshaller.ResolveMethodPointer((nuint)methodPtr.AsSpan().ReadNativeInteger(vm.Is32Bit));
+        //if (methodBase != null)
+        //    self.WriteField(_methodBase, marshall IMethodDescriptor to RuntimeMethodInfo);
+
+        return InvocationResult.StepOver(null);
+    }
+
+    private InvocationResult InvokeDelegate(CilExecutionContext context, IList<BitVector> arguments)
+    {
+        var vm = context.Machine;
+        var stack = context.CurrentFrame.EvaluationStack;
+        var corlib = vm.ContextModule.CorLibTypeFactory;
+
+        var self = arguments[0].AsObjectHandle(vm);
+
+        var _delegate = self.GetObjectType().Resolve()!.BaseType!.Resolve()!.BaseType;
+        IFieldDescriptor _target = new MemberReference(_delegate, "_target", new FieldSignature(corlib.Object));
+        IFieldDescriptor _methodPtr = new MemberReference(_delegate, "_methodPtr", new FieldSignature(corlib.IntPtr));
+
+        var methodPtr = self.ReadField(_methodPtr).AsSpan().ReadNativeInteger(vm.Is32Bit);
+        var method = vm.FunctionMarshaller.ResolveMethodPointer((nuint)methodPtr);
+
+        if (method == null)
+            throw new Exception("Cant resolve method");
+
+        var arg1 = self.ReadField(_target);
+        if (arg1.AsSpan().ReadNativeInteger(vm.Is32Bit) != 0)
+            stack.Push(arg1.AsObjectHandle(vm));
+
+        // skip 1 for delegate "this"
+        for (var i = 1; i < arguments.Count; i++)
+            stack.Push(arguments[i], method.Signature!.ParameterTypes[i]);
+
+        var result = vm.Dispatcher.Dispatch(context, new(CilOpCodes.Call, method));
+
+        if (!result.IsSuccess)
+            return InvocationResult.Exception(result.ExceptionObject);
+
+        return InvocationResult.StepOver(null);
+    }
+}

test/Platforms/Echo.Platforms.AsmResolver.Tests/Emulation/CilVirtualMachineTest.cs

@@ -662,5 +662,36 @@ public void StepPrefixedInstructionsShouldStepOverAllInstructions()
             _mainThread.Step();
             Assert.Equal(instructions[3].Offset, frame.ProgramCounter);
         }
+
+        [Fact]
+        public void CallDelegate()
+        {
+            var method = _fixture.MockModule
+                    .LookupMember<TypeDefinition>(typeof(TestClass).MetadataToken)
+                    .Methods.First(m => m.Name == nameof(TestClass.TestDelegateCall));
+
+            _vm.Invoker = DefaultInvokers.DelegateShim.WithFallback(DefaultInvokers.StepIn);
+
+            _mainThread.CallStack.Push(method);
+            bool entered = false;
+            bool retIsFive = false;
+            while ((entered & retIsFive) != true)
+            {
+                _mainThread.Step();
+                if (!entered && _mainThread.CallStack.Count == 3
+                    && _mainThread.CallStack.Peek().Method.Name == "ReturnAnyInt")
+                    entered = true;
+                else if (entered && !retIsFive && _mainThread.CallStack.Count == 2)
+                {
+                    var stack = _mainThread.CallStack.Peek().EvaluationStack;
+                    if (stack.Count == 1 && stack.Peek().Contents.AsSpan().U32 == 5)
+                    {
+                        retIsFive = true;
+                    }
+                }
+            }
+            Assert.True(entered);
+            Assert.True(retIsFive);
+        }
     }
 }

test/Platforms/Mocks/TestClass.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Net;
 using InlineIL;
@@ -285,5 +285,15 @@ public static int CatchExceptionInChildMethod(bool @throw)
 
             return result;
         }
+
+        public delegate int ReturnAnyIntDelegate();
+
+        private static int ReturnAnyInt() => 5;
+
+        public static int TestDelegateCall()
+        {
+            ReturnAnyIntDelegate del = ReturnAnyInt;
+            return del();
+        }
     }
 }