mirror of https://github.com/icsharpcode/ILSpy.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
206 lines
7.5 KiB
206 lines
7.5 KiB
// Copyright (c) 2018 Siegfried Pammer |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of this |
|
// software and associated documentation files (the "Software"), to deal in the Software |
|
// without restriction, including without limitation the rights to use, copy, modify, merge, |
|
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons |
|
// to whom the Software is furnished to do so, subject to the following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included in all copies or |
|
// substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, |
|
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
|
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE |
|
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|
// DEALINGS IN THE SOFTWARE. |
|
|
|
using System.Reflection.Metadata; |
|
|
|
namespace ICSharpCode.Decompiler.Metadata |
|
{ |
|
public static class SignatureBlobComparer |
|
{ |
|
public static bool EqualsMethodSignature(BlobReader a, BlobReader b, MetadataReader contextForA, MetadataReader contextForB) |
|
{ |
|
return EqualsMethodSignature(ref a, ref b, contextForA, contextForB); |
|
} |
|
|
|
static bool EqualsMethodSignature(ref BlobReader a, ref BlobReader b, MetadataReader contextForA, MetadataReader contextForB) |
|
{ |
|
SignatureHeader header; |
|
// compare signature headers |
|
if (a.RemainingBytes == 0 || b.RemainingBytes == 0 || (header = a.ReadSignatureHeader()) != b.ReadSignatureHeader()) |
|
return false; |
|
if (header.IsGeneric) |
|
{ |
|
// read & compare generic parameter count |
|
if (!IsSameCompressedInteger(ref a, ref b, out _)) |
|
return false; |
|
} |
|
// read & compare parameter count |
|
if (!IsSameCompressedInteger(ref a, ref b, out int totalParameterCount)) |
|
return false; |
|
if (!IsSameCompressedInteger(ref a, ref b, out int typeCode)) |
|
return false; |
|
if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) |
|
return false; |
|
int i = 0; |
|
for (; i < totalParameterCount; i++) |
|
{ |
|
if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) |
|
return false; |
|
// varargs sentinel |
|
if (typeCode == 65) |
|
break; |
|
if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) |
|
return false; |
|
} |
|
for (; i < totalParameterCount; i++) |
|
{ |
|
if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) |
|
return false; |
|
if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) |
|
return false; |
|
} |
|
return true; |
|
} |
|
|
|
public static bool EqualsTypeSignature(BlobReader a, BlobReader b, MetadataReader contextForA, MetadataReader contextForB) |
|
{ |
|
return EqualsTypeSignature(ref a, ref b, contextForA, contextForB); |
|
} |
|
|
|
static bool EqualsTypeSignature(ref BlobReader a, ref BlobReader b, MetadataReader contextForA, MetadataReader contextForB) |
|
{ |
|
if (!IsSameCompressedInteger(ref a, ref b, out int typeCode)) |
|
return false; |
|
return TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode); |
|
} |
|
|
|
static bool IsSameCompressedInteger(ref BlobReader a, ref BlobReader b, out int value) |
|
{ |
|
return a.TryReadCompressedInteger(out value) && b.TryReadCompressedInteger(out int otherValue) && value == otherValue; |
|
} |
|
|
|
static bool IsSameCompressedSignedInteger(ref BlobReader a, ref BlobReader b, out int value) |
|
{ |
|
return a.TryReadCompressedSignedInteger(out value) && b.TryReadCompressedSignedInteger(out int otherValue) && value == otherValue; |
|
} |
|
|
|
static bool TypesAreEqual(ref BlobReader a, ref BlobReader b, MetadataReader contextForA, MetadataReader contextForB, int typeCode) |
|
{ |
|
switch (typeCode) |
|
{ |
|
case 0x1: // ELEMENT_TYPE_VOID |
|
case 0x2: // ELEMENT_TYPE_BOOLEAN |
|
case 0x3: // ELEMENT_TYPE_CHAR |
|
case 0x4: // ELEMENT_TYPE_I1 |
|
case 0x5: // ELEMENT_TYPE_U1 |
|
case 0x6: // ELEMENT_TYPE_I2 |
|
case 0x7: // ELEMENT_TYPE_U2 |
|
case 0x8: // ELEMENT_TYPE_I4 |
|
case 0x9: // ELEMENT_TYPE_U4 |
|
case 0xA: // ELEMENT_TYPE_I8 |
|
case 0xB: // ELEMENT_TYPE_U8 |
|
case 0xC: // ELEMENT_TYPE_R4 |
|
case 0xD: // ELEMENT_TYPE_R8 |
|
case 0xE: // ELEMENT_TYPE_STRING |
|
case 0x16: // ELEMENT_TYPE_TYPEDBYREF |
|
case 0x18: // ELEMENT_TYPE_I |
|
case 0x19: // ELEMENT_TYPE_U |
|
case 0x1C: // ELEMENT_TYPE_OBJECT |
|
return true; |
|
case 0xF: // ELEMENT_TYPE_PTR |
|
case 0x10: // ELEMENT_TYPE_BYREF |
|
case 0x45: // ELEMENT_TYPE_PINNED |
|
case 0x1D: // ELEMENT_TYPE_SZARRAY |
|
if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) |
|
return false; |
|
if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) |
|
return false; |
|
return true; |
|
case 0x1B: // ELEMENT_TYPE_FNPTR |
|
if (!EqualsMethodSignature(ref a, ref b, contextForA, contextForB)) |
|
return false; |
|
return true; |
|
case 0x14: // ELEMENT_TYPE_ARRAY |
|
// element type |
|
if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) |
|
return false; |
|
if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) |
|
return false; |
|
// rank |
|
if (!IsSameCompressedInteger(ref a, ref b, out _)) |
|
return false; |
|
// sizes |
|
if (!IsSameCompressedInteger(ref a, ref b, out int numOfSizes)) |
|
return false; |
|
for (int i = 0; i < numOfSizes; i++) |
|
{ |
|
if (!IsSameCompressedInteger(ref a, ref b, out _)) |
|
return false; |
|
} |
|
// lower bounds |
|
if (!IsSameCompressedInteger(ref a, ref b, out int numOfLowerBounds)) |
|
return false; |
|
for (int i = 0; i < numOfLowerBounds; i++) |
|
{ |
|
if (!IsSameCompressedSignedInteger(ref a, ref b, out _)) |
|
return false; |
|
} |
|
return true; |
|
case 0x1F: // ELEMENT_TYPE_CMOD_REQD |
|
case 0x20: // ELEMENT_TYPE_CMOD_OPT |
|
// modifier |
|
if (!TypeHandleEquals(ref a, ref b, contextForA, contextForB)) |
|
return false; |
|
// unmodified type |
|
if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) |
|
return false; |
|
if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) |
|
return false; |
|
return true; |
|
case 0x15: // ELEMENT_TYPE_GENERICINST |
|
// generic type |
|
if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) |
|
return false; |
|
if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) |
|
return false; |
|
if (!IsSameCompressedInteger(ref a, ref b, out int numOfArguments)) |
|
return false; |
|
for (int i = 0; i < numOfArguments; i++) |
|
{ |
|
if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) |
|
return false; |
|
if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) |
|
return false; |
|
} |
|
return true; |
|
case 0x13: // ELEMENT_TYPE_VAR |
|
case 0x1E: // ELEMENT_TYPE_MVAR |
|
// index |
|
if (!IsSameCompressedInteger(ref a, ref b, out _)) |
|
return false; |
|
return true; |
|
case 0x11: // ELEMENT_TYPE_VALUETYPE |
|
case 0x12: // ELEMENT_TYPE_CLASS |
|
if (!TypeHandleEquals(ref a, ref b, contextForA, contextForB)) |
|
return false; |
|
return true; |
|
default: |
|
return false; |
|
} |
|
} |
|
|
|
static bool TypeHandleEquals(ref BlobReader a, ref BlobReader b, MetadataReader contextForA, MetadataReader contextForB) |
|
{ |
|
var typeA = a.ReadTypeHandle(); |
|
var typeB = b.ReadTypeHandle(); |
|
if (typeA.IsNil || typeB.IsNil) |
|
return false; |
|
return typeA.GetFullTypeName(contextForA) == typeB.GetFullTypeName(contextForB); |
|
} |
|
} |
|
}
|
|
|