public ParameterInfo(IReflectionInfoFactory reflectionInfoFactory, Mono.Cecil.ParameterDefinition parameter) { Name = parameter.Name; _attributes = parameter.CustomAttributes .Select(reflectionInfoFactory.GetInfo).ToArray(); _type = reflectionInfoFactory.GetReference(parameter.ParameterType); }
public ILRuntimeParameterInfo(Mono.Cecil.ParameterDefinition definition, IType type, MethodBase method) { this.type = type; this.method = method; this.MemberImpl = method; this.definition = definition; NameImpl = definition.Name; }
static ICLRType GetTType(ICLRSharp_Environment env, Mono.Cecil.ParameterDefinition param, MethodParamList _methodgen) { string typename = param.ParameterType.FullName; for (int i = 0; i < _methodgen.Count; i++) { string p = "!!" + i.ToString(); typename = typename.Replace(p, _methodgen[i].FullName); } return(env.GetType(typename)); }
public ILRuntimeParameterInfo(Mono.Cecil.ParameterDefinition definition, IType type, MemberInfo member, ILRuntime.Runtime.Enviorment.AppDomain appdomain) { this.IType = type; this.definition = definition; this.AppDomain = appdomain; AttrsImpl = (ParameterAttributes)definition.Attributes; ClassImpl = type.ReflectionType; DefaultValueImpl = definition.Constant; MemberImpl = member; NameImpl = definition.Name; PositionImpl = definition.Index; }
private static IParameter Convert(this Mono.Cecil.ParameterDefinition parameter, int sequence) { var writableParameter = MetadataFactory.InitializeParameter( parameter.Name, parameter.ParameterType.FullName, sequence); if (parameter.HasCustomAttributes) { for (var i = 0; i < parameter.CustomAttributes.Count; i++) { writableParameter.AddCustomAttribute(Convert(parameter.CustomAttributes[i], i)); } } return(writableParameter.Build()); }
/// <summary> /// Aspect code to inject at the end of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void EndBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { il.BeginFinallyBlock(); il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, @lock); il.Emit(Mono.Cecil.Cil.OpCodes.Callvirt, ExitMethod); il.EndExceptionBlock(); }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { var isSetProperty = method.Name.StartsWith("set_") && !method.IsStatic; if (!isSetProperty) { return; } il.Emit(Mono.Cecil.Cil.OpCodes.Ldarg_0); il.Emit(Mono.Cecil.Cil.OpCodes.Call, ThrowIfFrozenMethod); }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { }
unsafe void InitToken(ref OpCode code, object token, Dictionary <Mono.Cecil.Cil.Instruction, int> addr) { switch (code.Code) { case OpCodeEnum.Leave: case OpCodeEnum.Leave_S: case OpCodeEnum.Br: case OpCodeEnum.Br_S: case OpCodeEnum.Brtrue: case OpCodeEnum.Brtrue_S: case OpCodeEnum.Brfalse: case OpCodeEnum.Brfalse_S: //比较流程控制 case OpCodeEnum.Beq: case OpCodeEnum.Beq_S: case OpCodeEnum.Bne_Un: case OpCodeEnum.Bne_Un_S: case OpCodeEnum.Bge: case OpCodeEnum.Bge_S: case OpCodeEnum.Bge_Un: case OpCodeEnum.Bge_Un_S: case OpCodeEnum.Bgt: case OpCodeEnum.Bgt_S: case OpCodeEnum.Bgt_Un: case OpCodeEnum.Bgt_Un_S: case OpCodeEnum.Ble: case OpCodeEnum.Ble_S: case OpCodeEnum.Ble_Un: case OpCodeEnum.Ble_Un_S: case OpCodeEnum.Blt: case OpCodeEnum.Blt_S: case OpCodeEnum.Blt_Un: case OpCodeEnum.Blt_Un_S: code.TokenInteger = addr[(Mono.Cecil.Cil.Instruction)token]; break; case OpCodeEnum.Ldc_I4: code.TokenInteger = (int)token; break; case OpCodeEnum.Ldc_I4_S: code.TokenInteger = (sbyte)token; break; case OpCodeEnum.Ldc_I8: code.TokenLong = (long)token; break; case OpCodeEnum.Ldc_R4: { float val = (float)token; code.TokenInteger = *(int *)&val; } break; case OpCodeEnum.Ldc_R8: { double val = (double)token; code.TokenLong = *(long *)&val; } break; case OpCodeEnum.Stloc: case OpCodeEnum.Stloc_S: case OpCodeEnum.Ldloc: case OpCodeEnum.Ldloc_S: case OpCodeEnum.Ldloca: case OpCodeEnum.Ldloca_S: { Mono.Cecil.Cil.VariableDefinition vd = (Mono.Cecil.Cil.VariableDefinition)token; code.TokenInteger = vd.Index; } break; case OpCodeEnum.Ldarg_S: case OpCodeEnum.Ldarg: case OpCodeEnum.Ldarga: case OpCodeEnum.Ldarga_S: case OpCodeEnum.Starg: case OpCodeEnum.Starg_S: { Mono.Cecil.ParameterDefinition vd = (Mono.Cecil.ParameterDefinition)token; code.TokenInteger = vd.Index; if (HasThis) { code.TokenInteger++; } } break; case OpCodeEnum.Call: case OpCodeEnum.Newobj: case OpCodeEnum.Ldftn: case OpCodeEnum.Ldvirtftn: case OpCodeEnum.Callvirt: { bool invalidToken; var m = appdomain.GetMethod(token, declaringType, this, out invalidToken); if (m != null) { if (code.Code == OpCodeEnum.Callvirt && m is ILMethod) { ILMethod ilm = (ILMethod)m; if (!ilm.def.IsAbstract && !ilm.def.IsVirtual && !ilm.DeclearingType.IsInterface) { code.Code = OpCodeEnum.Call; } } if (invalidToken) { code.TokenInteger = m.GetHashCode(); } else { code.TokenInteger = token.GetHashCode(); } } else { //Cannot find method or the method is dummy MethodReference _ref = (MethodReference)token; int paramCnt = _ref.HasParameters ? _ref.Parameters.Count : 0; if (_ref.HasThis) { paramCnt++; } code.TokenLong = paramCnt; } } break; case OpCodeEnum.Constrained: case OpCodeEnum.Box: case OpCodeEnum.Unbox_Any: case OpCodeEnum.Unbox: case OpCodeEnum.Initobj: case OpCodeEnum.Isinst: case OpCodeEnum.Newarr: case OpCodeEnum.Stobj: case OpCodeEnum.Ldobj: { code.TokenInteger = GetTypeTokenHashCode(token); } break; case OpCodeEnum.Stfld: case OpCodeEnum.Ldfld: case OpCodeEnum.Ldflda: { code.TokenLong = appdomain.GetStaticFieldIndex(token, declaringType, this); } break; case OpCodeEnum.Stsfld: case OpCodeEnum.Ldsfld: case OpCodeEnum.Ldsflda: { code.TokenLong = appdomain.GetStaticFieldIndex(token, declaringType, this); } break; case OpCodeEnum.Ldstr: { long hashCode = appdomain.CacheString(token); code.TokenLong = hashCode; } break; case OpCodeEnum.Ldtoken: { if (token is FieldReference) { code.TokenInteger = 0; code.TokenLong = appdomain.GetStaticFieldIndex(token, declaringType, this); } else if (token is TypeReference) { code.TokenInteger = 1; code.TokenLong = GetTypeTokenHashCode(token); } else { throw new NotImplementedException(); } } break; case OpCodeEnum.Switch: { PrepareJumpTable(token, addr); code.TokenInteger = token.GetHashCode(); } break; } }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { field = method.DeclaringType.DefineField("<unsafe>_" + method.Name, typeof(int), Mono.Cecil.FieldAttributes.Static | Mono.Cecil.FieldAttributes.Private); var notZero = il.DefineLabel(); il.Emit(Mono.Cecil.Cil.OpCodes.Ldsfld, field); il.Emit(Mono.Cecil.Cil.OpCodes.Brfalse, notZero); il.Emit(Mono.Cecil.Cil.OpCodes.Newobj, typeof(ConcurrentAccessException).GetConstructor(Type.EmptyTypes)); il.Emit(Mono.Cecil.Cil.OpCodes.Throw); il.MarkLabel(notZero); il.Emit(Mono.Cecil.Cil.OpCodes.Ldsfld, field); il.Emit(Mono.Cecil.Cil.OpCodes.Ldc_I4_1); il.Emit(Mono.Cecil.Cil.OpCodes.Add); il.Emit(Mono.Cecil.Cil.OpCodes.Stsfld, field); }
/// <summary> /// Aspect code to inject at the end of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void EndBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { il.Emit(Mono.Cecil.Cil.OpCodes.Ldsfld, field); il.Emit(Mono.Cecil.Cil.OpCodes.Ldc_I4_1); il.Emit(Mono.Cecil.Cil.OpCodes.Sub); il.Emit(Mono.Cecil.Cil.OpCodes.Stsfld, field); }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { var meth = method; var returnType = meth.ReturnType.ReflectionType(); @lock = il.DeclareLocal(typeof(Thread.ReaderWriterLockSlim)); il.Emit(method.IsStatic ? Mono.Cecil.Cil.OpCodes.Ldnull : Mono.Cecil.Cil.OpCodes.Ldarg_0); il.Emit(Mono.Cecil.Cil.OpCodes.Call, GetLockMethod); il.Emit(Mono.Cecil.Cil.OpCodes.Stloc, @lock); il.BeginExceptionBlock(); il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, @lock); il.Emit(Mono.Cecil.Cil.OpCodes.Callvirt, EnterMethod); }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { if (method.IsStatic) { return; } if (method.IsConstructor) { il.Emit(Mono.Cecil.Cil.OpCodes.Ldarg_0); il.Emit(Mono.Cecil.Cil.OpCodes.Call, typeof(ThreadAffinityAttribute).GetMethod("SetInstanceThread")); return; } il.Emit(Mono.Cecil.Cil.OpCodes.Ldarg_0); il.Emit(Mono.Cecil.Cil.OpCodes.Call, typeof(ThreadAffinityAttribute).GetMethod("ThrowIfInstanceThreadNotMatch")); }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { var aspectType = this.GetType(); var hasExLabel = il.DefineLabel(); var exceptionLocal = il.DeclareLocal(typeof(Exception)); var offset = method.IsStatic ? 0 : 1; var paraMethod = method; var parameterType = parameter.ParameterType; var parameterDeclaringType = paraMethod.DeclaringType; var aspect = parameter.GetCustomAttribute(aspectType); if (aspect == null) { return; } var aspectField = ILWeaver.TypeFieldAspects[parameterDeclaringType.FullName][aspectType.FullName]; il.Emit(Mono.Cecil.Cil.OpCodes.Ldsfld, aspectField); il.Emit(Mono.Cecil.Cil.OpCodes.Ldarg, parameter.Index + offset); if (parameterType.IsValueType) { il.Emit(Mono.Cecil.Cil.OpCodes.Box, parameterType); } il.Emit(Mono.Cecil.Cil.OpCodes.Ldstr, parameter.Name); il.Emit(Mono.Cecil.Cil.OpCodes.Ldc_I4_1); il.Emit(Mono.Cecil.Cil.OpCodes.Ldtoken, paraMethod); il.Emit(Mono.Cecil.Cil.OpCodes.Call, typeof(MethodBase).GetMethod("GetMethodFromHandle", new Type[] { typeof(RuntimeMethodHandle) })); il.Emit(Mono.Cecil.Cil.OpCodes.Isinst, typeof(MethodInfo)); il.Emit(Mono.Cecil.Cil.OpCodes.Ldc_I4, parameter.Index); il.Emit(Mono.Cecil.Cil.OpCodes.Call, GetParameterContractAspectMethod); il.Emit(Mono.Cecil.Cil.OpCodes.Callvirt, ValidateContractMethod); il.Emit(Mono.Cecil.Cil.OpCodes.Stloc, exceptionLocal); il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, exceptionLocal); il.Emit(Mono.Cecil.Cil.OpCodes.Brfalse, hasExLabel); il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, exceptionLocal); il.Emit(Mono.Cecil.Cil.OpCodes.Throw); il.MarkLabel(hasExLabel); }
/// <summary> /// Aspect code to inject at the end of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void EndBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { var meth = method; var module = typeBuilder.Module; var returnType = meth.ReturnType.ReflectionType(); if (returnType == typeof(void) || !(meth.Name.StartsWith("get_") || meth.Parameters.Count == 0)) { return; } var isPrimitive = returnType.IsPrimitive(); var isStatic = method.IsStatic; if (autoField != null) { //var local = il.DeclareLocal(returnType); //il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, 0); //il.Emit(Mono.Cecil.Cil.OpCodes.Stloc, local); if (!isStatic) { il.Emit(Mono.Cecil.Cil.OpCodes.Ldarg_0); } il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, 0); if (isPrimitive) { il.Emit(Mono.Cecil.Cil.OpCodes.Newobj, typeof(Nullable <>).MakeGenericType(returnType) .GetConstructor(new Type[] { returnType })); } il.Emit(isStatic ? Mono.Cecil.Cil.OpCodes.Stsfld : Mono.Cecil.Cil.OpCodes.Stfld, autoField); } il.MarkLabel(autoLabel); if (autoField != null) { if (!isStatic) { il.Emit(Mono.Cecil.Cil.OpCodes.Ldarg_0); } il.Emit(isStatic ? Mono.Cecil.Cil.OpCodes.Ldsflda : Mono.Cecil.Cil.OpCodes.Ldflda, autoField); if (isPrimitive) { returnType = typeof(Nullable <>).MakeGenericType(returnType); il.Emit(Mono.Cecil.Cil.OpCodes.Call, module.Import(returnType.GetMethod("get_Value"))); } il.Emit(Mono.Cecil.Cil.OpCodes.Stloc, 0); } }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { var meth = method; var module = typeBuilder.Module; var returnType = meth.ReturnType.ReflectionType(); if (returnType == typeof(void) || !(meth.Name.StartsWith("get_") || meth.Parameters.Count == 0)) { return; } var isStatic = meth.IsStatic; var isPrimitive = returnType.IsPrimitive(); if (isPrimitive) { returnType = typeof(Nullable <>).MakeGenericType(returnType); } autoField = method.DeclaringType.DefineField("<auto_lazy>_" + meth.Name, returnType, isStatic ? Mono.Cecil.FieldAttributes.Static | Mono.Cecil.FieldAttributes.Private : Mono.Cecil.FieldAttributes.Private); autoLabel = il.DefineLabel(); if (!isStatic) { il.Emit(Mono.Cecil.Cil.OpCodes.Ldarg_0); } il.Emit(isStatic ? Mono.Cecil.Cil.OpCodes.Ldsflda : Mono.Cecil.Cil.OpCodes.Ldflda, autoField); if (isPrimitive) { il.Emit(Mono.Cecil.Cil.OpCodes.Call, module.Import(returnType.GetMethod("get_HasValue"))); } il.Emit(isPrimitive ? Mono.Cecil.Cil.OpCodes.Brtrue : Mono.Cecil.Cil.OpCodes.Brfalse, autoLabel); }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { var meth = method; lockWasTokenLocal = il.DeclareLocal(typeof(bool)); tempLocal = il.DeclareLocal(typeof(object)); il.Emit(method.IsStatic ? Mono.Cecil.Cil.OpCodes.Ldnull : Mono.Cecil.Cil.OpCodes.Ldarg_0); il.Emit(Mono.Cecil.Cil.OpCodes.Call, GetLockObjectMethod); il.Emit(Mono.Cecil.Cil.OpCodes.Stloc, tempLocal); il.BeginExceptionBlock(); il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, tempLocal); il.Emit(Mono.Cecil.Cil.OpCodes.Ldloca, lockWasTokenLocal); il.Emit(Mono.Cecil.Cil.OpCodes.Call, EnterMethod); }
/// <summary> /// Aspect code to inject at the end of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void EndBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { il.BeginFinallyBlock(); var takenLabel = il.DefineLabel(); il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, lockWasTokenLocal); il.Emit(Mono.Cecil.Cil.OpCodes.Brfalse, takenLabel); il.Emit(Mono.Cecil.Cil.OpCodes.Ldloc, tempLocal); il.Emit(Mono.Cecil.Cil.OpCodes.Call, ExitMethod); il.MarkLabel(takenLabel); il.EndExceptionBlock(); }
/// <summary> /// Aspect code to inject at the beginning of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void BeginBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { var methodName = method.Name; var isSetProperty = methodName.StartsWith("set_") && !method.IsStatic; if (!isSetProperty) { return; } il.Emit(Mono.Cecil.Cil.OpCodes.Ldstr, methodName.Substring(4)); il.Emit(Mono.Cecil.Cil.OpCodes.Newobj, typeof(ObjectReadOnlyException).GetConstructor(new[] { typeof(string) })); il.Emit(Mono.Cecil.Cil.OpCodes.Throw); }
/// <summary> /// Aspect code to inject at the end of weaved method /// </summary> /// <param name="typeBuilder">Type Builder</param> /// <param name="method">Method</param> /// <param name="parameter">Parameter</param> /// <param name="il">ILGenerator</param> internal void EndBlock(Mono.Cecil.TypeDefinition typeBuilder, Mono.Cecil.MethodDefinition method, Mono.Cecil.ParameterDefinition parameter, Mono.Cecil.Cil.ILProcessor il) { il.BeginCatchBlock(typeof(System.Exception)); il.EndExceptionBlock(); }