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