private AnalysisNet.IInstruction ProcessMethodCall(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.MethodCallOperation operation = OperationHelper.ToMethodCallOperation(op.OpCode.Code);
Cecil.MethodReference cciMethod = op.Operand as Cecil.MethodReference;
AnalysisNet.Types.IMethodReference ourMethod = typeExtractor.ExtractMethod(cciMethod);
AnalysisNet.IInstruction instruction;
if (ourMethod.ContainingType is FakeArrayType fakeArrayType)
{
AnalysisNet.Types.ArrayType arrayType = fakeArrayType.Type;
if (ourMethod.Name == "Set")
{
instruction = ProcessStoreArrayElement(op, arrayType);
return(instruction);
}
else
{
AnalysisNetBytecode.LoadArrayElementOperation arrayOp = OperationHelper.ToLoadArrayElementOperation(ourMethod.Name);
instruction = ProcessLoadArrayElement(op, arrayOp, arrayType);
return(instruction);
}
}
instruction = new AnalysisNetBytecode.MethodCallInstruction((uint)op.Offset, operation, ourMethod);
return(instruction);
}
private AnalysisNet.IInstruction ProcessLoadArrayElement(Cecil.Cil.Instruction op, AnalysisNetBytecode.LoadArrayElementOperation operation)
{
AnalysisNet.Types.ArrayType arrayType = null;
switch (op.OpCode.Code)
{
/*case Mono.Cecil.Cil.Code.Array_Addr:
* case Mono.Cecil.Cil.Code.Array_Create:
* case Mono.Cecil.Cil.Code.Array_Create_WithLowerBound:
* case Mono.Cecil.Cil.Code.Array_Get:
* case Mono.Cecil.Cil.Code.Array_Set:
* arrayType = typeExtractor.ExtractType(op.Operand as Cecil.TypeReference) as ArrayType;
* break;*/
//case Mono.Cecil.Cil.Code.Ldelem:
case Mono.Cecil.Cil.Code.Ldelem_Any:
case Mono.Cecil.Cil.Code.Ldelema:
arrayType = new AnalysisNet.Types.ArrayType(typeExtractor.ExtractType(op.Operand as Cecil.TypeReference));
break;
default:
arrayType = new AnalysisNet.Types.ArrayType(OperationHelper.GetOperationType(op.OpCode.Code));
break;
}
if (arrayType == null)
{
throw new NotImplementedException();
}
AnalysisNetBytecode.LoadArrayElementInstruction instruction = new AnalysisNetBytecode.LoadArrayElementInstruction((uint)op.Offset, operation, arrayType);
return(instruction);
}
private AnalysisNet.IInstruction ProcessStoreArrayElement(Cecil.Cil.Instruction op)
{
AnalysisNet.Types.ArrayType arrayType = null;
switch (op.OpCode.Code)
{
//case Mono.Cecil.Cil.Code.Array_Set:
// arrayType = typeExtractor.ExtractType(op.Operand as Cecil.TypeReference) as ArrayType;
// break;
//case Mono.Cecil.Cil.Code.Stelem:
case Mono.Cecil.Cil.Code.Stelem_Any:
AnalysisNet.Types.IType extractedType = typeExtractor.ExtractType(op.Operand as Cecil.TypeReference);
arrayType = new AnalysisNet.Types.ArrayType(extractedType);
break;
default:
arrayType = new AnalysisNet.Types.ArrayType(OperationHelper.GetOperationType(op.OpCode.Code));
break;
}
if (arrayType == null)
{
throw new NotImplementedException();
}
AnalysisNetBytecode.StoreArrayElementInstruction instruction = new AnalysisNetBytecode.StoreArrayElementInstruction((uint)op.Offset, arrayType);
return(instruction);
}
private AnalysisNet.IInstruction ProcessConversion(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.ConvertOperation operation = OperationHelper.ToConvertOperation(op.OpCode.Code);
bool overflow = OperationHelper.PerformsOverflowCheck(op.OpCode.Code);
bool unsigned = OperationHelper.OperandsAreUnsigned(op.OpCode.Code);
Cecil.TypeReference cciType = op.Operand as Cecil.TypeReference;
AnalysisNet.Types.IType ourType = OperationHelper.GetOperationType(op.OpCode.Code);
if (operation == AnalysisNetBytecode.ConvertOperation.Box)
{
ourType = typeExtractor.ExtractType(cciType);
}
else if (operation == AnalysisNetBytecode.ConvertOperation.Conv)
{
ourType = OperationHelper.GetOperationType(op.OpCode.Code);
}
else if (operation == AnalysisNetBytecode.ConvertOperation.Cast)
{
ourType = typeExtractor.ExtractType(op.Operand as Cecil.TypeReference);
}
AnalysisNetBytecode.ConvertInstruction instruction = new AnalysisNetBytecode.ConvertInstruction((uint)op.Offset, operation, ourType)
{
OverflowCheck = overflow,
UnsignedOperands = unsigned
};
return(instruction);
}
private AnalysisNet.IInstruction ProcessUnaryConditionalBranch(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.BranchOperation operation = OperationHelper.ToBranchOperation(op.OpCode.Code);
uint target = (uint)((Cecil.Cil.Instruction)op.Operand).Offset;
AnalysisNetBytecode.BranchInstruction instruction = new AnalysisNetBytecode.BranchInstruction((uint)op.Offset, operation, target);
return(instruction);
}
private AnalysisNet.IInstruction ProcessLoadMethodAddress(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.LoadMethodAddressOperation operation = OperationHelper.ToLoadMethodAddressOperation(op.OpCode.Code);
Cecil.MethodReference cciMethod = op.Operand as Cecil.MethodReference;
AnalysisNet.Types.IMethodReference ourMethod = typeExtractor.ExtractMethod(cciMethod);
AnalysisNetBytecode.LoadMethodAddressInstruction instruction = new AnalysisNetBytecode.LoadMethodAddressInstruction((uint)op.Offset, operation, ourMethod);
return(instruction);
}
private AnalysisNet.IInstruction ProcessStoreIndirect(Cecil.Cil.Instruction op)
{
AnalysisNet.Types.IType type = OperationHelper.GetOperationType(op.OpCode.Code);
if (op.OpCode.Code == Mono.Cecil.Cil.Code.Stobj)
{
type = typeExtractor.ExtractType(op.Operand as Cecil.TypeReference);
}
AnalysisNetBytecode.StoreIndirectInstruction instruction = new AnalysisNetBytecode.StoreIndirectInstruction((uint)op.Offset, type);
return(instruction);
}
private AnalysisNet.IInstruction ProcessLoadField(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.LoadFieldOperation operation = OperationHelper.ToLoadFieldOperation(op.OpCode.Code);
Cecil.FieldReference cciField = op.Operand as Cecil.FieldReference;
bool isStatic = op.OpCode.Code == Cecil.Cil.OpCodes.Ldsfld.Code || op.OpCode.Code == Cecil.Cil.OpCodes.Ldsflda.Code;
AnalysisNet.Types.FieldReference ourField = typeExtractor.ExtractField(cciField, isStatic);
AnalysisNetBytecode.LoadFieldInstruction instruction = new AnalysisNetBytecode.LoadFieldInstruction((uint)op.Offset, operation, ourField);
return(instruction);
}
private AnalysisNet.IInstruction ProcessBasic(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.BasicOperation operation = OperationHelper.ToBasicOperation(op.OpCode.Code);
bool overflow = OperationHelper.PerformsOverflowCheck(op.OpCode.Code);
bool unsigned = OperationHelper.OperandsAreUnsigned(op.OpCode.Code);
AnalysisNetBytecode.BasicInstruction instruction = new AnalysisNetBytecode.BasicInstruction((uint)op.Offset, operation)
{
OverflowCheck = overflow,
UnsignedOperands = unsigned
};
return(instruction);
}
private AnalysisNet.IInstruction ProcessLoadConstant(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.LoadOperation operation = OperationHelper.ToLoadOperation(op.OpCode.Code);
AnalysisNet.Types.IType type = OperationHelper.GetOperationType(op.OpCode.Code);
object value = OperationHelper.GetOperationConstant(op);
AnalysisNetTac.Values.Constant source = new AnalysisNetTac.Values.Constant(value)
{
Type = type
};
AnalysisNetBytecode.LoadInstruction instruction = new AnalysisNetBytecode.LoadInstruction((uint)op.Offset, operation, source);
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 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);
}
