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