public LocalVariableDefinition[] ParseLocalsSignature()
{
if (_reader.ReadSignatureHeader().Kind != SignatureKind.LocalVariables)
{
throw new BadImageFormatException();
}
int count = _reader.ReadCompressedInteger();
LocalVariableDefinition[] locals;
if (count > 0)
{
locals = new LocalVariableDefinition[count];
for (int i = 0; i < count; i++)
{
bool isPinned = false;
SignatureTypeCode typeCode = ParseTypeCode();
if (typeCode == SignatureTypeCode.Pinned)
{
isPinned = true;
typeCode = ParseTypeCode();
}
locals[i] = new LocalVariableDefinition(ParseType(typeCode), isPinned);
}
}
else
{
locals = Array.Empty <LocalVariableDefinition>();
}
return(locals);
}
public LocalVariableDefinition[] ParseLocalsSignature()
{
if ((_reader.ReadByte() & 0xF) != 7) // IMAGE_CEE_CS_CALLCONV_LOCAL_SIG - add it to SignatureCallingConvention?
{
throw new BadImageFormatException();
}
int count = _reader.ReadCompressedInteger();
LocalVariableDefinition[] locals;
if (count > 0)
{
locals = new LocalVariableDefinition[count];
for (int i = 0; i < count; i++)
{
bool isPinned = false;
SignatureTypeCode typeCode = ParseTypeCode();
if (typeCode == SignatureTypeCode.Pinned)
{
isPinned = true;
typeCode = ParseTypeCode();
}
locals[i] = new LocalVariableDefinition(ParseType(typeCode), isPinned);
}
}
else
{
locals = Array.Empty <LocalVariableDefinition>();
}
return(locals);
}
private TypeSignature _addTypeCodePrefix(SignatureTypeCode code)
{
if (isByRef())
{
throw new InvalidOperationException("Cannot use a by-ref type as the element type of an array, pointer or by-ref type.");
}
int compactLength = (int)(m_compact >> 56);
if (compactLength < 7)
{
return(new TypeSignature((long)(compactLength + 1) << 56 | m_compact << 8 | (byte)code));
}
var builder = TypeSignatureBuilder.getInstance();
try {
builder.appendByte((byte)code);
builder.appendSignature(this);
return(builder.makeSignature());
}
finally {
builder.clear();
}
}
// Decodes a fixed argument type of a custom attribute from its constructor signature.
//
// Note that we do not decode the full constructor signature using DecodeMethodSignature
// but instead decode one parameter at a time as we read the value blob. This is both
// better perf-wise, but even more important is that we can't actually reason about
// a method signature with opaque TType values without adding some unnecessary chatter
// with the provider.
private ArgumentTypeInfo DecodeFixedArgumentType(ref BlobReader signatureReader, bool isElementType = false)
{
SignatureTypeCode signatureTypeCode = signatureReader.ReadSignatureTypeCode();
var info = new ArgumentTypeInfo
{
TypeCode = (SerializationTypeCode)signatureTypeCode,
};
switch (signatureTypeCode)
{
case SignatureTypeCode.Boolean:
case SignatureTypeCode.Byte:
case SignatureTypeCode.Char:
case SignatureTypeCode.Double:
case SignatureTypeCode.Int16:
case SignatureTypeCode.Int32:
case SignatureTypeCode.Int64:
case SignatureTypeCode.SByte:
case SignatureTypeCode.Single:
case SignatureTypeCode.String:
case SignatureTypeCode.UInt16:
case SignatureTypeCode.UInt32:
case SignatureTypeCode.UInt64:
info.Type = _provider.GetPrimitiveType((PrimitiveTypeCode)signatureTypeCode);
break;
case SignatureTypeCode.Object:
info.TypeCode = SerializationTypeCode.TaggedObject;
info.Type = _provider.GetPrimitiveType(PrimitiveTypeCode.Object);
break;
case SignatureTypeCode.TypeHandle:
// Parameter is type def or ref and is only allowed to be System.Type or Enum.
EntityHandle handle = signatureReader.ReadTypeHandle();
info.Type = GetTypeFromHandle(handle);
info.TypeCode = _provider.IsSystemType(info.Type) ? SerializationTypeCode.Type : (SerializationTypeCode)_provider.GetUnderlyingEnumType(info.Type);
break;
case SignatureTypeCode.SZArray:
if (isElementType)
{
// jagged arrays are not allowed.
throw new BadImageFormatException();
}
var elementInfo = DecodeFixedArgumentType(ref signatureReader, isElementType: true);
info.ElementType = elementInfo.Type;
info.ElementTypeCode = elementInfo.TypeCode;
info.Type = _provider.GetSZArrayType(info.ElementType);
break;
default:
throw new BadImageFormatException();
}
return(info);
}
private void InspectFields(FieldDefinitionHandleCollection fields)
{
foreach (var fieldHandle in fields)
{
var inspectorField = new InspectorField();
var fieldDef = metaReader.GetFieldDefinition(fieldHandle);
var customAttr = fieldDef.GetCustomAttributes();
foreach (var caHandle in customAttr)
{
// Look for InspectorAttribute
if (DecodeCustomAttribute(caHandle, inspectorField))
{
BlobReader sigReader = metaReader.GetBlobReader(fieldDef.Signature);
SignatureHeader header = sigReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Field)
{
continue;
}
var typeCode = sigReader.ReadSignatureTypeCode();
string typeName = typeCode.ToString();
if (typeCode == SignatureTypeCode.SZArray)
{
inspectorField.IsArray = true;
SignatureTypeCode code = sigReader.ReadSignatureTypeCode();
if (code == SignatureTypeCode.TypeHandle)
{
bool isEnum;
DecodeTypeHandleTypeName(sigReader, out typeName, out isEnum);
}
else
{
typeName = code.ToString();
}
}
else if (typeCode == SignatureTypeCode.TypeHandle)
{
bool isEnum;
DecodeTypeHandleTypeName(sigReader, out typeName, out isEnum);
inspectorField.IsEnum = isEnum;
}
inspectorField.TypeName = typeName;
inspectorField.Name = metaReader.GetString(fieldDef.Name);
_inspectorComponent.Fields[inspectorField.Name] = inspectorField;
break;
}
}
}
}
private TypeSignature DecodeType(ref BlobReader signatureReader, SignatureTypeCode typeCode)
{
switch (typeCode)
{
case SignatureTypeCode.TypeHandle:
{
int typeArgumentOffset = 0;
return(DecodeType(signatureReader.ReadTypeHandle(), ImmutableArray <TypeSignature> .Empty, ref typeArgumentOffset));
}
case SignatureTypeCode.Array:
{
var elementType = DecodeModifiersAndType(ref signatureReader);
int rank;
int sizes;
signatureReader.TryReadCompressedInteger(out rank);
signatureReader.TryReadCompressedInteger(out sizes);
if (sizes != 0)
{
throw UnhandledMetadata();
}
return(new ArrayTypeSignature(elementType, rank));
}
case SignatureTypeCode.SZArray:
{
var elementType = DecodeModifiersAndType(ref signatureReader);
return(new ArrayTypeSignature(elementType, 1));
}
case SignatureTypeCode.GenericTypeInstance:
return(DecodeGenericTypeInstance(ref signatureReader));
case SignatureTypeCode.Pointer:
{
var pointedAtType = DecodeModifiersAndType(ref signatureReader);
return(new PointerTypeSignature(pointedAtType));
}
case SignatureTypeCode.GenericTypeParameter:
return(DecodeGenericTypeParameter(ref signatureReader, _allTypeParameters, _containingArity));
case SignatureTypeCode.GenericMethodParameter:
return(DecodeGenericTypeParameter(ref signatureReader, _methodTypeParameters, 0));
default:
{
var signature = typeCode.ToSpecialType().GetTypeSignature();
if (signature == null)
{
throw UnhandledMetadata();
}
return(signature);
}
}
}
public CustomAttributeValue <TType> DecodeValue(EntityHandle constructor, BlobHandle value)
{
BlobHandle signature;
switch (constructor.Kind)
{
case HandleKind.MethodDefinition:
MethodDefinition definition = _reader.GetMethodDefinition((MethodDefinitionHandle)constructor);
signature = definition.Signature;
break;
case HandleKind.MemberReference:
MemberReference reference = _reader.GetMemberReference((MemberReferenceHandle)constructor);
signature = reference.Signature;
break;
default:
throw new BadImageFormatException();
}
BlobReader signatureReader = _reader.GetBlobReader(signature);
BlobReader valueReader = _reader.GetBlobReader(value);
ushort prolog = valueReader.ReadUInt16();
if (prolog != 1)
{
throw new BadImageFormatException();
}
SignatureHeader header = signatureReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Method || header.IsGeneric)
{
throw new BadImageFormatException();
}
int parameterCount = signatureReader.ReadCompressedInteger();
SignatureTypeCode returnType = signatureReader.ReadSignatureTypeCode();
if (returnType != SignatureTypeCode.Void)
{
throw new BadImageFormatException();
}
ImmutableArray <CustomAttributeTypedArgument <TType> > fixedArguments = DecodeFixedArguments(ref signatureReader, ref valueReader, parameterCount);
ImmutableArray <CustomAttributeNamedArgument <TType> > namedArguments = DecodeNamedArguments(ref valueReader);
return(new CustomAttributeValue <TType>(fixedArguments, namedArguments));
}
private static bool IsByRef(ImmutableArray <byte> signature, ref int position)
{
SignatureTypeCode typeCode = (SignatureTypeCode)signature[position];
if (typeCode == SignatureTypeCode.ByReference)
{
position++;
return(true);
}
else
{
return(false);
}
}
// cf. MetadataDecoder<>.DecodeTypeOrThrow.
private TypeSignature DecodeType(ref BlobReader signatureReader, SignatureTypeCode typeCode)
{
switch (typeCode)
{
case SignatureTypeCode.TypeHandle:
{
int typeArgumentOffset = 0;
return DecodeType(signatureReader.ReadTypeHandle(), ImmutableArray<TypeSignature>.Empty, ref typeArgumentOffset);
}
case SignatureTypeCode.Array:
{
var elementType = DecodeModifiersAndType(ref signatureReader);
int rank;
int sizes;
signatureReader.TryReadCompressedInteger(out rank);
signatureReader.TryReadCompressedInteger(out sizes);
if (sizes != 0)
{
throw UnhandledMetadata();
}
return new ArrayTypeSignature(elementType, rank);
}
case SignatureTypeCode.SZArray:
{
var elementType = DecodeModifiersAndType(ref signatureReader);
return new ArrayTypeSignature(elementType, 1);
}
case SignatureTypeCode.GenericTypeInstance:
return DecodeGenericTypeInstance(ref signatureReader);
case SignatureTypeCode.Pointer:
{
var pointedAtType = DecodeModifiersAndType(ref signatureReader);
return new PointerTypeSignature(pointedAtType);
}
case SignatureTypeCode.GenericTypeParameter:
return DecodeGenericTypeParameter(ref signatureReader, _allTypeParameters, _containingArity);
case SignatureTypeCode.GenericMethodParameter:
return DecodeGenericTypeParameter(ref signatureReader, _methodTypeParameters, 0);
default:
{
var signature = typeCode.ToSpecialType().GetTypeSignature();
if (signature == null)
{
throw UnhandledMetadata();
}
return signature;
}
}
}
private static string GetTypeName(SignatureTypeCode typeCode)
{
switch (typeCode)
{
case SignatureTypeCode.Boolean: return("[bool]");
case SignatureTypeCode.Int32: return("[int]");
case SignatureTypeCode.String: return("[string]");
case SignatureTypeCode.Object: return("[object]");
default: return(null);
}
}
private TypeDesc ParseType(SignatureTypeCode typeCode)
{
if (_indexStack != null)
{
int was = _indexStack.Pop();
_indexStack.Push(was + 1);
_indexStack.Push(0);
}
TypeDesc result = ParseTypeImpl(typeCode);
if (_indexStack != null)
{
_indexStack.Pop();
}
return(result);
}
private SignatureTypeCode ParseTypeCode(bool skipPinned = true)
{
if (_indexStack != null)
{
int was = _indexStack.Pop();
_indexStack.Push(was + 1);
_indexStack.Push(0);
}
SignatureTypeCode result = ParseTypeCodeImpl(skipPinned);
if (_indexStack != null)
{
_indexStack.Pop();
}
return(result);
}
private SignatureTypeCode ParseTypeCode()
{
for (;;)
{
SignatureTypeCode typeCode = _reader.ReadSignatureTypeCode();
if (typeCode != SignatureTypeCode.RequiredModifier && typeCode != SignatureTypeCode.OptionalModifier)
{
return(typeCode);
}
_reader.ReadTypeHandle();
// _hasModifiers = true;
}
}
private CilEntity GetTypeEntity()
{
BlobReader blobReader = _readers.MdReader.GetBlobReader(_typeSpecification.Signature);
SignatureTypeCode typeCode = blobReader.ReadSignatureTypeCode();
while (typeCode == SignatureTypeCode.GenericTypeInstance)
{
typeCode = blobReader.ReadSignatureTypeCode();
}
if (typeCode == SignatureTypeCode.TypeHandle)
{
Handle handle = blobReader.ReadTypeHandle();
return(CilDecoder.DecodeEntityHandle((EntityHandle)handle, ref _readers));
}
return(new CilEntity(null, EntityKind.TypeSpecification));
}
private static void ParseType(ImmutableArray <byte> .Builder builder, Stream stream, bool allowByRef = false)
{
while (true)
{
SignatureTypeCode typeCode = (SignatureTypeCode)stream.ReadByte();
builder.Add((byte)typeCode);
switch (typeCode)
{
default:
throw ExceptionUtilities.UnexpectedValue(typeCode);
case SignatureTypeCode.TypeHandle:
ParseTypeHandle(builder, stream);
return;
case SignatureTypeCode.GenericTypeParameter:
case SignatureTypeCode.GenericMethodParameter:
builder.Add((byte)stream.ReadByte());
return;
case SignatureTypeCode.ByReference:
if (!allowByRef)
{
goto default;
}
break;
case SignatureTypeCode.SZArray:
break;
case SignatureTypeCode.Pointer:
break;
case SignatureTypeCode.GenericTypeInstance:
ParseGenericTypeInstance(builder, stream);
return;
}
allowByRef = false;
}
}
private SignatureTypeCode ParseTypeCodeImpl(bool skipPinned = true)
{
for (; ;)
{
SignatureTypeCode typeCode = _reader.ReadSignatureTypeCode();
if (typeCode == SignatureTypeCode.RequiredModifier)
{
EntityHandle typeHandle = _reader.ReadTypeHandle();
if (_embeddedSignatureDataList != null)
{
_embeddedSignatureDataList.Add(new EmbeddedSignatureData {
index = string.Join(".", _indexStack), kind = EmbeddedSignatureDataKind.RequiredCustomModifier, type = ResolveHandle(typeHandle)
});
}
continue;
}
if (typeCode == SignatureTypeCode.OptionalModifier)
{
EntityHandle typeHandle = _reader.ReadTypeHandle();
if (_embeddedSignatureDataList != null)
{
_embeddedSignatureDataList.Add(new EmbeddedSignatureData {
index = string.Join(".", _indexStack), kind = EmbeddedSignatureDataKind.OptionalCustomModifier, type = ResolveHandle(typeHandle)
});
}
continue;
}
// TODO: treat PINNED in the signature same as modopts (it matters
// in signature matching - you can actually define overloads on this)
if (skipPinned && typeCode == SignatureTypeCode.Pinned)
{
continue;
}
return(typeCode);
}
}
private bool MatchParameter(ParameterSymbol parameter, ImmutableArray <byte> signature, ref int position)
{
SignatureTypeCode typeCode = (SignatureTypeCode)signature[position];
bool isByRef;
if (typeCode == SignatureTypeCode.ByReference)
{
isByRef = true;
position++;
}
else
{
isByRef = false;
}
if (IsByRefParam(parameter) != isByRef)
{
return(false);
}
return(MatchType(GetParamType(parameter), signature, ref position));
}
public SignatureType(ref BlobReader signatureReader, MetadataReader mdReader, GenericParameterHandleCollection genericParams)
{
SignatureTypeCode signatureTypeCode = signatureReader.ReadSignatureTypeCode();
Flags = 0;
if (signatureTypeCode == SignatureTypeCode.SZArray)
{
Flags |= SignatureTypeFlags.ARRAY;
signatureTypeCode = signatureReader.ReadSignatureTypeCode();
}
TypeName = signatureTypeCode.ToString();
if (signatureTypeCode == SignatureTypeCode.TypeHandle || signatureTypeCode == SignatureTypeCode.ByReference)
{
if (signatureTypeCode == SignatureTypeCode.ByReference)
{
Flags |= SignatureTypeFlags.REFERENCE;
}
EntityHandle handle = signatureReader.ReadTypeHandle();
if (handle.Kind == HandleKind.TypeDefinition)
{
TypeDefinition typeDef = mdReader.GetTypeDefinition((TypeDefinitionHandle)handle);
TypeName = mdReader.GetString(typeDef.Name);
}
else if (handle.Kind == HandleKind.TypeReference)
{
TypeReference typeRef = mdReader.GetTypeReference((TypeReferenceHandle)handle);
TypeName = mdReader.GetString(typeRef.Name);
}
}
else if (signatureTypeCode == SignatureTypeCode.GenericMethodParameter)
{
int index = signatureReader.ReadCompressedInteger();
GenericParameter generic = mdReader.GetGenericParameter(genericParams[index]);
TypeName = mdReader.GetString(generic.Name);
Flags |= SignatureTypeFlags.GENERIC;
}
}
public SignatureType(ref BlobReader signatureReader, ref MetadataReader mdReader)
{
SignatureTypeCode = signatureReader.ReadSignatureTypeCode();
IsArray = (SignatureTypeCode == SignatureTypeCode.SZArray);
if (IsArray)
{
SignatureTypeCode = signatureReader.ReadSignatureTypeCode();
}
ClassName = SignatureTypeCode.ToString();
if (SignatureTypeCode == SignatureTypeCode.TypeHandle || SignatureTypeCode == SignatureTypeCode.ByReference)
{
EntityHandle handle = signatureReader.ReadTypeHandle();
if (handle.Kind == HandleKind.TypeDefinition)
{
var typeDef = mdReader.GetTypeDefinition((TypeDefinitionHandle)handle);
ClassName = mdReader.GetString(typeDef.Name);
}
else if (handle.Kind == HandleKind.TypeReference)
{
var typeRef = mdReader.GetTypeReference((TypeReferenceHandle)handle);
ClassName = mdReader.GetString(typeRef.Name);
}
}
}
private SignatureTypeCode ParseTypeCode(bool skipPinned = true)
{
for (;;)
{
SignatureTypeCode typeCode = _reader.ReadSignatureTypeCode();
// TODO: actually consume modopts
if (typeCode == SignatureTypeCode.RequiredModifier ||
typeCode == SignatureTypeCode.OptionalModifier)
{
_reader.ReadTypeHandle();
continue;
}
// TODO: treat PINNED in the signature same as modopts (it matters
// in signature matching - you can actually define overloads on this)
if (skipPinned && typeCode == SignatureTypeCode.Pinned)
{
continue;
}
return(typeCode);
}
}
/// <summary>
/// Does pretty much the same thing as MetadataDecoder.DecodeType only instead of
/// producing a type symbol it compares encoded type to the target.
///
/// Signature should be in format described in MemberDescriptor.
/// </summary>
private bool MatchType(TypeSymbol type, ImmutableArray <byte> signature, ref int position)
{
if (type == null)
{
return(false);
}
int paramPosition;
// Get the type.
SignatureTypeCode typeCode = (SignatureTypeCode)signature[position++];
// Switch on the type.
switch (typeCode)
{
case SignatureTypeCode.TypeHandle:
// Ecma-335 spec:
// 23.1.16 Element types used in signatures
// ...
// ELEMENT_TYPE_VALUETYPE 0x11 Followed by TypeDef or TypeRef token
// ELEMENT_TYPE_CLASS 0x12 Followed by TypeDef or TypeRef token
return(MatchTypeToTypeId(type, signature[position++]));
case SignatureTypeCode.Array:
if (!MatchType(GetArrayElementType(type), signature, ref position))
{
return(false);
}
int countOfDimensions = signature[position++];
return(MatchArrayRank(type, countOfDimensions));
case SignatureTypeCode.SZArray:
return(MatchType(GetSZArrayElementType(type), signature, ref position));
case SignatureTypeCode.Pointer:
return(MatchType(GetPointedToType(type), signature, ref position));
case SignatureTypeCode.GenericTypeParameter:
paramPosition = signature[position++];
return(IsGenericTypeParam(type, paramPosition));
case SignatureTypeCode.GenericMethodParameter:
paramPosition = signature[position++];
return(IsGenericMethodTypeParam(type, paramPosition));
case SignatureTypeCode.GenericTypeInstance:
if (!MatchType(GetGenericTypeDefinition(type), signature, ref position))
{
return(false);
}
int argumentCount = signature[position++];
for (int argumentIndex = 0; argumentIndex < argumentCount; argumentIndex++)
{
if (!MatchType(GetGenericTypeArgument(type, argumentIndex), signature, ref position))
{
return(false);
}
}
return(true);
default:
throw ExceptionUtilities.UnexpectedValue(typeCode);
}
}
private void EncodeType(BlobBuilder blobBuilder, TypeDesc type)
{
if (type.IsPrimitive)
{
SignatureTypeCode primitiveCode;
switch (type.Category)
{
case TypeFlags.Void:
primitiveCode = SignatureTypeCode.Void;
break;
case TypeFlags.Boolean:
primitiveCode = SignatureTypeCode.Boolean;
break;
case TypeFlags.Char:
primitiveCode = SignatureTypeCode.Char;
break;
case TypeFlags.SByte:
primitiveCode = SignatureTypeCode.SByte;
break;
case TypeFlags.Byte:
primitiveCode = SignatureTypeCode.Byte;
break;
case TypeFlags.Int16:
primitiveCode = SignatureTypeCode.Int16;
break;
case TypeFlags.UInt16:
primitiveCode = SignatureTypeCode.UInt16;
break;
case TypeFlags.Int32:
primitiveCode = SignatureTypeCode.Int32;
break;
case TypeFlags.UInt32:
primitiveCode = SignatureTypeCode.UInt32;
break;
case TypeFlags.Int64:
primitiveCode = SignatureTypeCode.Int64;
break;
case TypeFlags.UInt64:
primitiveCode = SignatureTypeCode.UInt64;
break;
case TypeFlags.IntPtr:
primitiveCode = SignatureTypeCode.IntPtr;
break;
case TypeFlags.UIntPtr:
primitiveCode = SignatureTypeCode.UIntPtr;
break;
case TypeFlags.Single:
primitiveCode = SignatureTypeCode.Single;
break;
case TypeFlags.Double:
primitiveCode = SignatureTypeCode.Double;
break;
default:
throw new Exception("Unknown primitive type");
}
blobBuilder.WriteByte((byte)primitiveCode);
}
else if (type.IsSzArray)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.SZArray);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsArray)
{
var arrayType = (ArrayType)type;
blobBuilder.WriteByte((byte)SignatureTypeCode.Array);
EncodeType(blobBuilder, type.GetParameterType());
var shapeEncoder = new ArrayShapeEncoder(blobBuilder);
// TODO Add support for non-standard array shapes
shapeEncoder.Shape(arrayType.Rank, default(ImmutableArray <int>), default(ImmutableArray <int>));
}
else if (type.IsPointer)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Pointer);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsFunctionPointer)
{
FunctionPointerType fnptrType = (FunctionPointerType)type;
EncodeMethodSignature(blobBuilder, fnptrType.Signature);
}
else if (type.IsByRef)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.ByReference);
EncodeType(blobBuilder, type.GetParameterType());
}
else if (type.IsObject)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Object);
}
else if (type.IsString)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.String);
}
else if (type.IsWellKnownType(WellKnownType.TypedReference))
{
blobBuilder.WriteByte((byte)SignatureTypeCode.TypedReference);
}
else if (type.IsWellKnownType(WellKnownType.Void))
{
blobBuilder.WriteByte((byte)SignatureTypeCode.Void);
}
else if (type is SignatureVariable)
{
SignatureVariable sigVar = (SignatureVariable)type;
SignatureTypeCode code = sigVar.IsMethodSignatureVariable ? SignatureTypeCode.GenericMethodParameter : SignatureTypeCode.GenericTypeParameter;
blobBuilder.WriteByte((byte)code);
blobBuilder.WriteCompressedInteger(sigVar.Index);
}
else if (type is InstantiatedType)
{
blobBuilder.WriteByte((byte)SignatureTypeCode.GenericTypeInstance);
EncodeType(blobBuilder, type.GetTypeDefinition());
blobBuilder.WriteCompressedInteger(type.Instantiation.Length);
foreach (var instantiationArg in type.Instantiation)
{
EncodeType(blobBuilder, instantiationArg);
}
}
else if (type is MetadataType)
{
var metadataType = (MetadataType)type;
// Must be class or valuetype
blobBuilder.WriteByte(type.IsValueType ? (byte)SignatureTypeKind.ValueType : (byte)SignatureTypeKind.Class);
int codedIndex = CodedIndex.TypeDefOrRef(GetTypeRef(metadataType));
blobBuilder.WriteCompressedInteger(codedIndex);
}
else
{
throw new Exception("Unexpected type");
}
}
private bool DecodeCustomAttribute(CustomAttributeHandle caHandle, InspectorField inspectorField)
{
// GetCustomAttribute: https://github.com/dotnet/roslyn/blob/master/src/Compilers/Core/Portable/MetadataReader/MetadataDecoder.cs#L1370
// Custom Attribute
var ca = metaReader.GetCustomAttribute(caHandle);
// MethodDefinitionHandle or MemberReferenceHandle
if (ca.Constructor.Kind != HandleKind.MemberReference)
{
Console.WriteLine("ca.Constructor.Kind != HandleKind.MemberReference");
return(false);
}
// constructor of the custom attr which contains the signature
var memberRef = metaReader.GetMemberReference((MemberReferenceHandle)ca.Constructor);
// parent of the constructor is the TypeReference
var parent = memberRef.Parent;
if (parent.Kind != HandleKind.TypeReference)
{
Console.WriteLine("parent.Kind != HandleKind.TypeReference");
return(false);
}
var parentTypeRef = metaReader.GetTypeReference((TypeReferenceHandle)parent);
// check whether we have an InspectorAttribute
if (metaReader.GetString(parentTypeRef.Name) != "InspectorAttribute")
{
//Console.WriteLine("parentTypeRef != InspectorAttribute");
return(false);
}
// args
var argsReader = metaReader.GetBlobReader((BlobHandle)ca.Value);
uint prolog = argsReader.ReadUInt16();
if (prolog != 1)
{
Console.WriteLine("prolog != 1");
return(false);
}
// sig reader is on constructor
BlobReader sigReader = metaReader.GetBlobReader(memberRef.Signature);
SignatureHeader header = sigReader.ReadSignatureHeader();
// Get the type parameter count.
if (header.IsGeneric && sigReader.ReadCompressedInteger() != 0)
{
Console.WriteLine("header.IsGeneric && sigReader.ReadCompressedInteger() != 0");
return(false);
}
// Get the parameter count
int paramCount = sigReader.ReadCompressedInteger();
// Get the type return type.
var returnTypeCode = sigReader.ReadSignatureTypeCode();
if (returnTypeCode != SignatureTypeCode.Void)
{
Console.WriteLine("returnTypeCode != SignatureTypeCode.Void");
return(false);
}
List <SignatureTypeCode> sigTypeCodes = new List <SignatureTypeCode>();
// position args
for (int i = 0; i < paramCount; i++)
{
SignatureTypeCode paramTypeCode = sigReader.ReadSignatureTypeCode();
// support string custom attr for now to simplify things
if (paramTypeCode != SignatureTypeCode.String)
{
return(false);
}
string value;
if (CrackStringInAttributeValue(out value, ref argsReader))
{
inspectorField.CustomAttrPositionalArgs.Add(value);
}
sigTypeCodes.Add(paramTypeCode);
}
// named args
short namedParamCount = argsReader.ReadInt16();
for (short i = 0; i < namedParamCount; i++)
{
// Ecma-335 23.3 - A NamedArg is simply a FixedArg preceded by information to identify which field or
// property it represents. [Note: Recall that the CLI allows fields and properties to have the same name; so
// we require a means to disambiguate such situations. end note] FIELD is the single byte 0x53. PROPERTY is
// the single byte 0x54.
// https://github.com/dotnet/roslyn/blob/master/src/Compilers/Core/Portable/MetadataReader/MetadataDecoder.cs#L1305
var kind = (CustomAttributeNamedArgumentKind)argsReader.ReadCompressedInteger();
if (kind != CustomAttributeNamedArgumentKind.Field && kind != CustomAttributeNamedArgumentKind.Property)
{
return(false);
}
var typeCode = argsReader.ReadSerializationTypeCode();
// support string/int custom attr for now to simplify things
if (typeCode != SerializationTypeCode.String && typeCode != SerializationTypeCode.Int32)
{
return(false);
}
string name;
if (!CrackStringInAttributeValue(out name, ref argsReader))
{
return(false);
}
if (typeCode == SerializationTypeCode.Int32)
{
int value;
value = argsReader.ReadInt32();
inspectorField.CustomAttrNamedArgs[name] = value.ToString();
}
else
{
string value;
if (!CrackStringInAttributeValue(out value, ref argsReader))
{
return(false);
}
inspectorField.CustomAttrNamedArgs[name] = value;
}
}
return(true);
}
private T WriteTypeCode(SignatureTypeCode value)
{
Builder.WriteByte((byte)value);
return(_continuation);
}
internal static SpecialType ToSpecialType(this SignatureTypeCode typeCode)
{
switch (typeCode)
{
case SignatureTypeCode.TypedReference:
return(SpecialType.System_TypedReference);
case SignatureTypeCode.Void:
return(SpecialType.System_Void);
case SignatureTypeCode.Boolean:
return(SpecialType.System_Boolean);
case SignatureTypeCode.SByte:
return(SpecialType.System_SByte);
case SignatureTypeCode.Byte:
return(SpecialType.System_Byte);
case SignatureTypeCode.Int16:
return(SpecialType.System_Int16);
case SignatureTypeCode.UInt16:
return(SpecialType.System_UInt16);
case SignatureTypeCode.Int32:
return(SpecialType.System_Int32);
case SignatureTypeCode.UInt32:
return(SpecialType.System_UInt32);
case SignatureTypeCode.Int64:
return(SpecialType.System_Int64);
case SignatureTypeCode.UInt64:
return(SpecialType.System_UInt64);
case SignatureTypeCode.Single:
return(SpecialType.System_Single);
case SignatureTypeCode.Double:
return(SpecialType.System_Double);
case SignatureTypeCode.Char:
return(SpecialType.System_Char);
case SignatureTypeCode.String:
return(SpecialType.System_String);
case SignatureTypeCode.IntPtr:
return(SpecialType.System_IntPtr);
case SignatureTypeCode.UIntPtr:
return(SpecialType.System_UIntPtr);
case SignatureTypeCode.Object:
return(SpecialType.System_Object);
default:
throw ExceptionUtilities.UnexpectedValue(typeCode);
}
}
public CustomAttributeValue <TType> DecodeValue(EntityHandle constructor, BlobHandle value)
{
BlobHandle signature;
BlobHandle attributeOwningTypeSpec = default;
switch (constructor.Kind)
{
case HandleKind.MethodDefinition:
MethodDefinition definition = _reader.GetMethodDefinition((MethodDefinitionHandle)constructor);
signature = definition.Signature;
break;
case HandleKind.MemberReference:
MemberReference reference = _reader.GetMemberReference((MemberReferenceHandle)constructor);
signature = reference.Signature;
// If this is a generic attribute, we'll need its instantiation to decode the signatures
if (reference.Parent.Kind == HandleKind.TypeSpecification)
{
TypeSpecification genericOwner = _reader.GetTypeSpecification((TypeSpecificationHandle)reference.Parent);
attributeOwningTypeSpec = genericOwner.Signature;
}
break;
default:
throw new BadImageFormatException();
}
BlobReader signatureReader = _reader.GetBlobReader(signature);
BlobReader valueReader = _reader.GetBlobReader(value);
ushort prolog = valueReader.ReadUInt16();
if (prolog != 1)
{
throw new BadImageFormatException();
}
SignatureHeader header = signatureReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Method || header.IsGeneric)
{
throw new BadImageFormatException();
}
int parameterCount = signatureReader.ReadCompressedInteger();
SignatureTypeCode returnType = signatureReader.ReadSignatureTypeCode();
if (returnType != SignatureTypeCode.Void)
{
throw new BadImageFormatException();
}
BlobReader genericContextReader = default;
if (!attributeOwningTypeSpec.IsNil)
{
// If this is a generic attribute, grab the instantiation arguments so that we can
// interpret the constructor signature, should it refer to the generic context.
genericContextReader = _reader.GetBlobReader(attributeOwningTypeSpec);
if (genericContextReader.ReadSignatureTypeCode() == SignatureTypeCode.GenericTypeInstance)
{
int kind = genericContextReader.ReadCompressedInteger();
if (kind != (int)SignatureTypeKind.Class && kind != (int)SignatureTypeKind.ValueType)
{
throw new BadImageFormatException();
}
genericContextReader.ReadTypeHandle();
// At this point, the reader points to the "GenArgCount Type Type*" part of the signature.
}
else
{
// Some other invalid TypeSpec. Don't accidentally allow resolving generic parameters
// from the constructor signature into a broken blob.
genericContextReader = default;
}
}
ImmutableArray <CustomAttributeTypedArgument <TType> > fixedArguments = DecodeFixedArguments(ref signatureReader, ref valueReader, parameterCount, genericContextReader);
ImmutableArray <CustomAttributeNamedArgument <TType> > namedArguments = DecodeNamedArguments(ref valueReader);
return(new CustomAttributeValue <TType>(fixedArguments, namedArguments));
}
private TypeDesc ParseTypeImpl(SignatureTypeCode typeCode)
{
// Switch on the type.
switch (typeCode)
{
case SignatureTypeCode.Void:
return(GetWellKnownType(WellKnownType.Void));
case SignatureTypeCode.Boolean:
return(GetWellKnownType(WellKnownType.Boolean));
case SignatureTypeCode.SByte:
return(GetWellKnownType(WellKnownType.SByte));
case SignatureTypeCode.Byte:
return(GetWellKnownType(WellKnownType.Byte));
case SignatureTypeCode.Int16:
return(GetWellKnownType(WellKnownType.Int16));
case SignatureTypeCode.UInt16:
return(GetWellKnownType(WellKnownType.UInt16));
case SignatureTypeCode.Int32:
return(GetWellKnownType(WellKnownType.Int32));
case SignatureTypeCode.UInt32:
return(GetWellKnownType(WellKnownType.UInt32));
case SignatureTypeCode.Int64:
return(GetWellKnownType(WellKnownType.Int64));
case SignatureTypeCode.UInt64:
return(GetWellKnownType(WellKnownType.UInt64));
case SignatureTypeCode.Single:
return(GetWellKnownType(WellKnownType.Single));
case SignatureTypeCode.Double:
return(GetWellKnownType(WellKnownType.Double));
case SignatureTypeCode.Char:
return(GetWellKnownType(WellKnownType.Char));
case SignatureTypeCode.String:
return(GetWellKnownType(WellKnownType.String));
case SignatureTypeCode.IntPtr:
return(GetWellKnownType(WellKnownType.IntPtr));
case SignatureTypeCode.UIntPtr:
return(GetWellKnownType(WellKnownType.UIntPtr));
case SignatureTypeCode.Object:
return(GetWellKnownType(WellKnownType.Object));
case SignatureTypeCode.TypeHandle:
return(ResolveHandle(_reader.ReadTypeHandle()));
case SignatureTypeCode.SZArray:
{
var elementType = ParseType();
if (elementType == null)
{
return(null);
}
return(_tsc.GetArrayType(elementType));
}
case SignatureTypeCode.Array:
{
var elementType = ParseType();
var rank = _reader.ReadCompressedInteger();
// TODO: Bounds for multi-dimmensional arrays
var boundsCount = _reader.ReadCompressedInteger();
for (int i = 0; i < boundsCount; i++)
{
_reader.ReadCompressedInteger();
}
var lowerBoundsCount = _reader.ReadCompressedInteger();
for (int j = 0; j < lowerBoundsCount; j++)
{
_reader.ReadCompressedInteger();
}
if (elementType != null)
{
return(_tsc.GetArrayType(elementType, rank));
}
else
{
return(null);
}
}
case SignatureTypeCode.ByReference:
{
TypeDesc byRefedType = ParseType();
if (byRefedType != null)
{
return(byRefedType.MakeByRefType());
}
else
{
return(null);
}
}
case SignatureTypeCode.Pointer:
{
TypeDesc pointedAtType = ParseType();
if (pointedAtType != null)
{
return(_tsc.GetPointerType(pointedAtType));
}
else
{
return(null);
}
}
case SignatureTypeCode.GenericTypeParameter:
return(_tsc.GetSignatureVariable(_reader.ReadCompressedInteger(), false));
case SignatureTypeCode.GenericMethodParameter:
return(_tsc.GetSignatureVariable(_reader.ReadCompressedInteger(), true));
case SignatureTypeCode.GenericTypeInstance:
{
TypeDesc typeDef = ParseType();
MetadataType metadataTypeDef = null;
if (typeDef != null)
{
metadataTypeDef = typeDef as MetadataType;
if (metadataTypeDef == null)
{
throw new BadImageFormatException();
}
}
TypeDesc[] instance = new TypeDesc[_reader.ReadCompressedInteger()];
for (int i = 0; i < instance.Length; i++)
{
instance[i] = ParseType();
if (instance[i] == null)
{
metadataTypeDef = null;
}
}
if (metadataTypeDef != null)
{
return(_tsc.GetInstantiatedType(metadataTypeDef, new Instantiation(instance)));
}
else
{
return(null);
}
}
case SignatureTypeCode.TypedReference:
return(GetWellKnownType(WellKnownType.TypedReference));
case SignatureTypeCode.FunctionPointer:
MethodSignature sig = ParseMethodSignatureInternal(skipEmbeddedSignatureData: true);
if (sig != null)
{
return(_tsc.GetFunctionPointerType(sig));
}
else
{
return(null);
}
default:
throw new BadImageFormatException();
}
}
private TypeDesc ParseType(SignatureTypeCode typeCode)
{
// Switch on the type.
switch (typeCode)
{
case SignatureTypeCode.Void:
return(GetWellKnownType(WellKnownType.Void));
case SignatureTypeCode.Boolean:
return(GetWellKnownType(WellKnownType.Boolean));
case SignatureTypeCode.SByte:
return(GetWellKnownType(WellKnownType.SByte));
case SignatureTypeCode.Byte:
return(GetWellKnownType(WellKnownType.Byte));
case SignatureTypeCode.Int16:
return(GetWellKnownType(WellKnownType.Int16));
case SignatureTypeCode.UInt16:
return(GetWellKnownType(WellKnownType.UInt16));
case SignatureTypeCode.Int32:
return(GetWellKnownType(WellKnownType.Int32));
case SignatureTypeCode.UInt32:
return(GetWellKnownType(WellKnownType.UInt32));
case SignatureTypeCode.Int64:
return(GetWellKnownType(WellKnownType.Int64));
case SignatureTypeCode.UInt64:
return(GetWellKnownType(WellKnownType.UInt64));
case SignatureTypeCode.Single:
return(GetWellKnownType(WellKnownType.Single));
case SignatureTypeCode.Double:
return(GetWellKnownType(WellKnownType.Double));
case SignatureTypeCode.Char:
return(GetWellKnownType(WellKnownType.Char));
case SignatureTypeCode.String:
return(GetWellKnownType(WellKnownType.String));
case SignatureTypeCode.IntPtr:
return(GetWellKnownType(WellKnownType.IntPtr));
case SignatureTypeCode.UIntPtr:
return(GetWellKnownType(WellKnownType.UIntPtr));
case SignatureTypeCode.Object:
return(GetWellKnownType(WellKnownType.Object));
case SignatureTypeCode.TypeHandle:
return(_module.GetType(_reader.ReadTypeHandle()));
case SignatureTypeCode.SZArray:
return(_module.Context.GetArrayType(ParseType()));
case SignatureTypeCode.Array:
{
var elementType = ParseType();
var rank = _reader.ReadCompressedInteger();
// TODO: Bounds for multi-dimmensional arrays
var boundsCount = _reader.ReadCompressedInteger();
for (int i = 0; i < boundsCount; i++)
{
_reader.ReadCompressedInteger();
}
var lowerBoundsCount = _reader.ReadCompressedInteger();
for (int j = 0; j < lowerBoundsCount; j++)
{
_reader.ReadCompressedInteger();
}
return(_module.Context.GetArrayType(elementType, rank));
}
case SignatureTypeCode.ByReference:
return(ParseType().MakeByRefType());
case SignatureTypeCode.Pointer:
return(_module.Context.GetPointerType(ParseType()));
case SignatureTypeCode.GenericTypeParameter:
return(_module.Context.GetSignatureVariable(_reader.ReadCompressedInteger(), false));
case SignatureTypeCode.GenericMethodParameter:
return(_module.Context.GetSignatureVariable(_reader.ReadCompressedInteger(), true));
case SignatureTypeCode.GenericTypeInstance:
{
TypeDesc typeDef = ParseType();
MetadataType metadataTypeDef = typeDef as MetadataType;
if (metadataTypeDef == null)
{
throw new BadImageFormatException();
}
TypeDesc[] instance = new TypeDesc[_reader.ReadCompressedInteger()];
for (int i = 0; i < instance.Length; i++)
{
instance[i] = ParseType();
}
return(_module.Context.GetInstantiatedType(metadataTypeDef, new Instantiation(instance)));
}
case SignatureTypeCode.TypedReference:
throw new PlatformNotSupportedException("TypedReference not supported in .NET Core");
case SignatureTypeCode.FunctionPointer:
throw new PlatformNotSupportedException("Function pointer types are not supported in .NET Core");
default:
throw new BadImageFormatException();
}
}
private TypeDesc ParseTypeImpl(SignatureTypeCode typeCode)
{
// Switch on the type.
switch (typeCode)
{
case SignatureTypeCode.Void:
return(GetWellKnownType(WellKnownType.Void));
case SignatureTypeCode.Boolean:
return(GetWellKnownType(WellKnownType.Boolean));
case SignatureTypeCode.SByte:
return(GetWellKnownType(WellKnownType.SByte));
case SignatureTypeCode.Byte:
return(GetWellKnownType(WellKnownType.Byte));
case SignatureTypeCode.Int16:
return(GetWellKnownType(WellKnownType.Int16));
case SignatureTypeCode.UInt16:
return(GetWellKnownType(WellKnownType.UInt16));
case SignatureTypeCode.Int32:
return(GetWellKnownType(WellKnownType.Int32));
case SignatureTypeCode.UInt32:
return(GetWellKnownType(WellKnownType.UInt32));
case SignatureTypeCode.Int64:
return(GetWellKnownType(WellKnownType.Int64));
case SignatureTypeCode.UInt64:
return(GetWellKnownType(WellKnownType.UInt64));
case SignatureTypeCode.Single:
return(GetWellKnownType(WellKnownType.Single));
case SignatureTypeCode.Double:
return(GetWellKnownType(WellKnownType.Double));
case SignatureTypeCode.Char:
return(GetWellKnownType(WellKnownType.Char));
case SignatureTypeCode.String:
return(GetWellKnownType(WellKnownType.String));
case SignatureTypeCode.IntPtr:
return(GetWellKnownType(WellKnownType.IntPtr));
case SignatureTypeCode.UIntPtr:
return(GetWellKnownType(WellKnownType.UIntPtr));
case SignatureTypeCode.Object:
return(GetWellKnownType(WellKnownType.Object));
case SignatureTypeCode.TypeHandle:
return(ResolveHandle(_reader.ReadTypeHandle()));
case SignatureTypeCode.SZArray:
{
var elementType = ParseType();
if (elementType == null)
{
return(null);
}
return(_tsc.GetArrayType(elementType));
}
case SignatureTypeCode.Array:
{
var elementType = ParseType();
var rank = _reader.ReadCompressedInteger();
if (_embeddedSignatureDataList != null)
{
var boundsCount = _reader.ReadCompressedInteger();
int [] bounds = boundsCount > 0 ? new int[boundsCount] : Array.Empty <int>();
for (int i = 0; i < boundsCount; i++)
{
bounds[i] = _reader.ReadCompressedInteger();
}
var lowerBoundsCount = _reader.ReadCompressedInteger();
int [] lowerBounds = lowerBoundsCount > 0 ? new int[lowerBoundsCount] : Array.Empty <int>();
bool nonZeroLowerBounds = false;
for (int j = 0; j < lowerBoundsCount; j++)
{
int loBound = _reader.ReadCompressedSignedInteger();
if (loBound != 0)
{
nonZeroLowerBounds = true;
}
lowerBounds[j] = loBound;
}
if (boundsCount != 0 || lowerBoundsCount != rank || nonZeroLowerBounds)
{
StringBuilder arrayShapeString = new StringBuilder();
arrayShapeString.Append(string.Join(",", bounds));
arrayShapeString.Append('|');
arrayShapeString.Append(string.Join(",", lowerBounds));
_embeddedSignatureDataList.Add(new EmbeddedSignatureData {
index = string.Join(".", _indexStack) + "|" + arrayShapeString.ToString(), kind = EmbeddedSignatureDataKind.ArrayShape, type = null
});
}
}
else
{
var boundsCount = _reader.ReadCompressedInteger();
for (int i = 0; i < boundsCount; i++)
{
_reader.ReadCompressedInteger();
}
var lowerBoundsCount = _reader.ReadCompressedInteger();
for (int j = 0; j < lowerBoundsCount; j++)
{
_reader.ReadCompressedSignedInteger();
}
}
if (elementType != null)
{
return(_tsc.GetArrayType(elementType, rank));
}
else
{
return(null);
}
}
case SignatureTypeCode.ByReference:
{
TypeDesc byRefedType = ParseType();
if (byRefedType != null)
{
return(byRefedType.MakeByRefType());
}
else
{
return(null);
}
}
case SignatureTypeCode.Pointer:
{
TypeDesc pointedAtType = ParseType();
if (pointedAtType != null)
{
return(_tsc.GetPointerType(pointedAtType));
}
else
{
return(null);
}
}
case SignatureTypeCode.GenericTypeParameter:
return(_tsc.GetSignatureVariable(_reader.ReadCompressedInteger(), false));
case SignatureTypeCode.GenericMethodParameter:
return(_tsc.GetSignatureVariable(_reader.ReadCompressedInteger(), true));
case SignatureTypeCode.GenericTypeInstance:
{
TypeDesc typeDef = ParseType();
MetadataType metadataTypeDef = null;
if (typeDef != null)
{
metadataTypeDef = typeDef as MetadataType;
if (metadataTypeDef == null)
{
throw new BadImageFormatException();
}
}
TypeDesc[] instance = new TypeDesc[_reader.ReadCompressedInteger()];
for (int i = 0; i < instance.Length; i++)
{
instance[i] = ParseType();
if (instance[i] == null)
{
metadataTypeDef = null;
}
}
if (metadataTypeDef != null)
{
return(_tsc.GetInstantiatedType(metadataTypeDef, new Instantiation(instance)));
}
else
{
return(null);
}
}
case SignatureTypeCode.TypedReference:
return(GetWellKnownType(WellKnownType.TypedReference));
case SignatureTypeCode.FunctionPointer:
MethodSignature sig = ParseMethodSignatureInternal(skipEmbeddedSignatureData: true);
if (sig != null)
{
return(_tsc.GetFunctionPointerType(sig));
}
else
{
return(null);
}
default:
throw new BadImageFormatException();
}
}
private void WriteTypeCode(SignatureTypeCode value)
{
Builder.WriteByte((byte)value);
}
private void WriteTypeCode(SignatureTypeCode value)
{
Builder.WriteByte((byte)value);
}
private TypeDesc ParseType(SignatureTypeCode typeCode)
{
// Switch on the type.
switch (typeCode)
{
case SignatureTypeCode.Void:
return GetWellKnownType(WellKnownType.Void);
case SignatureTypeCode.Boolean:
return GetWellKnownType(WellKnownType.Boolean);
case SignatureTypeCode.SByte:
return GetWellKnownType(WellKnownType.SByte);
case SignatureTypeCode.Byte:
return GetWellKnownType(WellKnownType.Byte);
case SignatureTypeCode.Int16:
return GetWellKnownType(WellKnownType.Int16);
case SignatureTypeCode.UInt16:
return GetWellKnownType(WellKnownType.UInt16);
case SignatureTypeCode.Int32:
return GetWellKnownType(WellKnownType.Int32);
case SignatureTypeCode.UInt32:
return GetWellKnownType(WellKnownType.UInt32);
case SignatureTypeCode.Int64:
return GetWellKnownType(WellKnownType.Int64);
case SignatureTypeCode.UInt64:
return GetWellKnownType(WellKnownType.UInt64);
case SignatureTypeCode.Single:
return GetWellKnownType(WellKnownType.Single);
case SignatureTypeCode.Double:
return GetWellKnownType(WellKnownType.Double);
case SignatureTypeCode.Char:
return GetWellKnownType(WellKnownType.Char);
case SignatureTypeCode.String:
return GetWellKnownType(WellKnownType.String);
case SignatureTypeCode.IntPtr:
return GetWellKnownType(WellKnownType.IntPtr);
case SignatureTypeCode.UIntPtr:
return GetWellKnownType(WellKnownType.UIntPtr);
case SignatureTypeCode.Object:
return GetWellKnownType(WellKnownType.Object);
case SignatureTypeCode.TypeHandle:
return _module.GetType(_reader.ReadTypeHandle());
case SignatureTypeCode.SZArray:
return _module.Context.GetArrayType(ParseType());
case SignatureTypeCode.Array:
{
var elementType = ParseType();
var rank = _reader.ReadCompressedInteger();
// TODO: Bounds for multi-dimmensional arrays
var boundsCount = _reader.ReadCompressedInteger();
for (int i = 0; i < boundsCount; i++)
_reader.ReadCompressedInteger();
var lowerBoundsCount = _reader.ReadCompressedInteger();
for (int j = 0; j < lowerBoundsCount; j++)
_reader.ReadCompressedInteger();
return _module.Context.GetArrayType(elementType, rank);
}
case SignatureTypeCode.ByReference:
return ParseType().MakeByRefType();
case SignatureTypeCode.Pointer:
return _module.Context.GetPointerType(ParseType());
case SignatureTypeCode.GenericTypeParameter:
return _module.Context.GetSignatureVariable(_reader.ReadCompressedInteger(), false);
case SignatureTypeCode.GenericMethodParameter:
return _module.Context.GetSignatureVariable(_reader.ReadCompressedInteger(), true);
case SignatureTypeCode.GenericTypeInstance:
{
TypeDesc typeDef = ParseType();
MetadataType metadataTypeDef = typeDef as MetadataType;
if (metadataTypeDef == null)
throw new BadImageFormatException();
TypeDesc[] instance = new TypeDesc[_reader.ReadCompressedInteger()];
for (int i = 0; i < instance.Length; i++)
instance[i] = ParseType();
return _module.Context.GetInstantiatedType(metadataTypeDef, new Instantiation(instance));
}
case SignatureTypeCode.TypedReference:
throw new PlatformNotSupportedException("TypedReference not supported in .NET Core");
case SignatureTypeCode.FunctionPointer:
throw new PlatformNotSupportedException("Function pointer types are not supported in .NET Core");
default:
throw new BadImageFormatException();
}
}
public BlobReader Skip()
{
BlobReader reader = _reader;
SignatureTypeCode typeCode = reader.ReadSignatureTypeCode();
switch (typeCode)
{
case SignatureTypeCode.Boolean:
case SignatureTypeCode.Char:
case SignatureTypeCode.SByte:
case SignatureTypeCode.Byte:
case SignatureTypeCode.Int16:
case SignatureTypeCode.UInt16:
case SignatureTypeCode.Int32:
case SignatureTypeCode.UInt32:
case SignatureTypeCode.Int64:
case SignatureTypeCode.UInt64:
case SignatureTypeCode.IntPtr:
case SignatureTypeCode.UIntPtr:
case SignatureTypeCode.Single:
case SignatureTypeCode.Double:
break;
case SignatureTypeCode.Object:
case SignatureTypeCode.String:
break;
case SignatureTypeCode.Array:
reader = new TypeSignature(reader).Skip();
reader = new ArrayShapeSignature(reader).Skip();
break;
case SignatureTypeCode.FunctionPointer:
throw new NotImplementedException(string.Format("{0} is not yet implemented.", typeCode));
case SignatureTypeCode.GenericTypeInstance:
reader.ReadSignatureTypeCode();
reader.ReadTypeHandle();
int argumentCount = reader.ReadCompressedInteger();
for (int i = 0; i < argumentCount; i++)
{
reader = new TypeSignature(reader).Skip();
}
break;
case SignatureTypeCode.GenericMethodParameter:
case SignatureTypeCode.GenericTypeParameter:
// skip the generic parameter index
reader.ReadCompressedInteger();
break;
case SignatureTypeCode.TypeHandle:
reader.ReadTypeHandle();
break;
case SignatureTypeCode.Pointer:
while (reader.IsCustomModifier())
{
reader = new CustomModifierSignature(reader).Skip();
}
if (reader.PeekSignatureTypeCode() == SignatureTypeCode.Void)
{
reader.ReadSignatureTypeCode();
}
else
{
reader = new TypeSignature(reader).Skip();
}
break;
case SignatureTypeCode.SZArray:
while (reader.IsCustomModifier())
{
reader = new CustomModifierSignature(reader).Skip();
}
reader = new TypeSignature(reader).Skip();
break;
default:
throw new InvalidOperationException("Invalid signature type code.");
}
return(reader);
}
private static string GetTypeName(SignatureTypeCode typeCode)
{
switch (typeCode)
{
case SignatureTypeCode.Boolean: return "[bool]";
case SignatureTypeCode.Int32: return "[int]";
case SignatureTypeCode.String: return "[string]";
case SignatureTypeCode.Object: return "[object]";
default: return null;
}
}
private object ReadAndTranslateValue(ref BlobReader sigReader, SignatureTypeCode typeCode, out bool isEnumTypeCode)
{
switch (typeCode)
{
case SignatureTypeCode.Boolean:
isEnumTypeCode = true;
return (short)(sigReader.ReadBoolean() ? 1 : 0);
case SignatureTypeCode.Char:
isEnumTypeCode = true;
return (ushort)sigReader.ReadChar();
case SignatureTypeCode.SByte:
isEnumTypeCode = true;
return (short)sigReader.ReadSByte();
case SignatureTypeCode.Byte:
isEnumTypeCode = true;
return (short)sigReader.ReadByte();
case SignatureTypeCode.Int16:
isEnumTypeCode = true;
return sigReader.ReadInt16();
case SignatureTypeCode.UInt16:
isEnumTypeCode = true;
return sigReader.ReadUInt16();
case SignatureTypeCode.Int32:
isEnumTypeCode = true;
return sigReader.ReadInt32();
case SignatureTypeCode.UInt32:
isEnumTypeCode = true;
return sigReader.ReadUInt32();
case SignatureTypeCode.Int64:
isEnumTypeCode = true;
return sigReader.ReadInt64();
case SignatureTypeCode.UInt64:
isEnumTypeCode = true;
return sigReader.ReadUInt64();
case SignatureTypeCode.Single:
isEnumTypeCode = false;
return sigReader.ReadSingle();
case SignatureTypeCode.Double:
isEnumTypeCode = false;
return sigReader.ReadDouble();
case SignatureTypeCode.String:
isEnumTypeCode = false;
if (sigReader.RemainingBytes == 1)
{
if (sigReader.ReadByte() != 0xff)
{
throw new BadImageFormatException();
}
return NullReferenceValue;
}
if (sigReader.RemainingBytes % 2 != 0)
{
throw new BadImageFormatException();
}
return sigReader.ReadUTF16(sigReader.RemainingBytes);
case SignatureTypeCode.Object:
// null reference
isEnumTypeCode = false;
return NullReferenceValue;
default:
throw new BadImageFormatException();
}
}
