private void ExtractParameters(Cecil.MethodDefinition methoddef, IList <AnalysisNetTac.Values.IVariable> ourParameters)
{
if (!methoddef.IsStatic)
{
AnalysisNet.Types.IType type = typeExtractor.ExtractType(methoddef.DeclaringType);
AnalysisNetTac.Values.LocalVariable v = new AnalysisNetTac.Values.LocalVariable("this", true)
{
Type = type
};
ourParameters.Add(v);
thisParameter = v;
}
foreach (Cecil.ParameterDefinition parameter in methoddef.Parameters)
{
AnalysisNet.Types.IType type = typeExtractor.ExtractType(parameter.ParameterType);
AnalysisNetTac.Values.LocalVariable v = new AnalysisNetTac.Values.LocalVariable(parameter.Name, true)
{
Type = type
};
ourParameters.Add(v);
parameters.Add(parameter.Index, v);
}
}
private AnalysisNet.IInstruction ProcessStoreArgument(Cecil.Cil.Instruction op)
{
AnalysisNetTac.Values.IVariable dest = thisParameter;
if (op.Operand is Cecil.ParameterDefinition parameter)
{
dest = parameters[parameter.Index];
}
AnalysisNetBytecode.StoreInstruction instruction = new AnalysisNetBytecode.StoreInstruction((uint)op.Offset, dest);
return(instruction);
}
private AnalysisNet.IInstruction ProcessLoadArgument(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.LoadOperation operation = OperationHelper.ToLoadOperation(op.OpCode.Code);
AnalysisNetTac.Values.IVariable source = thisParameter;
int argIdx = -1;
switch (op.OpCode.Code)
{
case Mono.Cecil.Cil.Code.Ldarg_0: argIdx = 0; break;
case Mono.Cecil.Cil.Code.Ldarg_1: argIdx = 1; break;
case Mono.Cecil.Cil.Code.Ldarg_2: argIdx = 2; break;
case Mono.Cecil.Cil.Code.Ldarg_3: argIdx = 3; break;
}
if (argIdx > -1)
{
if (thisParameter != null && argIdx == 0)
{
source = thisParameter;
}
else
{
int hasThis = thisParameter != null ? 1 : 0;
source = parameters[argIdx - hasThis];
}
}
if (op.Operand is Cecil.ParameterDefinition)
{
Cecil.ParameterDefinition parameter = op.Operand as Cecil.ParameterDefinition;
source = parameters[parameter.Index];
}
if (source == null)
{
throw new Exception("source cannot be null.");
}
AnalysisNetBytecode.LoadInstruction instruction = new AnalysisNetBytecode.LoadInstruction((uint)op.Offset, operation, source);
return(instruction);
}
private IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.ParameterDefinition> CreateParameters(AnalysisNet.Types.MethodDefinition methodDefinition, Mono.Cecil.MethodDefinition methodDef)
{
IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.ParameterDefinition> parameterDefinitions = new Dictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.ParameterDefinition>();
for (int idx = 0; idx < methodDefinition.Parameters.Count; idx++)
{
AnalysisNet.Types.MethodParameter methodParameter = methodDefinition.Parameters.ElementAt(idx);
//if (methodParameter.Name.Equals("this"))
// continue;
Cecil.ParameterDefinition paramDef = new Cecil.ParameterDefinition(ReferenceGenerator.TypeReference(methodParameter.Type));
if (methodParameter.DefaultValue != null)
{
paramDef.Constant = methodParameter.DefaultValue.Value;
paramDef.HasDefault = true;
}
if (methodParameter.Kind == AnalysisNet.Types.MethodParameterKind.In)
{
paramDef.IsIn = true;
}
else if (methodParameter.Kind == AnalysisNet.Types.MethodParameterKind.Out)
{
paramDef.IsOut = true;
}
methodDef.Parameters.Add(paramDef);
// map body parameters to cecil parameters
if (methodDefinition.HasBody && methodDefinition.Body.Parameters.Count > 0)
{
// body parameters contain 'this' while analysis-net's parameters do not
int localIdx = (methodDefinition.IsStatic ? 0 : 1) + idx;
AnalysisNet.ThreeAddressCode.Values.IVariable localVariable = methodDefinition.Body.Parameters.ElementAt(localIdx);
parameterDefinitions[localVariable] = paramDef;
}
}
return(parameterDefinitions);
}
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);
}
public override void Visit(Model.Bytecode.LoadInstruction instruction)
{
Mono.Cecil.Cil.Instruction cilIns;
if (instruction.Operation == Model.Bytecode.LoadOperation.Content)
{
Contract.Assert(instruction.Operand is AnalysisNetTac.Values.IVariable);
AnalysisNetTac.Values.IVariable variable = instruction.Operand as AnalysisNetTac.Values.IVariable;
if (variable.IsParameter)
{
if (variable.Name != "this")
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldarg, parameterDefinitions[variable]);
}
else
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldarg, 0);
}
}
else
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldloc, variableDefinitions[variable]);
}
}
else if (instruction.Operation == Model.Bytecode.LoadOperation.Value)
{
if (instruction.Operand is AnalysisNetTac.Values.Constant constant)
{
if (constant.Value is sbyte asSbyte)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldc_I4_S, asSbyte);
}
else if (constant.Value is byte asByte)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldc_I4, asByte);
}
else if (constant.Value is int asInt)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldc_I4, asInt);
}
else if (constant.Value is long asLong)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldc_I8, asLong);
}
else if (constant.Value is float asFloat)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldc_R4, asFloat);
}
else if (constant.Value is double asDouble)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldc_R8, asDouble);
}
else if (constant.Value is string asString)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldstr, asString);
}
else if (constant.Value == null)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldnull);
}
else
{
throw new NotImplementedException();
}
}
else if (instruction.Operand is AnalysisNetTac.Values.IVariable variable)
{
throw new NotImplementedException();
}
else if (instruction.Operand is AnalysisNetTac.Values.UnknownValue unk)
{
throw new NotImplementedException();
}
else
{
throw new NotImplementedException();
}
}
else if (instruction.Operation == Model.Bytecode.LoadOperation.Address)
{
if (instruction.Operand is AnalysisNetTac.Values.IVariable variable)
{
if (variable.IsParameter)
{
if (variable.Name != "this")
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldarga, parameterDefinitions[variable]);
}
else
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldarga, 0);
}
}
else
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldloca, variableDefinitions[variable]);
}
}
else
{
throw new NotImplementedException();
}
}
else
{
throw new NotImplementedException();
}
Result = new List <Mono.Cecil.Cil.Instruction>()
{
cilIns
};
}
