private AnalysisNet.IInstruction ProcessStoreLocal(Cecil.Cil.Instruction op)
{
int localIdx = -1;
Cecil.Cil.VariableDefinition variable = null;
switch (op.OpCode.Code)
{
case Mono.Cecil.Cil.Code.Stloc_S:
case Mono.Cecil.Cil.Code.Stloc: variable = (Cecil.Cil.VariableDefinition)op.Operand; break;
case Mono.Cecil.Cil.Code.Stloc_0: localIdx = 0; break;
case Mono.Cecil.Cil.Code.Stloc_1: localIdx = 1; break;
case Mono.Cecil.Cil.Code.Stloc_2: localIdx = 2; break;
case Mono.Cecil.Cil.Code.Stloc_3: localIdx = 3; break;
default:
throw new NotImplementedException();
}
AnalysisNetTac.Values.IVariable dest;
if (variable != null)
{
dest = locals[variable.Index];
}
else
{
dest = locals[localIdx];
}
AnalysisNetBytecode.StoreInstruction instruction = new AnalysisNetBytecode.StoreInstruction((uint)op.Offset, dest);
return(instruction);
}
private void IncrementUseCount(Mono.Cecil.Cil.VariableDefinition register)
{
int count;
if (!registerUseCounters.TryGetValue(register, out count))
{
count = 0;
}
count++;
registerUseCounters[register] = count;
}
private string GetLocalSourceName(Cecil.Cil.VariableDefinition local)
{
//var name = local.Name.Value;
string name = local.ToString();
//if (sourceLocationProvider != null)
//{
// bool isCompilerGenerated;
// name = sourceLocationProvider.GetSourceNameFor(local, out isCompilerGenerated);
//}
return(name);
}
private IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.Cil.VariableDefinition> CreateLocalVariables(Model.Types.MethodDefinition methodDefinition, Mono.Cecil.MethodDefinition methodDef)
{
IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.Cil.VariableDefinition> variableDefinitions = new Dictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.Cil.VariableDefinition>();
foreach (AnalysisNet.ThreeAddressCode.Values.IVariable localVariable in methodDefinition.Body.LocalVariables)
{
Cecil.Cil.VariableDefinition varDef = new Cecil.Cil.VariableDefinition(ReferenceGenerator.TypeReference(localVariable.Type));
methodDef.Body.Variables.Add(varDef);
variableDefinitions[localVariable] = varDef;
}
return(variableDefinitions);
}
public static Thread.ReaderWriterLockSlim GetLock(object instance)
{
Thread.ReaderWriterLockSlim @lock;
instance = instance ?? StaticInstance;
if (!Locks.TryGetValue(instance, out @lock))
{
@lock = Locks[instance] = new Thread.ReaderWriterLockSlim();
}
return(@lock);
}
/// <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)
{
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);
}
private AnalysisNet.IInstruction ProcessLoadLocal(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.LoadOperation operation = OperationHelper.ToLoadOperation(op.OpCode.Code);
AnalysisNetTac.Values.IVariable source = null;
int localIdx = -1;
switch (op.OpCode.Code)
{
case Mono.Cecil.Cil.Code.Ldloc_0: localIdx = 0; break;
case Mono.Cecil.Cil.Code.Ldloc_1: localIdx = 1; break;
case Mono.Cecil.Cil.Code.Ldloc_2: localIdx = 2; break;
case Mono.Cecil.Cil.Code.Ldloc_3: localIdx = 3; break;
case Mono.Cecil.Cil.Code.Ldloc_S:
case Mono.Cecil.Cil.Code.Ldloca_S:
case Mono.Cecil.Cil.Code.Ldloc:
case Mono.Cecil.Cil.Code.Ldloca:
Cecil.Cil.VariableDefinition varDef = (Cecil.Cil.VariableDefinition)op.Operand;
source = locals[varDef.Index]; break;
default:
throw new NotImplementedException();
}
if (localIdx > -1)
{
source = locals[localIdx];
}
AnalysisNetBytecode.LoadInstruction instruction = new AnalysisNetBytecode.LoadInstruction((uint)op.Offset, operation, source);
return(instruction);
}
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 (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;
}
}
void EmitInstruction(ILGenerator il, OpCode opcode, Cecil.Cil.VariableDefinition operand)
{
il.Emit(opcode, operand.Index);
}
protected override void Visit(Mono.Cecil.Cil.VariableDefinition variableDefinition, Context context)
{
Touch(variableDefinition);
base.Visit(variableDefinition, context);
}
protected override bool ShouldInlineAggressively(Mono.Cecil.Cil.VariableDefinition variable)
{
return(true);
}
