private void IndexConcreteMethods(ModuleDefinition module)
{
var implementationMethods = DecompilerService.GetConcreteMethods(module);
foreach (var method in implementationMethods)
{
if (ShouldSkip(method))
{
continue;
}
var methodNameKey = SignatureKeyService.GetFullMethodSignature(method);
if (!ImplementationMethodsIndexedByName.ContainsKey(methodNameKey))
{
ImplementationMethodsIndexedByName.Add(methodNameKey, method);
ImplementationMethodsList.Add(method);
ImplementationMethodsIndexedByTypeName.Add(method.DeclaringType.FullName, method);
}
var genericSignature = SignatureKeyService.GetGenericMethodSignature(method);
if (!string.IsNullOrEmpty(genericSignature))
{
if (!ImplementationMethodsIndexedByGenericSignature.ContainsKey(genericSignature))
{
ImplementationMethodsIndexedByGenericSignature.Add(genericSignature, method);
}
}
}
}
private void IndexInterfaceMethods(ModuleDefinition module)
{
var interfaceMethods = DecompilerService.GetInterfaceMethods(module);
foreach (var method in interfaceMethods)
{
// index by a simplified generic signature if it is a generic interface method
var genericSignature = SignatureKeyService.GetGenericMethodSignature(method);
if (!string.IsNullOrEmpty(genericSignature))
{
if (!InterfaceMethodsIndexedByGenericSignature.ContainsKey(genericSignature))
{
InterfaceMethodsIndexedByGenericSignature.Add(genericSignature, method);
}
}
// index by the standard method signature
var methodSignature = SignatureKeyService.GetFullMethodSignature(method);
if (!InterfaceMethodsIndexedByName.ContainsKey(methodSignature))
{
InterfaceMethodsIndexedByName.Add(methodSignature, method);
}
InterfaceMethodsIndexedByTypeName.Add(method.DeclaringType.FullName, method);
InterfaceMethodsList.Add(method);
}
}
private void DoCrossAssemblyWalk(MethodGraph methodGraph, string companyAssembliesPattern, ModuleDefinition module, string moduleMessagee)
{
var publicMethods = DecompilerService.GetPublicMethods(companyAssembliesPattern, module)
.Where(x => !IsBlackListed(x))
.OrderBy(x => x.DeclaringType.Name)
.ThenBy(x => x.Name)
.ToList();
int methodCount = publicMethods.Count;
var publicMethodsAnalyzed = new HashSet <string>();
_methodNodeLookup.Clear();
int methodCounter = 0;
foreach (var publicMethod in publicMethods)
{
methodCounter++;
_logOutput.LogAnalysis("Method " + methodCounter + " of " + methodCount + " : " + moduleMessagee + " -> " + publicMethod.Name);
if ((publicMethod.IsGetter || publicMethod.IsSetter) && !IsNoteworthyProperty(publicMethod))
{
continue;
}
var signature = SignatureKeyService.GetFullMethodSignature(publicMethod);
if (_methodIndexer.HasMethod(signature))
{
var unfilteredRootNodes = _methodIndexer.GetMethods(signature);
var rootNodes = unfilteredRootNodes.Where(x => x.HasImplementation() &&
(
// if it is a public implementation of a different assembly, then'll we'll filter it out here (and analyze it that assembly)
(x.ConcreteMethod.IsPublic && x.ConcreteMethod.Module.Name.Equals(module.Name))
// if it is a private implementation then analyze it now as we'll miss it when we analyze the public methods of the other assembly
|| !x.ConcreteMethod.DeclaringType.IsPublic
)
)
.ToList();
foreach (var rootMethod in rootNodes)
{
if (!AlreadyProcessed(rootMethod.GetMethodDefinition()))
{
var publicMethodNode = GetMethodNode(methodGraph.GraphType, methodGraph.ApplicationName, rootMethod);
var callTreeNode = new ExploreTreeNode()
{
FullSignature = signature
};
CrossAssemblyWalk(methodGraph, publicMethodNode, rootMethod, 1, callTreeNode);
CacheNode(rootMethod.GetMethodDefinition(), publicMethodNode);
methodGraph.AddMethodNode(publicMethodNode);
}
}
}
}
}
private void IndexAbstractMethods(ModuleDefinition module)
{
var abstractMethods = DecompilerService.GetAbstractMethods(module);
foreach (var method in abstractMethods)
{
AbstractMethodsIndexedByName.Add(SignatureKeyService.GetFullMethodSignature(method), method);
AbstractMethodsIndexedByTypeName.Add(method.DeclaringType.FullName, method);
AbstractMethodsList.Add(method);
}
}
private void ContinueDownFullTree(MethodGraph methodGraph, MethodNode parentMethodNode, MethodObject parentMethod, int depth, ExploreTreeNode callTreeNode)
{
foreach (var calledMethod in parentMethod.MethodsCalled)
{
CheckForResourceCall(methodGraph, calledMethod, parentMethod, parentMethodNode);
var calledMethodSignature = SignatureKeyService.GetFullMethodSignature(calledMethod.MethodCalled);
var treeNode = new ExploreTreeNode()
{
FullSignature = calledMethodSignature
};
callTreeNode.AddChild(treeNode);
bool isGenericAndIndexed = false;
string genericSignature = null;
var methodIsIndexed = _methodIndexer.HasMethod(calledMethodSignature);
if (!methodIsIndexed)
{
genericSignature = SignatureKeyService.GetGenericMethodSignature(calledMethod.MethodCalled);
if (!string.IsNullOrEmpty(genericSignature))
{
isGenericAndIndexed = _methodIndexer.HasMethod(genericSignature);
}
}
if (methodIsIndexed || isGenericAndIndexed)
{
List <MethodObject> matchingMethodNodes = null;
if (methodIsIndexed)
{
matchingMethodNodes = _methodIndexer.GetMethods(calledMethodSignature);
}
else if (isGenericAndIndexed)
{
matchingMethodNodes = _methodIndexer.GetMethods(genericSignature);
}
foreach (var calledMethodNode in matchingMethodNodes)
{
var cachedRootNode = GetCachedRootNode(calledMethodNode.GetMethodDefinition());
if (cachedRootNode != null) // this is a call to an already analyzed method, we copy over the calls and resource accesses already calculated for this node
{
cachedRootNode.CopyCallsToNode(parentMethodNode);
}
else // this is not a call to a previously analyzed method, so we continue down the call tree
{
PublicInnerAssemblyWalk(methodGraph, parentMethodNode, calledMethodNode, depth + 1, treeNode);
}
}
}
}
}
private void DoDirectCallWalk(MethodGraph methodGraph, string companyAssembliesPattern, ModuleDefinition module, string moduleMessagee)
{
var methods = _methodIndexer.GetAllMethods();
foreach (var method in methods)
{
var methodNode = GetMethodNode(methodGraph.GraphType, methodGraph.ApplicationName, method);
foreach (var calledMethod in method.MethodsCalled)
{
CheckForResourceCall(methodGraph, calledMethod, method, methodNode);
var calledMethodSignature = SignatureKeyService.GetFullMethodSignature(calledMethod.MethodCalled);
bool isGenericAndIndexed = false;
string genericSignature = null;
var methodIsIndexed = _methodIndexer.HasMethod(calledMethodSignature);
if (!methodIsIndexed)
{
genericSignature = SignatureKeyService.GetGenericMethodSignature(calledMethod.MethodCalled);
if (!string.IsNullOrEmpty(genericSignature))
{
isGenericAndIndexed = _methodIndexer.HasMethod(genericSignature);
}
}
if (methodIsIndexed || isGenericAndIndexed)
{
List <MethodObject> matchingMethodNodes = null;
if (methodIsIndexed)
{
matchingMethodNodes = _methodIndexer.GetMethods(calledMethodSignature);
}
else if (isGenericAndIndexed)
{
matchingMethodNodes = _methodIndexer.GetMethods(genericSignature);
}
foreach (var calledMethodNode in matchingMethodNodes)
{
AddDirectCalls(methodGraph, methodNode, calledMethodNode);
}
}
}
methodGraph.AddMethodNode(methodNode);
}
}
public void BuildMethodObjects(string appDomain)
{
foreach (var method in ImplementationMethodsList)
{
if (ShouldSkip(method))
{
continue;
}
var node = new MethodObject();
node.AppDomain = appDomain;
node.ConcreteMethod = method;
var implementsInterface = FindInterfaceMethod(method, node);
if (implementsInterface)
{
MethodObjectsIndexedByFullName.Add(SignatureKeyService.GetFullMethodSignature(node.InterfaceMethod), node);
var genericSignature = SignatureKeyService.GetGenericMethodSignature(node.InterfaceMethod);
if (!string.IsNullOrEmpty(genericSignature))
{
MethodObjectsIndexedByFullName.Add(genericSignature, node);
}
}
var implementsAbstractClass = FindAbstractMethod(method, node);
if (implementsAbstractClass)
{
MethodObjectsIndexedByFullName.Add(SignatureKeyService.GetFullMethodSignature(node.AbstractMethod), node);
}
var inheritsFromBaseClass = FindBaseClassMethod(method, node);
if (inheritsFromBaseClass)
{
MethodObjectsIndexedByFullName.Add(SignatureKeyService.GetFullMethodSignature(node.VirtualMethod), node);
}
FindFieldsAndMethods(method, node, true);
MethodObjectsIndexedByFullName.Add(SignatureKeyService.GetFullMethodSignature(method), node);
MethodObjectsList.Add(node);
}
foreach (var method in InterfaceMethodsList)
{
if (!MethodObjectsIndexedByFullName.HasIndex(SignatureKeyService.GetFullMethodSignature(method)))
{
var node = new MethodObject();
node.AppDomain = appDomain;
node.InterfaceMethod = method;
node.ImplementsType = ImplementsType.None;
MethodObjectsIndexedByFullName.Add(SignatureKeyService.GetFullMethodSignature(method), node);
}
}
foreach (var method in AbstractMethodsList)
{
if (!MethodObjectsIndexedByFullName.HasIndex(SignatureKeyService.GetFullMethodSignature(method)))
{
var node = new MethodObject();
node.AppDomain = appDomain;
node.AbstractMethod = method;
node.ImplementsType = ImplementsType.None;
MethodObjectsIndexedByFullName.Add(SignatureKeyService.GetFullMethodSignature(method), node);
}
}
}
