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