Core: ISIL: Resolve unambigous method calls

Cpp2IL.Core/Graphs/Processors/CallProcessor.cs

@@ -32,10 +32,15 @@ public void Process(MethodAnalysisContext methodAnalysisContext, Block block)
                 HandleKeyFunction(methodAnalysisContext.AppContext, callInstruction, target, keyFunctionAddresses);
                 return;
             }
-            else
-            {
-                // TODO: We could possibly try to resolve some non de-duplicated managed methods early on?
-            }
+
+            //Non-key function call. Try to find a single match
+            if (!methodAnalysisContext.AppContext.MethodsByAddress.TryGetValue(target, out var targetMethods))
+                return;
+
+            if (targetMethods is not [{ } singleTargetMethod])
+                return;
+
+            callInstruction.Operands[0] = InstructionSetIndependentOperand.MakeMethodReference(singleTargetMethod);
         }
 
         private void HandleKeyFunction(ApplicationAnalysisContext appContext, InstructionSetIndependentInstruction instruction, ulong target, BaseKeyFunctionAddresses kFA)

Cpp2IL.Core/ISIL/InstructionSetIndependentOperand.cs

@@ -14,8 +14,8 @@ public readonly struct InstructionSetIndependentOperand
     public static InstructionSetIndependentOperand MakeStack(int value) => new(OperandType.StackOffset, new IsilStackOperand(value));
     public static InstructionSetIndependentOperand MakeInstruction(InstructionSetIndependentInstruction instruction) => new(OperandType.Instruction, instruction);
     public static InstructionSetIndependentOperand MakeVectorElement(string registerName, IsilVectorRegisterElementOperand.VectorElementWidth width, int index) => new(OperandType.Register, new IsilVectorRegisterElementOperand(registerName, width, index));
-
     public static InstructionSetIndependentOperand MakeTypeMetadataUsage(TypeAnalysisContext value) => new(OperandType.TypeMetadataUsage, new IsilTypeMetadataUsageOperand(value));
+    public static InstructionSetIndependentOperand MakeMethodReference(MethodAnalysisContext value) => new(OperandType.MethodReference, new IsilMethodOperand(value));
 
 
     private InstructionSetIndependentOperand(OperandType type, IsilOperandData data)
@@ -41,11 +41,12 @@ public enum OperandType
         Memory = 8,
         Instruction = 16,
         TypeMetadataUsage = 32,
+        MethodReference = 64,
 
         MemoryOrStack = Memory | StackOffset,
-        NotStack = Immediate | Register | Memory | Instruction | TypeMetadataUsage,
+        NotStack = Immediate | Register | Memory | Instruction | TypeMetadataUsage | MethodReference,
 
 
-        Any = Immediate | StackOffset | Register | Memory | TypeMetadataUsage
+        Any = Immediate | StackOffset | Register | Memory | TypeMetadataUsage | MethodReference
     }
 }

Cpp2IL.Core/ISIL/IsilMethodOperand.cs

@@ -0,0 +1,15 @@
+using Cpp2IL.Core.Model.Contexts;
+
+namespace Cpp2IL.Core.ISIL;
+
+public readonly struct IsilMethodOperand : IsilOperandData
+{
+    public readonly MethodAnalysisContext Method { get; }
+
+    public IsilMethodOperand(MethodAnalysisContext method)
+    {
+        Method = method;
+    }
+
+    public override string ToString() => Method.DeclaringType?.Name + "." + Method.Name;
+}

Cpp2IL.Core/Model/Contexts/ApplicationAnalysisContext.cs

@@ -161,10 +161,13 @@ private void PopulateMethodsByAddressTable()
 
     public BaseKeyFunctionAddresses GetOrCreateKeyFunctionAddresses()
     {
-        if (_keyFunctionAddresses == null)
-            (_keyFunctionAddresses = InstructionSet.CreateKeyFunctionAddressesInstance()).Find(this);
+        lock (InstructionSet)
+        {
+            if (_keyFunctionAddresses == null)
+                (_keyFunctionAddresses = InstructionSet.CreateKeyFunctionAddressesInstance()).Find(this);
 
-        return _keyFunctionAddresses;
+            return _keyFunctionAddresses;
+        }
     }
 
     public MultiAssemblyInjectedType InjectTypeIntoAllAssemblies(string ns, string name, TypeAnalysisContext? baseType)

LibCpp2IL/LibCpp2IlMain.cs

@@ -92,8 +92,11 @@ public static void Reset()
             if (TheMetadata == null) return null;
 
             var typeGlobal = GetRawTypeGlobalByAddress(address);
+
+            if (typeGlobal?.Type is not (MetadataUsageType.Type or MetadataUsageType.TypeInfo))
+                return null;
 
-            return typeGlobal?.AsType();
+            return typeGlobal.AsType();
         }
 
         public static MetadataUsage? GetRawFieldGlobalByAddress(ulong address)