Example #1
0
        public DesktopStaticField(DesktopGCHeap heap, IFieldData field, BaseDesktopHeapType containingType, string name, FieldAttributes attributes, object defaultValue, IntPtr sig, int sigLen)
        {
            _field        = field;
            _name         = name;
            _attributes   = attributes;
            _type         = (BaseDesktopHeapType)heap.GetTypeByMethodTable(field.TypeMethodTable, 0);
            _defaultValue = defaultValue;
            _heap         = heap;
            _token        = field.FieldToken;

            if (_type != null && ElementType != ClrElementType.Class)
            {
                _type.ElementType = ElementType;
            }

            _containingType = containingType;


            if (_type == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int  etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out int sigType))
                    {
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
                    }

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);

                    if (res)
                    {
                        ClrElementType type = (ClrElementType)etype;

                        if (type == ClrElementType.Array)
                        {
                            res = sigParser.PeekElemType(out etype);
                            res = res && sigParser.SkipExactlyOne();

                            int ranks = 0;
                            res = res && sigParser.GetData(out ranks);

                            if (res)
                            {
                                _type = heap.GetArrayType((ClrElementType)etype, ranks, null);
                            }
                        }
                        else if (type == ClrElementType.SZArray)
                        {
                            res  = sigParser.PeekElemType(out etype);
                            type = (ClrElementType)etype;

                            if (DesktopRuntimeBase.IsObjectReference(type))
                            {
                                _type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
                            }
                            else
                            {
                                _type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
                            }
                        }
                        else if (type == ClrElementType.Pointer)
                        {
                            // Only deal with single pointers for now and types that have already been constructed
                            res  = sigParser.GetElemType(out etype);
                            type = (ClrElementType)etype;

                            sigParser.GetToken(out int token);
                            BaseDesktopHeapType innerType = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(field.Module, Convert.ToUInt32(token));

                            if (innerType == null)
                            {
                                innerType = (BaseDesktopHeapType)heap.GetBasicType(type);
                            }

                            _type = heap.CreatePointerType(innerType, type, null);
                        }
                    }
                }
            }

            if (_type == null)
            {
                _typeResolver = new Lazy <ClrType>(() =>
                {
                    ClrType type = (BaseDesktopHeapType)TryBuildType(_heap);

                    if (type == null)
                    {
                        type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
                    }

                    return(type);
                });
            }
        }
Example #2
0
        private static BaseDesktopHeapType GetType(DesktopGCHeap heap, IFieldData data, IntPtr sig, int sigLen, ClrElementType elementType)
        {
            BaseDesktopHeapType result = null;
            ulong mt = data.TypeMethodTable;

            if (mt != 0)
            {
                result = (BaseDesktopHeapType)heap.GetTypeByMethodTable(mt, 0);
            }

            if (result == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int  etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out int sigType))
                    {
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
                    }

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);


                    // Generic instantiation
                    if (etype == 0x15)
                    {
                        res = res && sigParser.GetElemType(out etype);
                    }

                    if (res)
                    {
                        ClrElementType type = (ClrElementType)etype;

                        if (type == ClrElementType.Array)
                        {
                            res = sigParser.PeekElemType(out etype);
                            res = res && sigParser.SkipExactlyOne();

                            int ranks = 0;
                            res = res && sigParser.GetData(out ranks);

                            if (res)
                            {
                                result = heap.GetArrayType((ClrElementType)etype, ranks, null);
                            }
                        }
                        else if (type == ClrElementType.SZArray)
                        {
                            res  = sigParser.PeekElemType(out etype);
                            type = (ClrElementType)etype;

                            if (DesktopRuntimeBase.IsObjectReference(type))
                            {
                                result = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
                            }
                            else
                            {
                                result = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
                            }
                        }
                        else if (type == ClrElementType.Pointer)
                        {
                            // Only deal with single pointers for now and types that have already been constructed
                            res  = sigParser.GetElemType(out etype);
                            type = (ClrElementType)etype;

                            sigParser.GetToken(out int token);
                            BaseDesktopHeapType innerType = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(data.Module, Convert.ToUInt32(token));

                            if (innerType == null)
                            {
                                innerType = (BaseDesktopHeapType)heap.GetBasicType(type);
                            }

                            result = heap.CreatePointerType(innerType, type, null);
                        }
                        else if (type == ClrElementType.Object || type == ClrElementType.Class)
                        {
                            result = (BaseDesktopHeapType)heap.ObjectType;
                        }
                        else
                        {
                            // struct, then try to get the token
                            int token = 0;
                            if (etype == 0x11 || etype == 0x12)
                            {
                                res = res && sigParser.GetToken(out token);
                            }

                            if (token != 0)
                            {
                                result = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(data.Module, (uint)token);
                            }

                            if (result == null)
                            {
                                if ((result = (BaseDesktopHeapType)heap.GetBasicType((ClrElementType)etype)) == null)
                                {
                                    result = heap.ErrorType;
                                }
                            }
                        }
                    }
                }

                if (result == null)
                {
                    result = (BaseDesktopHeapType)heap.GetBasicType(elementType);
                }
            }
            else if (elementType != ClrElementType.Class)
            {
                result.ElementType = elementType;
            }

            if (result.IsArray && result.ComponentType == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int  etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out int sigType))
                    {
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
                    }

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);

                    res = res && sigParser.GetElemType(out etype);

                    // Generic instantiation
                    if (etype == 0x15)
                    {
                        res = res && sigParser.GetElemType(out etype);
                    }

                    // If it's a class or struct, then try to get the token
                    int token = 0;
                    if (etype == 0x11 || etype == 0x12)
                    {
                        res = res && sigParser.GetToken(out token);
                    }

                    if (token != 0)
                    {
                        result.ComponentType = heap.GetGCHeapTypeFromModuleAndToken(data.Module, (uint)token);
                    }

                    else if (result.ComponentType == null)
                    {
                        if ((result.ComponentType = heap.GetBasicType((ClrElementType)etype)) == null)
                        {
                            result.ComponentType = heap.ErrorType;
                        }
                    }
                }
            }

            return(result);
        }
Example #3
0
        public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
        {
            _name = name;
            _field = data;
            _attributes = attributes;

            ulong mt = data.TypeMethodTable;
            if (mt != 0)
                _type = (BaseDesktopHeapType)heap.GetGCHeapType(mt, 0);

            if (_type == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int sigType, etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out sigType))
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);

                    if (res)
                    {
                        ClrElementType type = (ClrElementType)etype;

                        if (type == ClrElementType.Array)
                        {
                            res = sigParser.PeekElemType(out etype);
                            res = res && sigParser.SkipExactlyOne();

                            int ranks = 0;
                            res = res && sigParser.GetData(out ranks);

                            if (res)
                                _type = heap.GetArrayType((ClrElementType)etype, ranks, null);
                        }
                        else if (type == ClrElementType.SZArray)
                        {
                            res = sigParser.PeekElemType(out etype);
                            type = (ClrElementType)etype;

                            if (DesktopRuntimeBase.IsObjectReference(type))
                                _type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
                            else
                                _type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
                        }
                        else if (type == ClrElementType.Pointer)
                        {
                            // Only deal with single pointers for now and types that have already been constructed
                            res = sigParser.GetElemType(out etype);
                            type = (ClrElementType)etype;

                            int token;
                            sigParser.GetToken(out token);
                            BaseDesktopHeapType innerType = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(data.Module, Convert.ToUInt32(token));

                            if (innerType == null)
                            {
                                innerType = (BaseDesktopHeapType)heap.GetBasicType(type);
                            }

                            _type = heap.CreatePointerType(innerType, type, null);
                        }
                    }
                }

                if (_type == null)
                    _type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
            }
            else if (ElementType != ClrElementType.Class)
            {
                _type.ElementType = ElementType;
            }
        }
Example #4
0
        internal static ClrType?GetTypeForFieldSig(ITypeFactory factory, SigParser sigParser, ClrHeap heap, ClrModule?module)
        {
            ClrType?result = null;
            bool    res;
            int     etype = 0;

            if (res = sigParser.GetCallingConvInfo(out int sigType))
            {
                DebugOnly.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
            }

            res = res && sigParser.SkipCustomModifiers();
            res = res && sigParser.GetElemType(out etype);

            // Generic instantiation
            if (etype == 0x15)
            {
                res = res && sigParser.GetElemType(out etype);
            }

            if (res)
            {
                ClrElementType type = (ClrElementType)etype;

                if (type == ClrElementType.Array)
                {
                    res = sigParser.PeekElemType(out etype);
                    res = res && sigParser.SkipExactlyOne();

                    int ranks = 0;
                    res = res && sigParser.GetData(out ranks);

                    if (res)
                    {
                        ClrType inner = factory.GetOrCreateBasicType((ClrElementType)etype);
                        result = factory.GetOrCreateArrayType(inner, ranks);
                    }
                }
                else if (type == ClrElementType.SZArray)
                {
                    sigParser.PeekElemType(out etype);
                    type = (ClrElementType)etype;

                    if (type.IsObjectReference())
                    {
                        result = factory.GetOrCreateBasicType(ClrElementType.SZArray);
                    }
                    else
                    {
                        ClrType inner = factory.GetOrCreateBasicType((ClrElementType)etype);
                        result = factory.GetOrCreateArrayType(inner, 1);
                    }
                }
                else if (type == ClrElementType.Pointer)
                {
                    // Only deal with single pointers for now and types that have already been constructed
                    sigParser.GetElemType(out etype);
                    type = (ClrElementType)etype;

                    sigParser.GetToken(out int token);

                    if (module != null)
                    {
                        ClrType?innerType = factory.GetOrCreateTypeFromToken(module, (uint)token);
                        if (innerType is null)
                        {
                            innerType = factory.GetOrCreateBasicType(type);
                        }

                        result = factory.GetOrCreatePointerType(innerType, 1);
                    }
                }
                else if (type == ClrElementType.Object || type == ClrElementType.Class)
                {
                    result = heap.ObjectType;
                }
                else
                {
                    // struct, then try to get the token
                    int token = 0;
                    if (etype == 0x11 || etype == 0x12)
                    {
                        sigParser.GetToken(out token);
                    }

                    if (token != 0 && module != null)
                    {
                        result = factory.GetOrCreateTypeFromToken(module, (uint)token);
                    }

                    if (result is null)
                    {
                        result = factory.GetOrCreateBasicType((ClrElementType)etype);
                    }
                }
            }

            if (result is null)
            {
                return(result);
            }

            if (result.IsArray && result.ComponentType is null && result is ClrmdArrayType clrmdType)
            {
                etype = 0;

                if (res = sigParser.GetCallingConvInfo(out sigType))
                {
                    DebugOnly.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
                }

                res = res && sigParser.SkipCustomModifiers();
                res = res && sigParser.GetElemType(out etype);

                _ = res && sigParser.GetElemType(out etype);

                // Generic instantiation
                if (etype == 0x15)
                {
                    sigParser.GetElemType(out etype);
                }

                // If it's a class or struct, then try to get the token
                int token = 0;
                if (etype == 0x11 || etype == 0x12)
                {
                    sigParser.GetToken(out token);
                }

                if (token != 0 && module != null)
                {
                    clrmdType.SetComponentType(factory.GetOrCreateTypeFromToken(module, (uint)token));
                }
                else
                {
                    clrmdType.SetComponentType(factory.GetOrCreateBasicType((ClrElementType)etype));
                }
            }

            return(result);
        }
Example #5
0
        public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
        {
            _name       = name;
            _field      = data;
            _attributes = attributes;

            ulong mt = data.TypeMethodTable;

            if (mt != 0)
            {
                _type = (BaseDesktopHeapType)heap.GetGCHeapType(mt, 0);
            }

            if (_type == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int  sigType, etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out sigType))
                    {
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
                    }

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);

                    if (res)
                    {
                        ClrElementType type = (ClrElementType)etype;

                        if (type == ClrElementType.Array)
                        {
                            res = sigParser.PeekElemType(out etype);
                            res = res && sigParser.SkipExactlyOne();

                            int ranks = 0;
                            res = res && sigParser.GetData(out ranks);

                            if (res)
                            {
                                _type = heap.GetArrayType((ClrElementType)etype, ranks, null);
                            }
                        }
                        else if (type == ClrElementType.SZArray)
                        {
                            res  = sigParser.PeekElemType(out etype);
                            type = (ClrElementType)etype;

                            if (DesktopRuntimeBase.IsObjectReference(type))
                            {
                                _type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
                            }
                            else
                            {
                                _type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
                            }
                        }
                        else if (type == ClrElementType.Pointer)
                        {
                            // Only deal with single pointers for now and types that have already been constructed
                            res  = sigParser.GetElemType(out etype);
                            type = (ClrElementType)etype;

                            int token;
                            sigParser.GetToken(out token);
                            BaseDesktopHeapType innerType = (BaseDesktopHeapType)heap.GetGCHeapTypeFromModuleAndToken(data.Module, Convert.ToUInt32(token));

                            if (innerType == null)
                            {
                                innerType = (BaseDesktopHeapType)heap.GetBasicType(type);
                            }

                            _type = heap.CreatePointerType(innerType, type, null);
                        }
                    }
                }

                if (_type == null)
                {
                    _type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
                }
            }
            else if (ElementType != ClrElementType.Class)
            {
                _type.ElementType = ElementType;
            }
        }
Example #6
0
        public DesktopStaticField(DesktopGCHeap heap, IFieldData field, BaseDesktopHeapType containingType, string name, FieldAttributes attributes, object defaultValue, IntPtr sig, int sigLen)
        {
            m_field        = field;
            m_name         = name;
            m_attributes   = attributes;
            m_type         = (BaseDesktopHeapType)heap.GetGCHeapType(field.TypeMethodTable, 0);
            m_defaultValue = defaultValue;
            m_heap         = heap;

            if (m_type != null && ElementType != ClrElementType.Class)
            {
                m_type.SetElementType(ElementType);
            }

            m_containingType = containingType;


            if (m_type == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int  sigType, etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out sigType))
                    {
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
                    }

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);

                    if (res)
                    {
                        ClrElementType type = (ClrElementType)etype;

                        if (type == ClrElementType.Array)
                        {
                            res = sigParser.PeekElemType(out etype);
                            res = res && sigParser.SkipExactlyOne();

                            int ranks = 0;
                            res = res && sigParser.GetData(out ranks);

                            if (res)
                            {
                                m_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
                            }
                        }
                        else if (type == ClrElementType.SZArray)
                        {
                            res  = sigParser.PeekElemType(out etype);
                            type = (ClrElementType)etype;

                            if (DesktopRuntimeBase.IsObjectReference(type))
                            {
                                m_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
                            }
                            else
                            {
                                m_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
                            }
                        }
                    }
                }

                if (m_type == null)
                {
                    m_type = (BaseDesktopHeapType)TryBuildType(m_heap);
                }

                if (m_type == null)
                {
                    m_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
                }
            }
        }
Example #7
0
        public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
        {
            m_name       = name;
            m_field      = data;
            m_attributes = attributes;

            ulong mt = data.TypeMethodTable;

            if (mt != 0)
            {
                m_type = (BaseDesktopHeapType)heap.GetGCHeapType(mt, 0);
            }

            if (m_type == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int  sigType, etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out sigType))
                    {
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
                    }

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);

                    if (res)
                    {
                        ClrElementType type = (ClrElementType)etype;

                        if (type == ClrElementType.Array)
                        {
                            res = sigParser.PeekElemType(out etype);
                            res = res && sigParser.SkipExactlyOne();

                            int ranks = 0;
                            res = res && sigParser.GetData(out ranks);

                            if (res)
                            {
                                m_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
                            }
                        }
                        else if (type == ClrElementType.SZArray)
                        {
                            res  = sigParser.PeekElemType(out etype);
                            type = (ClrElementType)etype;

                            if (DesktopRuntimeBase.IsObjectReference(type))
                            {
                                m_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
                            }
                            else
                            {
                                m_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
                            }
                        }
                    }
                }

                if (m_type == null)
                {
                    m_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
                }
            }
            else if (ElementType != ClrElementType.Class)
            {
                m_type.SetElementType(ElementType);
            }
        }
Example #8
0
        public DesktopStaticField(DesktopGCHeap heap, IFieldData field, BaseDesktopHeapType containingType, string name, FieldAttributes attributes, object defaultValue, IntPtr sig, int sigLen)
        {
            m_field = field;
            m_name = name;
            m_attributes = attributes;
            m_type = (BaseDesktopHeapType)heap.GetGCHeapType(field.TypeMethodTable, 0);
            m_defaultValue = defaultValue;
            m_heap = heap;

            if (m_type != null && ElementType != ClrElementType.Class)
                m_type.SetElementType(ElementType);

            m_containingType = containingType;


            if (m_type == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int sigType, etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out sigType))
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);

                    if (res)
                    {
                        ClrElementType type = (ClrElementType)etype;

                        if (type == ClrElementType.Array)
                        {
                            res = sigParser.PeekElemType(out etype);
                            res = res && sigParser.SkipExactlyOne();

                            int ranks = 0;
                            res = res && sigParser.GetData(out ranks);

                            if (res)
                                m_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
                        }
                        else if (type == ClrElementType.SZArray)
                        {
                            res = sigParser.PeekElemType(out etype);
                            type = (ClrElementType)etype;

                            if (DesktopRuntimeBase.IsObjectReference(type))
                                m_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
                            else
                                m_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
                        }
                    }
                }

                if (m_type == null)
                    m_type = (BaseDesktopHeapType)TryBuildType(m_heap);

                if (m_type == null)
                    m_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
            }
        }
Example #9
0
        public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
        {
            m_name = name;
            m_field = data;
            m_attributes = attributes;

            ulong mt = data.TypeMethodTable;
            if (mt != 0)
                m_type = (BaseDesktopHeapType)heap.GetGCHeapType(mt, 0);

            if (m_type == null)
            {
                if (sig != IntPtr.Zero && sigLen > 0)
                {
                    SigParser sigParser = new SigParser(sig, sigLen);

                    bool res;
                    int sigType, etype = 0;

                    if (res = sigParser.GetCallingConvInfo(out sigType))
                        Debug.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);

                    res = res && sigParser.SkipCustomModifiers();
                    res = res && sigParser.GetElemType(out etype);

                    if (res)
                    {
                        ClrElementType type = (ClrElementType)etype;

                        if (type == ClrElementType.Array)
                        {
                            res = sigParser.PeekElemType(out etype);
                            res = res && sigParser.SkipExactlyOne();

                            int ranks = 0;
                            res = res && sigParser.GetData(out ranks);

                            if (res)
                                m_type = heap.GetArrayType((ClrElementType)etype, ranks, null);
                        }
                        else if (type == ClrElementType.SZArray)
                        {
                            res = sigParser.PeekElemType(out etype);
                            type = (ClrElementType)etype;

                            if (DesktopRuntimeBase.IsObjectReference(type))
                                m_type = (BaseDesktopHeapType)heap.GetBasicType(ClrElementType.SZArray);
                            else
                                m_type = (BaseDesktopHeapType)heap.GetArrayType(type, -1, null);
                        }
                    }
                }
                
                if (m_type == null)
                    m_type = (BaseDesktopHeapType)heap.GetBasicType(ElementType);
            }
            else if (ElementType != ClrElementType.Class)
            {
                m_type.SetElementType(ElementType);
            }
        }