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); } }
public AnalysisNet.Types.IMethodReference ExtractMethod(Cecil.MethodReference methodReference) { return(performanceCache.GetOrCreate(methodReference, (cacheEntry) => { if (methodReference is Cecil.GenericInstanceMethod instanceMethod) { List <AnalysisNet.Types.IType> genericArguments = new List <AnalysisNet.Types.IType>(); foreach (Cecil.TypeReference typeParameterref in instanceMethod.GenericArguments) { AnalysisNet.Types.IType typeArgumentref = ExtractType(typeParameterref); genericArguments.Add(typeArgumentref); } AnalysisNet.Types.IMethodReference method = ExtractMethod(instanceMethod.GetElementMethod()); AnalysisNet.Types.MethodReference instantiatedMethod = AnalysisNet.Extensions.Instantiate(method, genericArguments); instantiatedMethod.Resolve(host); return instantiatedMethod; } else { return ExtractNonGenericInstanceMethod(methodReference); } })); }
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.Types.ArrayType ExtractType(Cecil.ArrayType typeref) { AnalysisNet.Types.IType elements = ExtractType(typeref.ElementType); AnalysisNet.Types.ArrayType type = new AnalysisNet.Types.ArrayType(elements, (uint)typeref.Rank); return(type); }
private AnalysisNet.Types.IMethodReference ExtractNonGenericInstanceMethod(Cecil.MethodReference methodref) { AnalysisNet.Types.IType extractedType = ExtractType(methodref.DeclaringType); AnalysisNet.Types.IBasicType containingType; if (extractedType is AnalysisNet.Types.ArrayType arrayType) { containingType = new FakeArrayType(arrayType); } else { containingType = (AnalysisNet.Types.IBasicType)extractedType; } AnalysisNet.Types.MethodReference method = new AnalysisNet.Types.MethodReference(methodref.Name, AnalysisNet.Types.PlatformType.Void); genericParameterExtractor.MapGenericParameters(methodref, method); method.ReturnType = ExtractType(methodref.ReturnType); ExtractParameters(method.Parameters, methodref.Parameters); method.GenericParameterCount = methodref.GenericParameters.Count(); method.ContainingType = containingType; method.IsStatic = !(methodref.HasThis || methodref.ExplicitThis); method.Resolve(host); return(method); }
private AnalysisNet.Types.PointerType ExtractType(Cecil.PointerType typeref) { AnalysisNet.Types.IType target = ExtractType(typeref.ElementType); AnalysisNet.Types.PointerType type = new AnalysisNet.Types.PointerType(target); return(type); }
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 ProcessSizeof(Cecil.Cil.Instruction op) { Cecil.TypeReference cciType = op.Operand as Cecil.TypeReference; AnalysisNet.Types.IType ourType = typeExtractor.ExtractType(cciType); AnalysisNetBytecode.SizeofInstruction instruction = new AnalysisNetBytecode.SizeofInstruction((uint)op.Offset, ourType); 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 void ExtractParameters(ICollection <AnalysisNet.Types.IMethodParameterReference> dest, IEnumerable <Cecil.ParameterDefinition> source) { foreach (Cecil.ParameterDefinition parameterref in source) { AnalysisNet.Types.IType type = ExtractType(parameterref.ParameterType); AnalysisNet.Types.MethodParameterReference parameter = new AnalysisNet.Types.MethodParameterReference((ushort)parameterref.Index, type) { Kind = GetMethodParameterKind(parameterref) }; dest.Add(parameter); } }
private AnalysisNet.Types.FunctionPointerType ExtractType(Cecil.FunctionPointerType typeref) { AnalysisNet.Types.IType returnType = ExtractType(typeref.ElementType); AnalysisNet.Types.FunctionPointerType type = new AnalysisNet.Types.FunctionPointerType(returnType); //ExtractCustomAttributes(type.Attributes, typeref.Attr); ExtractParameters(type.Parameters, typeref.Parameters); //type.IsStatic = typeref.IsStatic; type.IsStatic = !(typeref.HasThis || typeref.ExplicitThis); return(type); }
public AnalysisNet.Types.IType ExtractType(Cecil.TypeReference typeReference) { return(performanceCache.GetOrCreate(typeReference, (cacheEntry) => { AnalysisNet.Types.IType result = null; if (typeReference is Cecil.ArrayType arrayType) { result = ExtractType(arrayType); } else if (typeReference is Cecil.ByReferenceType byReferenceType) { result = ExtractType(byReferenceType); } else if (typeReference is Cecil.PointerType pointerType) { result = ExtractType(pointerType); } else if (typeReference is Cecil.GenericParameter genericParameterType) { result = ExtractType(genericParameterType); } else if (typeReference is Cecil.FunctionPointerType functionPointerType) { result = ExtractType(functionPointerType); } else if (typeReference is Cecil.GenericInstanceType genericInstanceType) { result = ExtractType(genericInstanceType); } else { // named type reference result = ExtractNonGenericInstanceType(typeReference); } if (result is AnalysisNet.Types.BasicType) { AnalysisNet.Types.BasicType basicType = result as AnalysisNet.Types.BasicType; basicType.Resolve(host); if (basicType.GenericType is AnalysisNet.Types.BasicType) { basicType = basicType.GenericType as AnalysisNet.Types.BasicType; basicType.Resolve(host); } } return result; })); }
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 void ExtractLocalVariables(IEnumerable <Cecil.Cil.VariableDefinition> cciLocalVariables, IList <AnalysisNetTac.Values.IVariable> ourLocalVariables) { foreach (Cecil.Cil.VariableDefinition local in cciLocalVariables) { string name = GetLocalSourceName(local); AnalysisNet.Types.IType type = typeExtractor.ExtractType(local.VariableType); AnalysisNetTac.Values.LocalVariable v = new AnalysisNetTac.Values.LocalVariable(name) { Type = type }; ourLocalVariables.Add(v); locals.Add(local.Index, v); } }
private void ExtractFields(AnalysisNet.Types.TypeDefinition containingType, IList <AnalysisNet.Types.FieldDefinition> dest, IEnumerable <Cecil.FieldDefinition> source) { foreach (Cecil.FieldDefinition fielddef in source) { string name = fielddef.Name; AnalysisNet.Types.IType type = ExtractType(fielddef.FieldType); AnalysisNet.Types.FieldDefinition field = new AnalysisNet.Types.FieldDefinition(name, type); byte[] newArray = new byte[fielddef.InitialValue.Length]; Array.Copy(fielddef.InitialValue, newArray, newArray.Length); field.InitialValue = newArray; ExtractCustomAttributes(field.Attributes, fielddef.CustomAttributes); field.Visibility = ExtractVisibilityKind(fielddef); field.IsStatic = fielddef.IsStatic; field.ContainingType = containingType; dest.Add(field); } }
public Cecil.TypeReference TypeReference(AnalysisNet.Types.IType type) { if (type is AnalysisNet.Types.IBasicType basicType) { return(TypeReference(basicType)); } if (type is AnalysisNet.Types.IGenericParameterReference iGenericParam) { return(TypeReference(iGenericParam)); } if (type is AnalysisNet.Types.FunctionPointerType functionPointerType) { var funcPtr = new Cecil.FunctionPointerType() { ReturnType = TypeReference(functionPointerType.ReturnType), HasThis = !functionPointerType.IsStatic, }; funcPtr.Parameters.AddRange(functionPointerType.Parameters.Select(p => new Cecil.ParameterDefinition(TypeReference(p.Type)))); return(funcPtr); } if (type is AnalysisNet.Types.PointerType pointerType) { // Mono.Cecil.PointerType is an unsafe reference return(new Cecil.ByReferenceType(TypeReference(pointerType.TargetType))); } if (type is AnalysisNet.Types.ArrayType arrayType) { return(Cecil.Rocks.TypeReferenceRocks.MakeArrayType(TypeReference(arrayType.ElementsType), (int)arrayType.Rank)); } if (type is AnalysisNet.Types.UnknownType unknownType) { throw new NotImplementedException(); } throw new NotImplementedException(); }
private void ExtractParameters(IList <AnalysisNet.Types.MethodParameter> dest, IEnumerable <Cecil.ParameterDefinition> source) { foreach (Cecil.ParameterDefinition parameterdef in source) { string name = parameterdef.Name; AnalysisNet.Types.IType type = ExtractType(parameterdef.ParameterType); AnalysisNet.Types.MethodParameter parameter = new AnalysisNet.Types.MethodParameter((ushort)parameterdef.Index, name, type); ExtractCustomAttributes(parameter.Attributes, parameterdef.CustomAttributes); if (parameterdef.HasConstant) { parameter.DefaultValue = new AnalysisNet.ThreeAddressCode.Values.Constant(parameterdef.Constant) { Type = parameter.Type }; } parameter.Kind = GetMethodParameterKind(parameterdef); dest.Add(parameter); } }
private void ExtractExceptionInformation(IEnumerable <Cecil.Cil.ExceptionHandler> cciExceptionInformation, IList <AnalysisNet.ProtectedBlock> ourExceptionInformation) { foreach (Cecil.Cil.ExceptionHandler cciExceptionInfo in cciExceptionInformation) { AnalysisNet.ProtectedBlock tryHandler = new AnalysisNet.ProtectedBlock((uint)cciExceptionInfo.TryStart.Offset, (uint)cciExceptionInfo.TryEnd.Offset); switch (cciExceptionInfo.HandlerType) { case Cecil.Cil.ExceptionHandlerType.Filter: AnalysisNet.Types.IType filterExceptionType = typeExtractor.ExtractType((Cecil.TypeReference)cciExceptionInfo.FilterStart.Operand); AnalysisNet.FilterExceptionHandler filterHandler = new AnalysisNet.FilterExceptionHandler((uint)cciExceptionInfo.FilterStart.Offset, (uint)cciExceptionInfo.HandlerStart.Offset, (uint)cciExceptionInfo.HandlerEnd.Offset, filterExceptionType); tryHandler.Handler = filterHandler; break; case Cecil.Cil.ExceptionHandlerType.Catch: AnalysisNet.Types.IType catchExceptionType = typeExtractor.ExtractType(cciExceptionInfo.CatchType); AnalysisNet.CatchExceptionHandler catchHandler = new AnalysisNet.CatchExceptionHandler((uint)cciExceptionInfo.HandlerStart.Offset, (uint)cciExceptionInfo.HandlerEnd.Offset, catchExceptionType); tryHandler.Handler = catchHandler; break; case Cecil.Cil.ExceptionHandlerType.Fault: AnalysisNet.FaultExceptionHandler faultHandler = new AnalysisNet.FaultExceptionHandler((uint)cciExceptionInfo.HandlerStart.Offset, (uint)cciExceptionInfo.HandlerEnd.Offset); tryHandler.Handler = faultHandler; break; case Cecil.Cil.ExceptionHandlerType.Finally: AnalysisNet.FinallyExceptionHandler finallyHandler = new AnalysisNet.FinallyExceptionHandler((uint)cciExceptionInfo.HandlerStart.Offset, (uint)cciExceptionInfo.HandlerEnd.Offset); tryHandler.Handler = finallyHandler; break; default: throw new Exception("Unknown exception handler block kind"); } ourExceptionInformation.Add(tryHandler); } }
private AnalysisNet.IInstruction ProcessInitObj(Cecil.Cil.Instruction op) { AnalysisNet.Types.IType type = typeExtractor.ExtractType(op.Operand as Cecil.TypeReference); AnalysisNetBytecode.InitObjInstruction instruction = new AnalysisNetBytecode.InitObjInstruction((uint)op.Offset, type); return(instruction); }
private AnalysisNet.IInstruction ProcessConstrained(Cecil.Cil.Instruction op) { AnalysisNet.Types.IType thisType = typeExtractor.ExtractType(op.Operand as Cecil.TypeReference); AnalysisNetBytecode.ConstrainedInstruction ins = new AnalysisNetBytecode.ConstrainedInstruction((uint)op.Offset, thisType); return(ins); }