FieldAccessor.cs

Go to the documentation of this file.

using System;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;
 
namespace IKVM.Runtime.Accessors
{
 
#if FIRST_PASS == false && EXPORTER == false && IMPORTER == false
 
    internal abstract class FieldAccessor
    {
 
        readonly Type type;
        readonly string name;
        FieldInfo field;
 
        protected FieldAccessor(Type type, string name)
        {
            this.type = type ?? throw new ArgumentNullException(nameof(type));
            this.name = name ?? throw new ArgumentNullException(nameof(name));
        }
 
        protected Type Type => type;
 
        protected string Name => name;
 
        protected FieldInfo Field => AccessorUtil.LazyGet(ref field, () => type.GetField(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) ?? throw new InvalidOperationException();
 
    }
 
    internal sealed class FieldAccessor<TField> : FieldAccessor
    {
 
        public static FieldAccessor<TField> LazyGet(ref FieldAccessor<TField> location, Type type, string name)
        {
            return AccessorUtil.LazyGet(ref location, () => new FieldAccessor<TField>(type, name));
        }
 
        Func<TField> getter;
        Action<TField> setter;
 
        public FieldAccessor(Type type, string name) :
            base(type, name)
        {
 
        }
 
        Func<TField> Getter => AccessorUtil.LazyGet(ref getter, MakeGetter);
 
        Action<TField> Setter => AccessorUtil.LazyGet(ref setter, MakeSetter);
 
        Func<TField> MakeGetter()
        {
#if FIRST_PASS
            throw new NotImplementedException();
#else
            var dm = DynamicMethodUtil.Create($"__<FieldAccessorGet>__{Type.Name.Replace(".", "_")}__{Field.Name}", Type, false, typeof(TField), Array.Empty<Type>());
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.Emit(OpCodes.Ldsfld, Field);
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (Func<TField>)dm.CreateDelegate(typeof(Func<TField>));
#endif
        }
 
        Action<TField> MakeSetter()
        {
#if FIRST_PASS
            throw new NotImplementedException();
#else
            var dm = DynamicMethodUtil.Create($"__<FieldAccessorSet>__{Type.Name.Replace(".", "_")}__{Field.Name}", Type, false, typeof(void), new[] { typeof(TField) });
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Stsfld, Field);
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (Action<TField>)dm.CreateDelegate(typeof(Action<TField>));
#endif
        }
 
        public TField GetValue() => Getter();
 
        public void SetValue(TField value) => Setter(value);
 
    }
 
    internal sealed class FieldAccessor<TObject, TField> : FieldAccessor
    {
 
        delegate TField GetterDelegate(TObject self);
        delegate void SetterDelegate(TObject self, TField value);
        delegate TField ExchangeDelegate(TObject self, TField value);
        delegate TField CompareExchangeDelegate(TObject self, TField value, TField comparand);
 
        static readonly MethodInfo ExchangeOfInt32 = typeof(Interlocked).GetMethod(nameof(Interlocked.Exchange), new[] { typeof(int).MakeByRefType(), typeof(int) });
        static readonly MethodInfo ExchangeOfInt64 = typeof(Interlocked).GetMethod(nameof(Interlocked.Exchange), new[] { typeof(long).MakeByRefType(), typeof(long) });
        static readonly MethodInfo ExchangeOfSingle = typeof(Interlocked).GetMethod(nameof(Interlocked.Exchange), new[] { typeof(float).MakeByRefType(), typeof(float) });
        static readonly MethodInfo ExchangeOfDouble = typeof(Interlocked).GetMethod(nameof(Interlocked.Exchange), new[] { typeof(double).MakeByRefType(), typeof(double) });
        static readonly MethodInfo ExchangeOfT = typeof(Interlocked).GetMethods().First(i => i.Name == nameof(Interlocked.Exchange) && i.GetGenericArguments().Length == 1);
 
        static readonly MethodInfo CompareExchangeOfInt32 = typeof(Interlocked).GetMethod(nameof(Interlocked.CompareExchange), new[] { typeof(int).MakeByRefType(), typeof(int), typeof(int) });
        static readonly MethodInfo CompareExchangeOfInt64 = typeof(Interlocked).GetMethod(nameof(Interlocked.CompareExchange), new[] { typeof(long).MakeByRefType(), typeof(long), typeof(long) });
        static readonly MethodInfo CompareExchangeOfSingle = typeof(Interlocked).GetMethod(nameof(Interlocked.CompareExchange), new[] { typeof(float).MakeByRefType(), typeof(float), typeof(float) });
        static readonly MethodInfo CompareExchangeOfDouble = typeof(Interlocked).GetMethod(nameof(Interlocked.CompareExchange), new[] { typeof(double).MakeByRefType(), typeof(double), typeof(double) });
        static readonly MethodInfo CompareExchangeOfT = typeof(Interlocked).GetMethods().First(i => i.Name == nameof(Interlocked.CompareExchange) && i.GetGenericArguments().Length == 1);
 
        public static FieldAccessor<TObject, TField> LazyGet(ref FieldAccessor<TObject, TField> location, Type type, string name)
        {
            return AccessorUtil.LazyGet(ref location, () => new FieldAccessor<TObject, TField>(type, name));
        }
 
        GetterDelegate getter;
        SetterDelegate setter;
        ExchangeDelegate exchange;
        CompareExchangeDelegate compareExchange;
 
        public FieldAccessor(Type type, string name) :
            base(type, name)
        {
 
        }
 
        GetterDelegate Getter => AccessorUtil.LazyGet(ref getter, MakeGetter);
 
        SetterDelegate Setter => AccessorUtil.LazyGet(ref setter, MakeSetter);
 
        ExchangeDelegate Exchange => AccessorUtil.LazyGet(ref exchange, MakeExchange);
 
        CompareExchangeDelegate CompareExchange => AccessorUtil.LazyGet(ref compareExchange, MakeCompareExchange);
 
        GetterDelegate MakeGetter()
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            var dm = DynamicMethodUtil.Create($"__<FieldAccessorGet>__{Field.DeclaringType.Name.Replace(".", "_")}__{Field.Name}", Type, false, typeof(TField), new[] { typeof(TObject) });
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, Type);
            il.Emit(OpCodes.Ldfld, Field);
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (GetterDelegate)dm.CreateDelegate(typeof(GetterDelegate));
#endif
        }
 
        SetterDelegate MakeSetter()
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            var dm = DynamicMethodUtil.Create($"__<FieldAccessorSet>__{Field.DeclaringType.Name.Replace(".", "_")}__{Field.Name}", Type, false, typeof(void), new[] { typeof(TObject), typeof(TField) });
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Castclass, Type);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Stfld, Field);
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (SetterDelegate)dm.CreateDelegate(typeof(SetterDelegate));
#endif
        }
 
        ExchangeDelegate MakeExchange()
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            var dm = DynamicMethodUtil.Create($"__<FieldAccessorExchange>__{Field.DeclaringType.Name.Replace(".", "_")}__{Field.Name}", Type, false, typeof(TField), new[] { typeof(TObject), typeof(TField) });
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.EmitLdarg(0);
            il.Emit(OpCodes.Castclass, Type);
            il.Emit(Field.IsStatic ? OpCodes.Ldsflda: OpCodes.Ldflda, Field);
            il.EmitLdarg(1);
 
            switch (typeof(TField))
            {
                case Type t when t == typeof(int):
                    il.Emit(OpCodes.Call, ExchangeOfInt32);
                    break;
                case Type t when t == typeof(long):
                    il.Emit(OpCodes.Call, ExchangeOfInt64);
                    break;
                case Type t when t == typeof(float):
                    il.Emit(OpCodes.Call, ExchangeOfSingle);
                    break;
                case Type t when t == typeof(double):
                    il.Emit(OpCodes.Call, ExchangeOfDouble);
                    break;
                case Type t when t.IsValueType == false:
                    il.Emit(OpCodes.Call, ExchangeOfT.MakeGenericMethod(Field.FieldType));
                    break;
                default:
                    throw new InternalException("No Interlocked.Exchange implementation for type.");
            }
 
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (ExchangeDelegate)dm.CreateDelegate(typeof(ExchangeDelegate));
#endif
        }
 
        CompareExchangeDelegate MakeCompareExchange()
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            var dm = DynamicMethodUtil.Create($"__<FieldAccessorCompareExchange>__{Field.DeclaringType.Name.Replace(".", "_")}__{Field.Name}", Type, false, typeof(TField), new[] { typeof(TObject), typeof(TField), typeof(TField) });
            var il = JVM.Context.CodeEmitterFactory.Create(dm);
 
            il.EmitLdarg(0);
            il.Emit(OpCodes.Castclass, Type);
            il.Emit(Field.IsStatic ? OpCodes.Ldsflda : OpCodes.Ldflda, Field);
            il.EmitLdarg(1);
            il.EmitLdarg(2);
 
            switch (typeof(TField))
            {
                case Type t when t == typeof(int):
                    il.Emit(OpCodes.Call, CompareExchangeOfInt32);
                    break;
                case Type t when t == typeof(long):
                    il.Emit(OpCodes.Call, CompareExchangeOfInt64);
                    break;
                case Type t when t == typeof(float):
                    il.Emit(OpCodes.Call, CompareExchangeOfSingle);
                    break;
                case Type t when t == typeof(double):
                    il.Emit(OpCodes.Call, CompareExchangeOfDouble);
                    break;
                case Type t when t.IsValueType == false:
                    il.Emit(OpCodes.Call, CompareExchangeOfT.MakeGenericMethod(Field.FieldType));
                    break;
                default:
                    throw new InternalException("No Interlocked.CompareExchange implementation for type.");
            }
 
            il.Emit(OpCodes.Ret);
            il.DoEmit();
 
            return (CompareExchangeDelegate)dm.CreateDelegate(typeof(CompareExchangeDelegate));
#endif
        }
 
        public TField GetValue(TObject self) => Getter(self);
 
        public void SetValue(TObject self, TField value) => Setter(self, value);
 
        public TField ExchangeValue(TObject self, TField value) => Exchange(self, value);
        
        public TField CompareExchangeValue(TObject self, TField value, TField comparand) => CompareExchange(self, value, comparand);
 
    }
 
#endif
 
}