private IEntity FindEntityInRelevantAssemblies(string navigateTo, IEnumerable <LoadedAssembly> relevantAssemblies)
{
ITypeReference typeRef = null;
IMemberReference memberRef = null;
if (navigateTo.StartsWith("T:", StringComparison.Ordinal))
{
typeRef = IdStringProvider.ParseTypeName(navigateTo);
}
else
{
memberRef = IdStringProvider.ParseMemberIdString(navigateTo);
typeRef = memberRef.DeclaringTypeReference;
}
foreach (LoadedAssembly asm in relevantAssemblies.ToList())
{
var module = asm.GetPEFileOrNull();
if (CanResolveTypeInPEFile(module, typeRef, out var typeHandle))
{
ICompilation compilation = typeHandle.Kind == HandleKind.ExportedType
? new DecompilerTypeSystem(module, module.GetAssemblyResolver())
: new SimpleCompilation(module, MinimalCorlib.Instance);
return(memberRef == null
? typeRef.Resolve(new SimpleTypeResolveContext(compilation)) as ITypeDefinition
: (IEntity)memberRef.Resolve(new SimpleTypeResolveContext(compilation)));
}
}
return(null);
}
public int GetMemberIndex(IMemberReference reference)
{
int classIndex = GetClassIndex(reference.DeclaringClass);
int nameAndTypeIndex = GetNameAndTypeIndex(reference.Name, reference.Descriptor);
MemberRefInfo memberRefInfo;
switch (reference)
{
case IField _:
memberRefInfo = new FieldRefInfo((ushort)classIndex, (ushort)nameAndTypeIndex);
break;
case IMethod _:
memberRefInfo = new MethodRefInfo((ushort)classIndex, (ushort)nameAndTypeIndex);
break;
default:
throw new NotSupportedException();
}
if (!_memberRefInfos.TryGetValue(memberRefInfo, out int index))
{
index = AddConstant(memberRefInfo);
_memberRefInfos.Add(memberRefInfo, index);
}
return(index);
}
public static string getFunctionUniqueSignatureFromMethodReference(IMemberReference methodReference)
{
try
{
if (methodReference.DeclaringType.Module != null)
{
if (methodReference.DeclaringType.Scope.Name == methodReference.DeclaringType.Module.Name)
{
return(String.Format("{0}!{1}", methodReference.DeclaringType.Module.Assembly.Name, methodReference)); // use the module name if the scope matches
}
return(String.Format("{0}!{1}", methodReference.DeclaringType.Scope, methodReference)); // use the scope name for external methods (like mscorlib.dll)
}
return(String.Format("{0}!{1}", "[NullModule]", methodReference)); // when there is no module info
// methodReference.DeclaringType.Scope.MetadataToken.
/*return String.Format("{0}!{1}",
* ((methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Name : "[NullModule]")
* , methodReference); */
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference", true);
}
return(null);
}
private void ResolveMemberRefToken(IMemberReference entity)
{
var row = CreateMemberRefRow(entity, _metadata);
var rid = _metadata.MemberRefTable.Add(row);
_token = new MetadataToken(MetadataTokenType.MemberRef, rid);
}
public IEnumerable<ExceptionSources> this [IMemberReference member] {
get {
if (member == null)
throw new ArgumentNullException ("member");
IMemberReference memberDef = member.Resolve ();
if (memberDef == null) {
ArrayType array = member.DeclaringType as ArrayType;
if (array != null && array.Rank > 1) {
// Multi-dimensional array; the member is runtime generated,
// doesn't "really" exist (in a form that we can resolve),
// so we can't do anything further.
return new ExceptionSources[0];
}
throw new NotSupportedException (string.Format (
"Unable to resolve member {0}::{1}.",
member.DeclaringType.FullName, member.Name));
}
string memberDecl = xdoc.GetDeclaration (member.Resolve ());
Dictionary<string, ExceptionSources> e;
if (!db.TryGetValue (memberDecl, out e)) {
e = new Dictionary<string, ExceptionSources> ();
var bodies = GetMethodBodies (member);
foreach (var body in bodies) {
if (body == null)
continue;
FillExceptions (body, e);
}
db.Add (memberDecl, e);
}
return e.Values;
}
}
private void SetCurrentReference()
{
if (MainModel == null)
{
return;
}
IMemberReference memberReference = MainModel.CurrentReference;
// Select the correct node in the tree
TreeNode node = FindNode(memberReference);
if (node == null)
{
return;
}
node.EnsureVisible();
_assembliesTree.SelectedNode = node;
// Set the display context content
if (memberReference is IResource)
{
SetResource((IResource)memberReference);
}
else
{
SetCodeReference(memberReference);
}
}
/// <summary>
/// Determines whether two callable member references are considered equal according to their signatures.
/// </summary>
/// <param name="reference1">The first reference to compare.</param>
/// <param name="reference2">The second reference to compare.</param>
/// <returns><c>True</c> if the members are considered equal, <c>False</c> otherwise.</returns>
public bool Equals(IMemberReference reference1, IMemberReference reference2)
{
if (reference1 == null && reference2 == null)
{
return(true);
}
if (reference1 == null || reference2 == null)
{
return(false);
}
var callable = reference1 as ICallableMemberReference;
if (callable != null)
{
return(Equals(callable, reference2 as ICallableMemberReference));
}
var type = reference1 as ITypeDefOrRef;
if (type != null)
{
return(Equals((IMemberReference)type, reference1 as ITypeDefOrRef));
}
return(false);
}
public void WriteReference(string text, string toolTip, Object reference)
{
this.writer.ApplyIndent();
bool handled = false;
if (reference is ITypeDeclaration)
{
ITypeReference tr = (ITypeReference)reference;
if (!Utils.IsSystemType(tr.Namespace))
{
WriteMetadataItem(text, (IMetadataItem)reference);
handled = true;
}
}
else if (reference is IMemberReference && reference is IMetadataItem)
{
IMemberReference mr = (IMemberReference)reference;
ITypeReference tr = (ITypeReference)mr.DeclaringType;
if (tr == null || (tr != null && !Utils.IsSystemType(tr.Namespace)))
{
WriteMetadataItem(text, (IMetadataItem)reference);
handled = true;
}
}
if (!handled)
{
this.writer.WriteColor(text, 0x006018);
}
}
public IMemberReference ImportReference(IMemberReference reference)
{
var type = reference as ITypeDefOrRef;
if (type != null)
{
return(ImportType(type));
}
var method = reference as MethodDefinition;
if (method != null)
{
return(ImportMethod(method));
}
var field = reference as FieldDefinition;
if (field != null)
{
return(ImportField(field));
}
var member = reference as MemberReference;
if (member != null)
{
return(ImportMember(member));
}
throw new NotSupportedException("Invalid or unsupported reference.");
}
public AccessorOwnerMemberReference(IMemberReference accessorReference)
{
if (accessorReference == null)
{
throw new ArgumentNullException("accessorReference");
}
this.accessorReference = accessorReference;
}
public IReadOnlyList <IMemberDefinition> MemberReferance(IMemberReference memberReferance)
{
// this is only sometimes a closure
//
return(new List <IMemberDefinition> {
memberReferance.MemberDefinition
});
}
public SpecializingMemberReference(IMemberReference memberDefinitionReference, IList<ITypeReference> classTypeArgumentReferences = null, IList<ITypeReference> methodTypeArgumentReferences = null)
{
if (memberDefinitionReference == null)
throw new ArgumentNullException("memberDefinitionReference");
this.memberDefinitionReference = memberDefinitionReference;
this.classTypeArgumentReferences = classTypeArgumentReferences;
this.methodTypeArgumentReferences = methodTypeArgumentReferences;
}
private MemberRefRow CreateMemberRefRow(IMemberReference entity, MetadataBuilder metadata)
{
return(new MemberRefRow(
metadata.ResolveToken(entity.DeclaringType),
metadata.WriteString(entity.Name),
metadata.WriteSignature(entity)
));
}
public ExplicitInterfaceImplementationMemberReference(ITypeReference typeReference, IMemberReference interfaceMemberReference)
{
if (typeReference == null)
throw new ArgumentNullException("typeReference");
if (interfaceMemberReference == null)
throw new ArgumentNullException("interfaceMemberReference");
this.typeReference = typeReference;
this.interfaceMemberReference = interfaceMemberReference;
}
public OwnedParameterReference(IMemberReference member, int index)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
this.memberReference = member;
this.index = index;
}
public SpecializingMemberReference(IMemberReference memberDefinitionReference, IList <ITypeReference> classTypeArgumentReferences = null, IList <ITypeReference> methodTypeArgumentReferences = null)
{
if (memberDefinitionReference == null)
{
throw new ArgumentNullException("memberDefinitionReference");
}
this.memberDefinitionReference = memberDefinitionReference;
this.classTypeArgumentReferences = classTypeArgumentReferences;
this.methodTypeArgumentReferences = methodTypeArgumentReferences;
}
public SpecializingMemberReference(ITypeReference declaringTypeReference, IMemberReference memberDefinitionReference, IList<ITypeReference> typeArgumentReferences = null)
{
if (declaringTypeReference == null)
throw new ArgumentNullException("declaringTypeReference");
if (memberDefinitionReference == null)
throw new ArgumentNullException("memberDefinitionReference");
this.declaringTypeReference = declaringTypeReference;
this.memberDefinitionReference = memberDefinitionReference;
this.typeArgumentReferences = typeArgumentReferences;
}
internal static string GetFullName(this IMemberReference reference, IHasTypeSignature signature)
{
var methodSignature = signature as MethodSignature;
var parameterString = methodSignature != null
? "(" + methodSignature.Parameters.Select(x => x.ParameterType).GetTypeArrayString() + ")"
: string.Empty;
return(string.Format("{0} {1}::{2}{3}",
signature.TypeSignature.FullName, reference.DeclaringType.FullName, reference.Name, parameterString));
}
private static void VerifyMatching(IMemberReference original, IMemberReference expected, params IMemberReference[] fails)
{
Assert.IsTrue(_comparer.MatchMembers(original, expected), "The original signature did not match the expected.");
Assert.IsTrue(_comparer.MatchMembers(expected, original), "The expected signature did not match the original.");
foreach (var fail in fails)
{
Assert.IsFalse(_comparer.MatchMembers(original, fail), original + " matched " + fail.FullName);
Assert.IsFalse(_comparer.MatchMembers(fail, original), fail.FullName + " matched " + original);
}
}
public void Back()
{
if (_backList.Count == 0)
{
return;
}
_forwardList.Push(CurrentReference);
_currentReference = _backList.Pop();
NotifyObservers(new MainModelChangeHint(MainModelChangeHint.HintType.CurrentReference));
}
public void ParseMemberReferenceFindTypeName()
{
IMemberReference memberReference = AssemblyManager.ParseMemberReference("[mscorlib]System.Text.StringBuilder");
Assert.IsNotNull(memberReference);
Assert.IsInstanceOf(typeof(ITypeReference), memberReference);
ITypeReference typeReference = (ITypeReference)memberReference;
Assert.AreEqual("System.Text", typeReference.Namespace);
Assert.AreEqual("StringBuilder", typeReference.Name);
}
public void ParseMemberReferenceFindAssemblyName()
{
IMemberReference memberReference = AssemblyManager.ParseMemberReference("[mscorlib]");
Assert.IsNotNull(memberReference);
Assert.IsInstanceOf(typeof(IAssemblyReference), memberReference);
IAssemblyReference assemblyReference = (IAssemblyReference)memberReference;
Assert.AreEqual("mscorlib", assemblyReference.Name);
//Assert.AreEqual(assembly, assemblyReference);
}
public static StandAloneSignature GetMemberReferenceSignature(IMemberReference memberRef, MetadataBuilder metadata)
{
if (memberRef is MethodReference)
{
return(GetMethodSignature((MethodReference)memberRef, metadata));
}
if (memberRef is FieldReference)
{
return(GetFieldSignature((FieldReference)memberRef, metadata));
}
throw new InvalidOperationException("Can't compute signature for member reference of type: " + memberRef.GetType());
}
public static MsilInstruction Create(MsilOpCode code, IMemberReference operand)
{
switch (code.OperandType)
{
case MsilOperandType.InlineField:
case MsilOperandType.InlineMethod:
case MsilOperandType.InlineTok:
case MsilOperandType.InlineType:
return new MsilInstruction(0, code, operand);
}
throw new ArgumentException("Opcode does not accept a member operand operand.", "code");
}
public static MsilInstruction Create(MsilOpCode code, IMemberReference operand)
{
switch (code.OperandType)
{
case MsilOperandType.InlineField:
case MsilOperandType.InlineMethod:
case MsilOperandType.InlineTok:
case MsilOperandType.InlineType:
return(new MsilInstruction(0, code, operand));
}
throw new ArgumentException("Opcode does not accept a member operand operand.", "code");
}
public ExplicitInterfaceImplementationMemberReference(ITypeReference typeReference, IMemberReference interfaceMemberReference)
{
if (typeReference == null)
{
throw new ArgumentNullException("typeReference");
}
if (interfaceMemberReference == null)
{
throw new ArgumentNullException("interfaceMemberReference");
}
this.typeReference = typeReference;
this.interfaceMemberReference = interfaceMemberReference;
}
private void CreateStack(AssemblyCompilerContext assemblyContext, IMemberReference method)
{
using (var runtime = assemblyContext.GetOutputFileWriter("stack.s"))
{
runtime.WriteLine(".globl _setup_stack");
runtime.WriteLine(" .def _setup_stack; .scl 2; .type 32; .endef");
runtime.WriteLine("_setup_stack:");
runtime.WriteLine(" movl %esp, %ecx");
runtime.WriteLine(" movl 4(%esp), %esp");
runtime.WriteLine(" call _{0}", method.Name);
runtime.WriteLine(" movl %ecx, %esp");
runtime.WriteLine(" ret");
}
}
public SpecializingMemberReference(ITypeReference declaringTypeReference, IMemberReference memberDefinitionReference, IList <ITypeReference> typeArgumentReferences = null)
{
if (declaringTypeReference == null)
{
throw new ArgumentNullException("declaringTypeReference");
}
if (memberDefinitionReference == null)
{
throw new ArgumentNullException("memberDefinitionReference");
}
this.declaringTypeReference = declaringTypeReference;
this.memberDefinitionReference = memberDefinitionReference;
this.typeArgumentReferences = typeArgumentReferences;
}
public virtual void Collect(IMemberReference member)
{
Collect(member.Name);
if (member is FieldReference)
{
Collect((member as FieldReference).Owner);
}
if (member is MethodReference)
{
Collect((member as MethodReference).Owner);
}
}
private ICirFunction processMemberReference(ICirData cirData, IMemberReference memberDefinition, SequencePoint sequencePoint)
{
switch (memberDefinition.GetType().Name)
{
case "MethodReference":
return processMethodReference(cirData, (MethodReference)memberDefinition, sequencePoint);
case "MethodDefinition":
return processMethodDefinition(cirData, (MethodDefinition)memberDefinition, sequencePoint);
default:
DI.log.error("in CirFactory.processMethodMember, unsupported MethodMember: {0}", memberDefinition.GetType().Name);
break;
}
return null;
}
public IInterpetedOperation MemberReferance(IMemberReference codeElement)
{
if (backing.TryGetValue(codeElement, out var res))
{
return(res);
}
else
{
var op = new InterpetedMemberReferance();
backing.Add(codeElement, op);
op.Init(
MemberDefinition(codeElement.MemberDefinition).CastTo <InterpetedMemberDefinition>());
return(op);
}
}
public virtual void Collect(IMemberReference member)
{
Collect(member.Name);
switch (member)
{
case FieldReference fieldReference:
Collect(fieldReference.Owner);
break;
case MethodReference methodReference:
Collect(methodReference.Owner);
break;
}
}
internal static int GetColorDeclaringType(IMemberReference memberReference)
{
ITypeReference typeReference = memberReference.DeclaringType as ITypeReference;
if (typeReference != null)
{
int color = GetColorDeclaringType(typeReference);
if (color == ColorInformation.Hidden)
{
return(color);
}
}
return(GetColor(memberReference));
}
private ICirFunction processMemberReference(ICirData cirData, IMemberReference memberDefinition, SequencePoint sequencePoint)
{
switch (memberDefinition.GetType().Name)
{
case "MethodReference":
return(processMethodReference(cirData, (MethodReference)memberDefinition, sequencePoint));
case "MethodDefinition":
return(processMethodDefinition(cirData, (MethodDefinition)memberDefinition, sequencePoint));
default:
DI.log.error("in CirFactory.processMethodMember, unsupported MethodMember: {0}", memberDefinition.GetType().Name);
break;
}
return(null);
}
private static TreeNode FindNode(IMemberReference memberReference, TreeNode parentNode)
{
if (parentNode == null)
{
return(null);
}
foreach (TreeNode node in parentNode.Nodes)
{
if (node.Tag == memberReference)
{
return(node);
}
}
return(null);
}
private void _assembliesTree_AfterSelect(object sender, TreeViewEventArgs e)
{
if (MainModel == null)
{
return;
}
using (new WaitCursor())
{
IMemberReference memberReference = e.Node.Tag as IMemberReference;
if (memberReference != null)
{
MainModel.CurrentReference = memberReference;
return;
}
}
}
public static string getFunctionUniqueSignatureFromMethodReference(IMemberReference methodReference)
{
try
{
if (methodReference.DeclaringType.Module != null )
{
if (methodReference.DeclaringType.Scope.Name == methodReference.DeclaringType.Module.Name)
return String.Format("{0}!{1}", methodReference.DeclaringType.Module.Assembly.Name, methodReference); // use the module name if the scope matches
return String.Format("{0}!{1}", methodReference.DeclaringType.Scope, methodReference); // use the scope name for external methods (like mscorlib.dll)
}
return String.Format("{0}!{1}", "[NullModule]", methodReference); // when there is no module info
// methodReference.DeclaringType.Scope.MetadataToken.
/*return String.Format("{0}!{1}",
((methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Name : "[NullModule]")
, methodReference); */
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference",true);
}
return null;
}
/// <summary>
/// Is other equal to this?
/// </summary>
public virtual bool Equals(IMemberReference other)
{
return Equals(other as MethodReference);
}
public OwnedParameterReference(IMemberReference member, int index)
{
if (member == null)
throw new ArgumentNullException("member");
this.memberReference = member;
this.index = index;
}
public ParameterDefinitionCollection(IMemberReference container)
{
m_container = container;
m_items = new ArrayList ();
}
private static void VerifyMatching(IMemberReference original, IMemberReference expected, params IMemberReference[] fails)
{
Assert.IsTrue(_comparer.MatchMembers(original, expected), "The original signature did not match the expected.");
Assert.IsTrue(_comparer.MatchMembers(expected, original), "The expected signature did not match the original.");
foreach (var fail in fails)
{
Assert.IsFalse(_comparer.MatchMembers(original, fail), original + " matched " + fail.FullName);
Assert.IsFalse(_comparer.MatchMembers(fail, original), fail.FullName + " matched " + original);
}
}
MethodBody[] GetMethodBodies (IMemberReference member)
{
if (member is MethodReference) {
return new[]{ (((MethodReference) member).Resolve ()).Body };
}
if (member is PropertyReference) {
PropertyDefinition prop = ((PropertyReference) member).Resolve ();
return new[]{
prop.GetMethod != null ? prop.GetMethod.Body : null,
prop.SetMethod != null ? prop.SetMethod.Body : null,
};
}
if (member is FieldReference)
return new MethodBody[]{};
if (member is EventReference) {
EventDefinition ev = ((EventReference) member).Resolve ();
return new[]{
ev.AddMethod != null ? ev.AddMethod.Body : null,
ev.InvokeMethod != null ? ev.InvokeMethod.Body : null,
ev.RemoveMethod != null ? ev.RemoveMethod.Body : null,
};
}
throw new NotSupportedException ("Unsupported member type: " + member.GetType().FullName);
}
private void CreateStack(AssemblyCompilerContext assemblyContext, IMemberReference method)
{
using (var runtime = assemblyContext.GetOutputFileWriter("stack.s"))
{
runtime.WriteLine(".globl _setup_stack");
runtime.WriteLine(" .def _setup_stack; .scl 2; .type 32; .endef");
runtime.WriteLine("_setup_stack:");
runtime.WriteLine(" movl %esp, %ecx");
runtime.WriteLine(" movl 4(%esp), %esp");
runtime.WriteLine(" call _{0}", method.Name);
runtime.WriteLine(" movl %ecx, %esp");
runtime.WriteLine(" ret");
}
}
/// <summary>
/// Is other equal to this?
/// </summary>
public override bool Equals(IMemberReference other)
{
return Equals(other as MethodDefinition);
}
/// <summary>
/// Determines whether two callable member references are considered equal according to their signatures.
/// </summary>
/// <param name="reference1">The first reference to compare.</param>
/// <param name="reference2">The second reference to compare.</param>
/// <returns><c>True</c> if the members are considered equal, <c>False</c> otherwise.</returns>
public bool MatchMembers(IMemberReference reference1, IMemberReference reference2)
{
if (reference1 == null && reference2 == null)
return true;
if (reference1 == null || reference2 == null)
return false;
var callable = reference1 as ICallableMemberReference;
if (callable != null)
return MatchMembers(callable, reference2 as ICallableMemberReference);
var type = reference1 as ITypeDefOrRef;
if (type != null)
return MatchMembers(type, reference1 as ITypeDefOrRef);
return false;
}
public ParameterDefinitionCollection (IMemberReference container)
{
m_container = container;
}
public AccessorOwnerMemberReference(IMemberReference accessorReference)
{
if (accessorReference == null)
throw new ArgumentNullException("accessorReference");
this.accessorReference = accessorReference;
}
public virtual bool Equals(IMemberReference other)
{
return (other is FieldReference)
&& Equals(other as FieldReference);
}
public override bool Equals(IMemberReference other)
{
return (other is FieldDefinition)
&& Equals(other as FieldDefinition);
}
/// <summary>
/// Is other equal to this?
/// </summary>
public bool Equals(IMemberReference other)
{
return Equals(other as ClassReference);
}
public IMemberReference ImportReference(IMemberReference reference)
{
var type = reference as ITypeDefOrRef;
if (type != null)
return ImportType(type);
var method = reference as MethodDefinition;
if (method != null)
return ImportMethod(method);
var field = reference as FieldDefinition;
if (field != null)
return ImportField(field);
var member = reference as MemberReference;
if (member != null)
return ImportMember(member);
throw new NotSupportedException("Invalid or unsupported reference.");
}
public MethodCalled(IMemberReference _memberReference, SequencePoint _sequencePoint)
{
memberReference = _memberReference;
sequencePoint = _sequencePoint;
}
private void WriteMemberReference(IMemberReference memberReference, IFormatter formatter)
{
IFieldReference fieldReference = memberReference as IFieldReference;
if (fieldReference != null)
{
this.WriteFieldReference(fieldReference, formatter);
}
IMethodReference methodReference = memberReference as IMethodReference;
if (methodReference != null)
{
this.WriteMethodReference(methodReference, formatter);
}
IPropertyReference propertyReference = memberReference as IPropertyReference;
if (propertyReference != null)
{
this.WritePropertyReference(propertyReference, formatter);
}
IEventReference eventReference = memberReference as IEventReference;
if (eventReference != null)
{
this.WriteEventReference(eventReference, formatter);
}
}
