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