public void mapTypeInterfaces(ICirData cirData, TypeDefinition typeToMap)
{
var classSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeToMap);
var cirClass = getCirClass(cirData, classSignature);
foreach (object interfaceType in typeToMap.Interfaces)
{
var type = interfaceType.GetType().FullName;
TypeReference typeReference = null;
switch (interfaceType.GetType().FullName)
{
case "Mono.Cecil.GenericInstanceType":
{
//var genericInstanceType = (GenericInstanceType)interfaceType;
typeReference = (GenericInstanceType)interfaceType;
break;
}
case "Mono.Cecil.TypeReference":
{
typeReference = (TypeReference)interfaceType;
break;
}
case "Mono.Cecil.TypeDefinition":
{
typeReference = (TypeReference)interfaceType;
break;
}
default:
{
DI.log.error("in mapTypeInterfaces, unsupported interface type: {0}", interfaceType.GetType().FullName);
break;
}
}
if (typeReference != null)
{
// typeReference = (TypeReference)interfaceType;
var typeReferenceSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeReference);
var typeReferenceCirClass = getCirClass(cirData, typeReferenceSignature);
cirClass.dSuperClasses.Add(typeReferenceCirClass.Signature, typeReferenceCirClass);
}
}
if (typeToMap.BaseType != null)
{
var baseTypeSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeToMap.BaseType);
var baseCirClass = getCirClass(cirData, baseTypeSignature);
cirClass.dSuperClasses.Add(baseCirClass.Signature, baseCirClass);
}
}
public ICirFunction processMethodReference(ICirData cirData, MethodReference methodReference, SequencePoint sequencePoint)
{
try
{
var functionSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodReference);
var functionType = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodReference.DeclaringType);
var cirFunction = getCirFunction(cirData, functionSignature, functionType);
cirFunction.CecilSignature = methodReference.ToString();
cirFunction.ReturnType = methodReference.ReturnType.ReturnType.FullName;
cirFunction.ParentClass = getCirClass(cirData, CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodReference.DeclaringType));
cirFunction.ParentClassFullName = methodReference.DeclaringType.FullName;
cirFunction.ParentClassName = methodReference.DeclaringType.Name;
//
cirFunction.Module = (methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Assembly.ToString() : "[NullModule]";
//cirFunction.Module = (methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Name : "[NullModule]";
cirFunction.FunctionName = methodReference.Name;
cirFunction.FunctionNameAndParameters = CecilUtils.getMethodNameAndParameters(methodReference);
cirFunction.ClassNameFunctionNameAndParameters = string.Format("{0}.{1}",
cirFunction.ParentClassFullName,
cirFunction.FunctionNameAndParameters);
cirFunction.SymbolDef = Guid.NewGuid().ToString();
/*if (sequencePoint != null)
* {
* if (string.IsNullOrEmpty(cirFunction.File) == false)
* {
* }
* cirFunction.File = sequencePoint.Document.Url;
* cirFunction.FileLine = sequencePoint.StartColumn.ToString();
* }*/
//methodReference.ReturnType // to implement since we need to add reference to a CirClass
return(cirFunction);
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.processMethodReference", true);
return(null);
}
}
public ICirFunction processMethodDefinition(ICirData cirData, MethodDefinition methodDefinition, SequencePoint sequencePoint)
{
try
{
//var functionSignature = methodDefinition.ToString();
var functionSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodDefinition);
var functionClass = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodDefinition.DeclaringType);
var cirFunction = getCirFunction(cirData, functionSignature, functionClass);
if (false == cirFunction.HasBeenProcessedByCirFactory)
{
if (methodDefinition.CustomAttributes != null && methodDefinition.CustomAttributes.Count > 0)
{
foreach (CustomAttribute customAttribute in methodDefinition.CustomAttributes)
{
var constructorSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(customAttribute.Constructor);
var cirAttribute = new CirAttribute(constructorSignature);
foreach (var constructorParameter in customAttribute.ConstructorParameters)
{
var type = constructorParameter.GetType().FullName;
}
if (customAttribute.Fields.Count > 0 || customAttribute.Properties.Count > 0)
{
}
// PublicDI.log.debug("Added attribute {0} to {1}", customAttribute.Constructor.Name, cirFunction.FunctionName);
cirFunction.FunctionAttributes.Add(cirAttribute);
}
}
// map the common values with MethodReference
processMethodReference(cirData, methodDefinition, sequencePoint);
cirFunction.HasBeenProcessedByCirFactory = true; // we need to put this in here or we will have an infinite loop on recursive functions
cirFunction.HasControlFlowGraph = true; // ControlFlowGraph is use by the Viewers to determine if we have more than just a reference to this method
cirFunction.ParentClass.bClassHasMethodsWithControlFlowGraphs = true; // also mark the parent class
cirFunction.IsStatic = methodDefinition.IsStatic;
cirFunction.IsUnmanaged = methodDefinition.IsUnmanaged;
cirFunction.IsUnmanagedExport = methodDefinition.IsUnmanagedExport;
cirFunction.IsVirtual = methodDefinition.IsVirtual;
cirFunction.IsSetter = methodDefinition.IsSetter;
cirFunction.IsGetter = methodDefinition.IsGetter;
cirFunction.IsRuntime = methodDefinition.IsRuntime;
cirFunction.IsPublic = methodDefinition.IsPublic;
cirFunction.IsPrivate = methodDefinition.IsPrivate;
cirFunction.IsPInvokeImpl = methodDefinition.IsPInvokeImpl;
cirFunction.IsNative = methodDefinition.IsNative;
cirFunction.IsManaged = methodDefinition.IsManaged;
cirFunction.IsInternalCall = methodDefinition.IsInternalCall;
cirFunction.IsIL = methodDefinition.IsIL;
cirFunction.IsConstructor = methodDefinition.IsConstructor;
cirFunction.IsAbstract = methodDefinition.IsAbstract;
cirFunction.HasSecurity = methodDefinition.HasSecurity;
cirFunction.HasBody = methodDefinition.HasBody;
// try to find the location of the current method by going for the first line of the first method
if (methodDefinition.HasBody)
{
foreach (Instruction instruction in methodDefinition.Body.Instructions)
{
if (instruction.SequencePoint != null)
{
cirFunction.File = instruction.SequencePoint.Document.Url;
if (instruction.SequencePoint.StartLine == 16707566) // means there is no source code ref
{
cirFunction.FileLine = "0";
}
else
{
cirFunction.FileLine = instruction.SequencePoint.StartLine.ToString();
}
break;
}
}
}
// map method parameters (this could be on the MethodReference but if so we would have to check for doing it more than once:
foreach (ParameterDefinition parameter in methodDefinition.Parameters)
{
ICirFunctionParameter functionParameter = new CirFunctionParameter
{
ParameterName = parameter.ToString(),
ParameterType = parameter.ParameterType.FullName,
Constant = (parameter.Constant != null) ? parameter.Constant.ToString() : "",
HasConstant = parameter.HasConstant,
HasDefault = parameter.HasDefault,
Method = parameter.Method.ToString()
};
cirFunction.FunctionParameters.Add(functionParameter);
}
// map the calls made and the IsCalledBy
foreach (var methodCalled in CecilUtils.getMethodsCalledInsideMethod(methodDefinition))
{
ICirFunction cirCalledFunction = processMemberReference(cirData, methodCalled.memberReference, methodCalled.sequencePoint);
if (cirCalledFunction != null)
{
// store the fucntion called sequence
cirFunction.FunctionsCalled.Add(new CirFunctionCall(cirCalledFunction, methodCalled.sequencePoint));
// store the unique list of funcions called
if (false == cirFunction.FunctionsCalledUniqueList.Contains(cirCalledFunction))
{
cirFunction.FunctionsCalledUniqueList.Add(cirCalledFunction);
}
// map the FunctionCalled and FunctionIsCalledBy
var cirFunctionCall = new CirFunctionCall(cirCalledFunction, sequencePoint);
//cirFunction.FunctionsCalled.Add(cirFunctionCall);
cirCalledFunction.FunctionIsCalledBy.Add(cirFunctionCall);
//if (false == cirCalledFunction.FunctionIsCalledBy.Contains(cirFunction))
// cirCalledFunction.FunctionIsCalledBy.Add(cirFunction);
}
}
}
// to implement if needed
/* foreach (var methodOverride in methodDefinition.Overrides)
* {
* var name = methodOverride.GetType();
* }*/
return(cirFunction);
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.processMethodDefinition", true);
return(null);
}
}
public ICirClass processTypeDefinition(ICirData cirData, TypeDefinition typeDefinition)
{
try
{
var classSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeDefinition);
var cirClass = getCirClass(cirData, classSignature);
// map attributes for this classs
if (typeDefinition.CustomAttributes != null && typeDefinition.CustomAttributes.Count > 0)
{
foreach (CustomAttribute customAttribute in typeDefinition.CustomAttributes)
{
var constructorSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(customAttribute.Constructor);
var cirAttribute = new CirAttribute(constructorSignature);
foreach (var constructorParameter in customAttribute.ConstructorParameters)
{
// var type = constructorParameter.GetType().FullName;
cirAttribute.Parameters.Add(constructorParameter.ToString(), constructorParameter.GetType().FullName);
}
if (customAttribute.Fields.Count > 0 || customAttribute.Properties.Count > 0)
{
}
cirClass.ClassAttributes.Add(cirAttribute);
}
}
if (false == cirClass.HasBeenProcessedByCirFactory)
{
cirClass.HasBeenProcessedByCirFactory = true;
cirClass.Name = typeDefinition.Name;
cirClass.FullName = typeDefinition.FullName;
cirClass.Module = typeDefinition.Module.Name;
cirClass.Namespace = cirClass.Namespace;
cirClass.SymbolDef = Guid.NewGuid().ToString();
cirClass.IsAbstract = typeDefinition.IsAbstract;
// cirClass.IsAnonymous = typeDefinition.
cirClass.IsClass = typeDefinition.IsClass;
cirClass.IsEnum = typeDefinition.IsEnum;
cirClass.IsInterface = typeDefinition.IsInterface;
cirClass.IsImport = typeDefinition.IsImport;
cirClass.IsNotPublic = typeDefinition.IsNotPublic;
cirClass.IsPublic = typeDefinition.IsPublic;
cirClass.HasSecurity = typeDefinition.HasSecurity;
}
else
{
DI.log.info("This Class has already been processed, so only adding any possible extra methods: {0}", cirClass.Name);
}
// handle constuctors
foreach (MethodDefinition methodDefinition in typeDefinition.Constructors)
{
ICirFunction cirFunction = processMethodDefinition(cirData, methodDefinition, null);
if (false == cirClass.dFunctions.ContainsValue(cirFunction))
{
cirClass.dFunctions.Add(cirFunction.FunctionSignature, cirFunction);
}
// try to find source code reference
if (cirFunction.FunctionsCalled.Count > 0 && cirClass.FileLine == null)
{
if (false == string.IsNullOrEmpty(cirFunction.FunctionsCalled[0].fileName))
{
cirClass.File = cirFunction.FunctionsCalled[0].fileName;
cirClass.FileLine = "0"; // set it to zero and try to map it later
}
}
}
// handle methods
foreach (MethodDefinition methodDefinition in typeDefinition.Methods)
{
ICirFunction cirFunction = processMethodDefinition(cirData, methodDefinition, null);
if (false == cirClass.dFunctions.ContainsValue(cirFunction))
{
cirClass.dFunctions.Add(cirFunction.FunctionSignature, cirFunction);
}
}
return(cirClass);
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.processTypeDefinition", true);
return(null);
}
}
public static bool areEqual_MethodDefinitionAndCirFunction(MethodDefinition cecilMethodDefintion, ICirFunction cirFunction)
{
try
{
if (cecilMethodDefintion == null || cirFunction == null)
{
return(false);
}
var cirFunctionProperties = new Dictionary <string, object>();
foreach (var property in DI.reflection.getProperties(cirFunction.GetType()))
{
cirFunctionProperties.Add(property.Name, DI.reflection.getProperty(property.Name, cirFunction));
// DI.log.info("prop: {0} = {1}", property.Name, cirFunctionProperties[property.Name]);
}
var methodsCalledInsideMethod = CecilUtils.getMethodsCalledInsideMethod(cecilMethodDefintion);
var moduleName = (cecilMethodDefintion.DeclaringType.Module != null) ? cecilMethodDefintion.DeclaringType.Module.Assembly.Name.ToString() : "[NullModule]";
foreach (var property in cirFunctionProperties.Keys)
{
switch (property)
{
case "FunctionSignature":
if (cirFunctionProperties[property].ToString() != String.Format("{0}!{1}", moduleName, cecilMethodDefintion))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: cirFunction[FunctionSignature]!=cecilMethodDefintion");
return(false);
}
break;
case "IsPrivate":
case "IsStatic":
case "IsConstructor":
case "IsUnmanaged":
case "IsUnmanagedExport":
case "IsVirtual":
case "IsSetter":
case "IsGetter":
case "IsRuntime":
case "IsPublic":
case "IsPInvokeImpl":
case "IsNative":
case "IsManaged":
case "IsInternalCall":
case "IsIL":
case "IsAbstract":
case "HasSecurity":
case "HasBody":
if ((bool)cirFunctionProperties[property] !=
(bool)DI.reflection.getProperty(property, cecilMethodDefintion))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: (bool)cirFunctionProperties[" + property +
"] != (bool)DI.reflection.getProperty(" + property + ", cecilMethodDefintion)");
return(false);
}
break;
case "ParentClass":
var cirClass1 = (CirClass)cirFunctionProperties[property];
if (cirClass1.Signature != CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(cecilMethodDefintion.DeclaringType))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: cirFunction[ParentClass]!=cecilMethodDefintion == " + cecilMethodDefintion.DeclaringType.FullName);
return(false);
}
break;
case "ParentClassFullName":
var parentClassFullName = (string)cirFunctionProperties[property];
if (parentClassFullName != cecilMethodDefintion.DeclaringType.FullName)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: cirFunction[ParentClassFullName]!=cecilMethodDefintion.FullName " + cecilMethodDefintion.DeclaringType.FullName);
return(false);
}
break;
case "ParentClassName":
var parentClassName = (string)cirFunctionProperties[property];
if (parentClassName != cecilMethodDefintion.DeclaringType.Name)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: cirFunction[parentClassName]!=cecilMethodDefintion.FullName " + cecilMethodDefintion.DeclaringType.Name);
return(false);
}
break;
case "FunctionParameters":
var cirFunctionParameters = (List <ICirFunctionParameter>)cirFunctionProperties[property];
if (cecilMethodDefintion.Parameters.Count != cirFunctionParameters.Count)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: the FunctionParameters count didn't match");
return(false);
}
foreach (ParameterDefinition parameter in cecilMethodDefintion.Parameters)
{
if (false == ViewHelpers.getCirParameterTypeStringList(cirFunctionParameters).Contains(parameter.ParameterType.FullName))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: the FunctionParameters signatures didn't match");
return(false);
}
}
break;
case "FunctionsCalledUniqueList":
var functionsCalledUniqueList = (List <ICirFunction>)cirFunctionProperties[property];
foreach (MethodCalled methodCalled in methodsCalledInsideMethod)
{
if (false == ViewHelpers.getCirFunctionStringList(functionsCalledUniqueList).Contains(CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodCalled.memberReference)))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: there was a missing function in the FunctionsCalledUniqueList");
return(false);
}
}
break;
case "FunctionsCalledSequence":
var functionsCalledSequence = (List <ICirFunction>)cirFunctionProperties[property];
if (functionsCalledSequence.Count != methodsCalledInsideMethod.Count)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: functionsCalledSequence.Count != methodsCalledInsideMethod.Count");
return(false);
}
for (int i = 0; i < methodsCalledInsideMethod.Count; i++)
{
if (CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodsCalledInsideMethod[i].memberReference) != ViewHelpers.getCirFunctionStringList(functionsCalledSequence)[i])
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: the FunctionsCalledSequence does match");
return(false);
}
}
break;
case "ReturnType":
if (cecilMethodDefintion.ReturnType.ReturnType.FullName != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: ReturnType don't match");
return(false);
}
break;
case "CecilSignature":
if (cecilMethodDefintion.ToString() != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: CecilSignature din't match");
return(false);
}
break;
case "FunctionNameAndParameters":
if (CecilUtils.getMethodNameAndParameters(cecilMethodDefintion) != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: FunctionNameAndParameters din't match");
return(false);
}
break;
case "FunctionName":
if (cecilMethodDefintion.Name != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: FunctionName din't match");
return(false);
}
break;
case "Module":
if (moduleName != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: Module din't match");
return(false);
}
break;
case "ClassNameFunctionNameAndParameters":
var classNameFunctionNameAndParameters = cirFunctionProperties[property].ToString();
var expectedClassNameFunctionNameAndParameters = string.Format("{0}.{1}",
cirFunction.ParentClassFullName,
cirFunction.FunctionNameAndParameters);
if (classNameFunctionNameAndParameters != expectedClassNameFunctionNameAndParameters)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: classNameFunctionNameAndParameters din't match");
return(false);
}
break;
// ignore these ones
case "IsSource":
case "IsSink":
case "FunctionParameterTypes":
case "lcfgBasicBlocks":
case "SymbolDef":
case "ReflectionSignature":
case "O2MDbgSignature":
case "UsedTypes":
case "FunctionIsCalledBy":
case "dSsaVariables":
case "dVariables":
case "HasControlFlowGraph":
case "OnlyShowFunctionNameInToString":
case "HasBeenProcessedByCirFactory":
break;
// case "":
//break;
default:
DI.log.error(" property not handled: {0}", property);
break;
}
}
return(true);
}
catch (Exception ex)
{
DI.log.ex(ex, "in areEqual_MethodDefinitionAndCirFunction", true);
return(false);
}
}