public static IILGenerator Ldarg(this IILGenerator gen, byte argIndex)
{
switch (argIndex)
{
case 0:
gen.Ldarg_0();
break;
case 1:
gen.Ldarg_1();
break;
case 2:
gen.Ldarg_2();
break;
case 3:
gen.Ldarg_3();
break;
default:
gen.Ldarg_S(argIndex);
break;
}
return(gen);
}
public void SetUp()
{
_innerILGeneratorMock = MockRepository.GenerateStrictMock <IILGenerator>();
_emittableOperandProviderStub = MockRepository.GenerateStub <IEmittableOperandProvider>();
_decorator = new ILGeneratorDecorator(_innerILGeneratorMock, _emittableOperandProviderStub);
}
private Dictionary <VariableReference, LocalBuilder> AddVariables(IILGenerator generator,
IEnumerable <VariableReference> variables)
{
return(variables.ToDictionary(
variable => variable,
variable => generator.DeclareLocal(_typeResolver.Resolve(variable.VariableType))));
}
public ILGeneratorDecorator(IILGenerator innerIlGenerator, IEmittableOperandProvider emittableOperandProvider)
{
ArgumentUtility.CheckNotNull("innerIlGenerator", innerIlGenerator);
ArgumentUtility.CheckNotNull("emittableOperandProvider", emittableOperandProvider);
_innerILGenerator = innerIlGenerator;
_emittableOperandProvider = emittableOperandProvider;
}
public CodeGenerationExpressionEmitter(IILGenerator ilGenerator, Action <Expression> childExpressionEmitter)
{
ArgumentUtility.CheckNotNull("ilGenerator", ilGenerator);
ArgumentUtility.CheckNotNull("childExpressionEmitter", childExpressionEmitter);
_ilGenerator = ilGenerator;
_childExpressionEmitter = childExpressionEmitter;
}
private static void CreateInitValueType(Type targetType, IILGenerator gen)
{
var _var = gen.DeclareLocal(targetType);
gen
.Ldloca_S(_var)
.Initobj(targetType)
.Ldloc_0();
}
public ILGeneration(IILGenerator generator, CodeGenerationStore store, CurrentMethodInfo currentMethodInfo,
IType[] delegateConstructorTypes, IConstructorInfo baseConstructorCall, SimpleTypeChecker typeChecker)
{
this.generator = generator;
this.store = store;
this.currentMethodInfo = currentMethodInfo;
this.delegateConstructorTypes = delegateConstructorTypes;
this.baseConstructorCall = baseConstructorCall;
this.typeChecker = typeChecker;
}
public static Func <TField> StaticGetField <TField>(FieldInfo field)
{
DynamicMethod getter = new DynamicMethod($"get_{field.DeclaringType.Name}_{field.Name}", typeof(TField), new Type[] { }, typeof(Dynamic), true);
IILGenerator gen = getter.GetILGenerator().AsInterface();
gen
.Ldsfld(field)
.Ret();
return((Func <TField>)getter.CreateDelegate(typeof(Func <TField>)));
}
internal ILGeneratorInstructionVisitor(
IServiceLocator serviceLocator,
IILGenerator generator,
IDictionary<VariableReference, LocalBuilder> locals)
: this(serviceLocator,
generator,
locals,
serviceLocator.Resolve<ITypeResolver>(),
serviceLocator.Resolve<IOpCodeMapper>())
{
}
private void AddInstructions(IILGenerator generator, IEnumerable <Instruction> instructions,
Dictionary <VariableReference, LocalBuilder> locals)
{
IInstructionVisitor visitor = new ILGeneratorInstructionVisitor(_serviceLocator, generator, locals);
foreach (var instruction in instructions)
{
instruction.Accept(visitor);
}
generator.Emit(OpCodes.Ret);
}
internal ILGeneratorInstructionVisitor(
IServiceLocator serviceLocator,
IILGenerator generator,
IDictionary <VariableReference, LocalBuilder> locals)
: this(
serviceLocator,
generator,
locals,
serviceLocator.Resolve <ITypeResolver>(),
serviceLocator.Resolve <IOpCodeMapper>())
{
}
public static ILArgBuilder GetArgBuilder(IILGenerator gen, Type delegateArg, Type targetArg)
{
foreach (var builder in ilBuilders)
{
if (builder.Key(delegateArg, targetArg))
{
return((ILArgBuilder)Activator.CreateInstance(builder.Value, gen, delegateArg, targetArg));
}
}
throw new NotSupportedException($"argument converstion from {delegateArg} to {targetArg} is not supported");
}
public static Action <TField> StaticSetField <TField>(FieldInfo field)
{
DynamicMethod getter = new DynamicMethod($"set_{field.DeclaringType.Name}_{field.Name}", null, new Type[] { typeof(TField) }, typeof(Dynamic), true);
IILGenerator gen = getter.GetILGenerator().AsInterface();
gen
.Ldarg_0()
.Stsfld(field)
.Ret();
return((Action <TField>)getter.CreateDelegate(typeof(Action <TField>)));
}
public static ByRefGetter <TInstance, TField> StructGetField <TInstance, TField>(FieldInfo field) where TInstance : struct
{
DynamicMethod getter = new DynamicMethod($"get_{field.DeclaringType.Name}_{field.Name}", typeof(TField), new Type[] { typeof(TInstance).MakeByRefType() }, typeof(Dynamic), true);
IILGenerator gen = getter.GetILGenerator().AsInterface();
gen
.Ldarg_0()
.Ldfld(field)
.Ret();
return((ByRefGetter <TInstance, TField>)getter.CreateDelegate(typeof(ByRefGetter <TInstance, TField>)));
}
public static Setter <TInstance, TField> InstanceSetField <TInstance, TField>(FieldInfo field) where TInstance : class
{
DynamicMethod getter = new DynamicMethod($"set_{field.DeclaringType.Name}_{field.Name}", null, new Type[] { typeof(TInstance), typeof(TField) }, typeof(Dynamic), true);
IILGenerator gen = getter.GetILGenerator().AsInterface();
gen
.Ldarg_0()
.Ldarg_1()
.Stfld(field)
.Ret();
return((Setter <TInstance, TField>)getter.CreateDelegate(typeof(Setter <TInstance, TField>)));
}
internal ILGeneratorInstructionVisitor(
IServiceLocator serviceLocator,
IILGenerator generator,
IDictionary<VariableReference, LocalBuilder> locals,
ITypeResolver typeResolver,
IOpCodeMapper opCodeMapper)
: this(generator,
locals,
typeResolver,
serviceLocator.Resolve<IMethodResolver>(),
serviceLocator.Resolve<IFieldResolver>(),
opCodeMapper)
{
}
internal ILGeneratorInstructionVisitor(
IServiceLocator serviceLocator,
IILGenerator generator,
IDictionary <VariableReference, LocalBuilder> locals,
ITypeResolver typeResolver,
IOpCodeMapper opCodeMapper)
: this(generator,
locals,
typeResolver,
serviceLocator.Resolve <IMethodResolver>(),
serviceLocator.Resolve <IFieldResolver>(),
opCodeMapper)
{
}
internal ILGeneratorInstructionVisitor(IILGenerator generator,
IDictionary <VariableReference, LocalBuilder> locals,
ITypeResolver typeResolver,
IMethodResolver methodResolver,
IFieldResolver fieldResolver,
IOpCodeMapper opCodeMapper)
{
ArgumentChecker.NotNull(generator, () => generator);
ArgumentChecker.NotNull(locals, () => locals);
ArgumentChecker.NotNull(typeResolver, () => typeResolver);
ArgumentChecker.NotNull(methodResolver, () => methodResolver);
ArgumentChecker.NotNull(fieldResolver, () => fieldResolver);
ArgumentChecker.NotNull(opCodeMapper, () => opCodeMapper);
_generator = generator;
_locals = locals;
_typeResolver = typeResolver;
_methodResolver = methodResolver;
_fieldResolver = fieldResolver;
_opCodeMapper = opCodeMapper;
}
internal ILGeneratorInstructionVisitor(IILGenerator generator)
: this(ServiceLocator.Default, generator, new Dictionary<VariableReference, LocalBuilder>())
{
}
public static IILGenerator Ldloc_1(this IILGenerator gen)
{
gen.Emit(OpCodes.Ldloc_1); return(gen);
}
public MethodWriter(MethodBuilder mb, MethodInstance method, StringBuilder sb)
{
this.gen = new TraceILGenerator(mb.GetILGenerator(), sb);
this.method = method;
}
internal ILGeneratorInstructionVisitor(IILGenerator generator)
: this(ServiceLocator.Default, generator, new Dictionary <VariableReference, LocalBuilder>())
{
}
public static Delegate ConstructorCaller(Type delegateType, ConstructorInfo constructor, Type instanceType)
{
// arguments checks
if (!typeof(Delegate).IsAssignableFrom(delegateType))
{
throw new ArgumentException("delegateType does not represents a delegate", nameof(delegateType));
}
if (instanceType == null && !instanceType.IsValueType)
{
throw new ArgumentNullException(nameof(instanceType));
}
if (constructor == null && !instanceType.IsValueType)
{
throw new ArgumentException("constructor is null, but instanceType is not a value type", nameof(instanceType));
}
// read delegate info
var methodInfo = delegateType.GetMethod("Invoke");
var delegateArgs = methodInfo.GetParameters().Select(x => x.ParameterType).ToArray() ?? Type.EmptyTypes;
var retType = methodInfo.ReturnType != typeof(void) ? methodInfo.ReturnType : null;
// read constructor info
var ctorArgs = constructor?.GetParameters().Select(x => x.ParameterType).ToArray() ?? Type.EmptyTypes;
if (delegateArgs.Length != ctorArgs.Length)
{
throw new Exception("deletage's arguments count does not match constructor's arguments count");
}
//
var targetType = constructor?.DeclaringType ?? instanceType;
DynamicMethod wrapper = new DynamicMethod($"ctor_{targetType.Name}_", retType, delegateArgs, typeof(Dynamic), true);
IILGenerator gen = wrapper.GetILGenerator().AsInterface();
if (targetType.IsValueType && ctorArgs.Length == 0)
{
CreateInitValueType(targetType, gen);
}
else
{
List <ILArgBuilder> argBuilders = new List <ILArgBuilder>();
for (int i = 0; i < ctorArgs.Length; i++)
{
argBuilders.Add(ILMethodBuilder.GetArgBuilder(gen, delegateArgs[i], ctorArgs[i]));
}
for (int i = 0; i < ctorArgs.Length; i++)
{
argBuilders[i].Prepare((byte)i);
}
for (int i = 0; i < ctorArgs.Length; i++)
{
argBuilders[i].PassArg((byte)i);
}
gen.Newobj(constructor);
for (int i = ctorArgs.Length - 1; i >= 0; i--)
{
argBuilders[i].Finalize_((byte)i);
}
}
gen.Ret();
return(wrapper.CreateDelegate(delegateType));
}
internal ILGeneratorInstructionVisitor(IILGenerator generator,
IDictionary<VariableReference, LocalBuilder> locals,
ITypeResolver typeResolver,
IMethodResolver methodResolver,
IFieldResolver fieldResolver,
IOpCodeMapper opCodeMapper)
{
ArgumentChecker.NotNull(generator, () => generator);
ArgumentChecker.NotNull(locals, () => locals);
ArgumentChecker.NotNull(typeResolver, () => typeResolver);
ArgumentChecker.NotNull(methodResolver, () => methodResolver);
ArgumentChecker.NotNull(fieldResolver, () => fieldResolver);
ArgumentChecker.NotNull(opCodeMapper, () => opCodeMapper);
_generator = generator;
_locals = locals;
_typeResolver = typeResolver;
_methodResolver = methodResolver;
_fieldResolver = fieldResolver;
_opCodeMapper = opCodeMapper;
}
public InterfaceGenerator(IFunctionPointerLoader functionPointerLoader, IILGenerator ilGenerator)
{
this.functionPointerLoader = functionPointerLoader;
this.ilGenerator = ilGenerator;
}
public PassthroughILBuilder(IILGenerator gen, Type delegateArgType, Type methodArgType) : base(gen, delegateArgType, methodArgType)
{
}
public UnboxILBuilder(IILGenerator gen, Type delegateArgType, Type methodArgType) : base(gen, delegateArgType, methodArgType)
{
}
public void SetUp()
{
_ilGeneratorMock = MockRepository.GenerateStrictMock <IILGenerator>();
_childExpressionEmitterMock = MockRepository.GenerateStrictMock <IChildExpressionEmitter>();
_emitter = new CodeGenerationExpressionEmitter(_ilGeneratorMock, _childExpressionEmitterMock.EmitChildExpression);
}
public ILArgBuilder(IILGenerator gen, Type delegateArgType, Type methodArgType)
{
this.gen = gen;
this.delegateArgType = delegateArgType;
this.methodArgType = methodArgType;
}
public static Delegate CreateMethodCaller(Type delegateType, MethodInfo method)
{
// arguments checks
if (!typeof(Delegate).IsAssignableFrom(delegateType))
{
throw new ArgumentException("delegateType does not represents a delegate", nameof(delegateType));
}
// read delegate info
var methodInfo = delegateType.GetMethod("Invoke");
var delegateArgs = methodInfo?.GetParameters().Select(x => x.ParameterType).ToArray() ?? Type.EmptyTypes;
var retType = methodInfo.ReturnType != typeof(void) ? methodInfo.ReturnType : null;
// read method info
var methodArgs = method.GetParameters().Select(x => x.ParameterType).ToArray();
var argsCount = methodArgs.Length;
//
Type this_ = method.IsStatic ? null : (method.DeclaringType.IsValueType ? method.DeclaringType.MakeByRefType() : method.DeclaringType);
var arguments = Enumerable.Empty <Type>();
if (this_ != null)
{
arguments = arguments.Append(this_);
argsCount++;
}
arguments = arguments.Concat(methodArgs);
if (delegateArgs.Length != argsCount)
{
throw new Exception("deletage's arguments count does not match method's arguments count");
}
DynamicMethod wrapper = new DynamicMethod($"method_{method.DeclaringType.Name}_{method.Name}", retType, arguments.ToArray(), typeof(Dynamic), true);
IILGenerator gen = wrapper.GetILGenerator().AsInterface();
int argIndex = 0;
if (this_ != null)
{
if (this_.IsValueType)
{
// Struct;
gen.Ldarga_S((byte)argIndex++);
}
else
{
// Class; ref Struct;
gen.Ldarg((byte)argIndex++);
}
}
for (int i = 0; i < methodArgs.Length; i++)
{
gen.Ldarg((byte)argIndex++);
}
gen
.Call(method)
.Ret();
return(wrapper.CreateDelegate(delegateType));
}
public ByRefClassILBuilder(IILGenerator gen, Type delegateArgType, Type methodArgType) : base(gen, delegateArgType, methodArgType)
{
elementType = methodArgType.GetElementType();
}
private static void AddMethodImplementation(TypeBuilder typeBuilder, Type interfaceType, MethodInfo methodInfo, FieldBuilder handlerFieldBuilder)
{
string methodName = $"{interfaceType.Name}.{methodInfo.Name}";
ParameterInfo[] parameters = methodInfo.GetParameters();
Type[] ParameterTypes = parameters.Select(p => p.ParameterType).ToArray();
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, Private | Final | HideBySig | NewSlot | Virtual, methodInfo.ReturnType, ParameterTypes);
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo parameter = parameters[i];
methodBuilder.DefineParameter(i + 1, parameter.Attributes, parameter.Name);
}
IILGenerator il = CreateILGenerator(methodBuilder.GetILGenerator());
LocalBuilder parametersLocal = il.DeclareLocal(typeof(object[]));
LocalBuilder resultLocal = il.DeclareLocal(typeof(object));
bool hasReturnValue = methodInfo.ReturnType == typeof(void);
int parametersLocalLength = parameters.Length;
il.Emit(Ldc_I4, parametersLocalLength);
il.Emit(Newarr, typeof(object));
il.Emit(Stloc, parametersLocal);
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo parameterInfo = parameters[i];
Type parameterType = parameterInfo.ParameterType;
TypeInfo parameterTypeInfo = parameterType.GetTypeInfo();
il.Emit(Ldloc, parametersLocal);
il.Emit(Ldc_I4, i);
il.Emit(Ldarg, i + 1);
if (parameterType.IsByRef)
{
Type elementType = parameterType.GetElementType();
TypeInfo elementTypeInfo = elementType.GetTypeInfo();
if (elementTypeInfo.IsClass)
{
il.Emit(Ldind_Ref);
}
else if (ldindOpCodes.TryGetValue(elementType, out var opCode))
{
il.Emit(opCode);
}
else
{
il.Emit(Ldobj, elementType);
}
}
else if (!parameterTypeInfo.IsClass)
{
il.Emit(Box, parameterType);
}
il.Emit(Stelem_Ref);
}
il.Emit(Ldarg_0);
il.Emit(Ldfld, handlerFieldBuilder);
il.Emit(Call, typeof(MethodBase).GetMethod(nameof(MethodBase.GetCurrentMethod)));
il.Emit(Ldloc, parametersLocal);
il.Emit(Callvirt, typeof(IProxyHandler).GetMethod(nameof(IProxyHandler.HandleMethod)));
il.Emit(Stloc, resultLocal);
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo parameterInfo = parameters[i];
Type parameterType = parameterInfo.ParameterType;
TypeInfo parameterTypeInfo = parameterType.GetTypeInfo();
if (parameterType.IsByRef)
{
Type elementType = parameterType.GetElementType();
TypeInfo elementTypeInfo = elementType.GetTypeInfo();
il.Emit(Ldarg, i + 1);
il.Emit(Ldloc, parametersLocal);
il.Emit(Ldc_I4, i);
il.Emit(Ldelem_Ref);
if (elementTypeInfo.IsClass)
{
il.Emit(Castclass, elementType);
il.Emit(Stind_Ref);
}
else
{
il.Emit(Unbox_Any, elementType);
if (stindOpCodes.TryGetValue(elementType, out var opCode))
{
il.Emit(opCode);
}
else
{
il.Emit(Stobj, elementType);
}
}
}
}
if (methodInfo.ReturnType != typeof(void))
{
il.Emit(Ldloc, resultLocal);
if (!methodInfo.ReturnType.GetTypeInfo().IsClass)
{
il.Emit(Unbox_Any, methodInfo.ReturnType);
}
}
il.Emit(Ret);
typeBuilder.DefineMethodOverride(methodBuilder, methodInfo);
}
public MethodWriter(ConstructorBuilder cb, MethodInstance method, StringBuilder sb)
{
this.gen = new TraceILGenerator(cb.GetILGenerator(), sb);
this.method = method;
}
public static IILGenerator Ldarg_S(this IILGenerator gen, byte index)
{
gen.Emit(OpCodes.Ldarg_S, index); return(gen);
}
