예제 #1
0
 internal DesktopRCWData(DesktopGCHeap heap, ulong rcw, IRCWData data)
 {
     _addr       = rcw;
     _rcw        = data;
     _heap       = heap;
     _osThreadID = uint.MaxValue;
 }
예제 #2
0
 internal DesktopRCWData(DesktopGCHeap heap, Address rcw, IRCWData data)
 {
     m_addr       = rcw;
     m_rcw        = data;
     m_heap       = heap;
     m_osThreadID = uint.MaxValue;
 }
예제 #3
0
        internal ulong GetMTForDomain(ClrAppDomain domain, DesktopHeapType type)
        {
            DesktopGCHeap heap = null;
            IList <MethodTableTokenPair> mtList = _runtime.GetMethodTableList(_mapping[domain]);

            bool hasToken = type.MetadataToken != 0 && type.MetadataToken != uint.MaxValue;

            uint token = ~0xff000000 & type.MetadataToken;

            foreach (MethodTableTokenPair pair in mtList)
            {
                if (hasToken)
                {
                    if (pair.Token == token)
                    {
                        return(pair.MethodTable);
                    }
                }
                else
                {
                    if (heap == null)
                    {
                        heap = (DesktopGCHeap)_runtime.Heap;
                    }

                    if (heap.GetTypeByMethodTable(pair.MethodTable, 0) == type)
                    {
                        return(pair.MethodTable);
                    }
                }
            }

            return(0);
        }
예제 #4
0
 public DesktopThreadStaticField(DesktopGCHeap heap, IFieldData field, string name)
 {
     _field = field;
     _name  = name;
     _token = field.FieldToken;
     _type  = (BaseDesktopHeapType)heap.GetTypeByMethodTable(field.TypeMethodTable, 0);
 }
예제 #5
0
 public BaseDesktopHeapType(ulong mt, DesktopGCHeap heap, DesktopBaseModule module, uint token)
 {
     _constructedMT = mt;
     DesktopHeap    = heap;
     DesktopModule  = module;
     _token         = token;
     _gcDesc        = new Lazy <GCDesc>(FillGCDesc);
 }
예제 #6
0
 public DesktopPointerType(DesktopGCHeap heap, DesktopBaseModule module, ClrElementType eltype, uint token, string nameHint)
     : base(0, heap, module, token)
 {
     ElementType     = ClrElementType.Pointer;
     _pointerElement = eltype;
     if (nameHint != null)
     {
         BuildName(nameHint);
     }
 }
예제 #7
0
        public DesktopInstanceField(DesktopGCHeap heap, IFieldData data, string name, FieldAttributes attributes, IntPtr sig, int sigLen)
        {
            _name       = name;
            _field      = data;
            _attributes = attributes;
            _token      = data.FieldToken;

            _heap = heap;
            _type = new Lazy <BaseDesktopHeapType>(() => GetType(_heap, data, sig, sigLen, (ClrElementType)_field.CorElementType));
        }
예제 #8
0
 public DesktopArrayType(DesktopGCHeap heap, DesktopBaseModule module, ClrElementType eltype, int ranks, uint token, string nameHint)
     : base(0, heap, module, token)
 {
     ElementType   = ClrElementType.Array;
     _arrayElement = eltype;
     _ranks        = ranks;
     if (nameHint != null)
     {
         BuildName(nameHint);
     }
 }
예제 #9
0
        public override ClrHeap GetHeap()
        {
            if (_heap == null)
            {
                if (HasArrayComponentMethodTables)
                {
                    _heap = new LegacyGCHeap(this);
                }
                else
                {
                    _heap = new V46GCHeap(this);
                }
            }

            return(_heap);
        }
예제 #10
0
        /// <summary>
        /// Flushes the dac cache.  This function MUST be called any time you expect to call the same function
        /// but expect different results.  For example, after walking the heap, you need to call Flush before
        /// attempting to walk the heap again.
        /// </summary>
        public override void Flush()
        {
            OnRuntimeFlushed();

            Revision++;
            _dacInterface.Flush();

            _modules.Clear();
            _moduleFiles = null;
            _moduleSizes = null;
            _domains     = null;
            _system      = null;
            _shared      = null;
            _threads     = null;
            MemoryReader = null;
            _heap        = null;
            _threadpool  = null;
        }
예제 #11
0
        public override IEnumerable <ClrType> EnumerateTypes()
        {
            DesktopGCHeap heap = (DesktopGCHeap)_runtime.Heap;
            IList <MethodTableTokenPair> mtList = _runtime.GetMethodTableList(_address);

            if (_typesLoaded)
            {
                foreach (ClrType type in heap.EnumerateTypes())
                {
                    if (type.Module == this)
                    {
                        yield return(type);
                    }
                }
            }
            else
            {
                if (mtList != null)
                {
                    foreach (MethodTableTokenPair pair in mtList)
                    {
                        ulong mt = pair.MethodTable;
                        if (mt != _runtime.ArrayMethodTable)
                        {
                            // prefetch element type, as this also can load types
                            ClrType type = heap.GetTypeByMethodTable(mt, 0, 0);
                            if (type != null)
                            {
                                yield return(type);
                            }
                        }
                    }
                }

                _typesLoaded = true;
            }
        }
예제 #12
0
 internal DesktopCCWData(DesktopGCHeap heap, Address ccw, ICCWData data)
 {
     m_addr = ccw;
     m_ccw  = data;
     m_heap = heap;
 }
예제 #13
0
        /// <summary>
        /// Gets the GC heap of the process.
        /// </summary>
        public override ClrHeap GetHeap(TextWriter diagnosticLog)
        {
            if (_heap == null)
                _heap = new DesktopGCHeap(this, diagnosticLog);

            return _heap;
        }
예제 #14
0
        public override ClrHeap GetHeap()
        {
            if (_heap == null)
                _heap = new DesktopGCHeap(this, null);

            return _heap;
        }
예제 #15
0
 public SpecialType(DesktopGCHeap heap, string name)
     : base(heap, heap.DesktopRuntime.ErrorModule, 0)
 {
     _name = name;
 }
예제 #16
0
 internal DesktopCCWData(DesktopGCHeap heap, ulong ccw, ICCWData data)
 {
     _addr = ccw;
     _ccw  = data;
     _heap = heap;
 }
예제 #17
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);
            }
        }
예제 #18
0
        internal DesktopHeapType(Func <string> typeNameFactory, DesktopModule module, uint token, ulong mt, IMethodTableData mtData, DesktopGCHeap heap)
            : base(mt, heap, module, token)
        {
            _name = new Lazy <string>(typeNameFactory);

            Shared            = mtData.Shared;
            _parent           = mtData.Parent;
            _baseSize         = mtData.BaseSize;
            _componentSize    = mtData.ComponentSize;
            _containsPointers = mtData.ContainsPointers;
            _hasMethods       = mtData.NumMethods > 0;
        }
예제 #19
0
        public override ClrHeap GetHeap()
        {
            if (_heap == null)
            {
                if (HasArrayComponentMethodTables)
                    _heap = new LegacyGCHeap(this);
                else
                    _heap = new V46GCHeap(this);
            }

            return _heap;
        }
예제 #20
0
 public DesktopHeapType(ulong mt, DesktopGCHeap heap, DesktopBaseModule module, uint token) : base(mt, heap, module, token)
 {
 }
예제 #21
0
 internal LockInspection(DesktopGCHeap heap, DesktopRuntimeBase runtime)
 {
     _heap = heap;
     _runtime = runtime;
 }
예제 #22
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);
        }
예제 #23
0
 internal LockInspection(DesktopGCHeap heap, DesktopRuntimeBase runtime)
 {
     _heap    = heap;
     _runtime = runtime;
 }
예제 #24
0
파일: fields.cs 프로젝트: Pavel-Durov/msos
        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);
            }
        }
예제 #25
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);
                }
            }
        }
예제 #26
0
 public PrimitiveType(DesktopGCHeap heap, ClrElementType type)
     : base(0, heap, heap.DesktopRuntime.ErrorModule, 0)
 {
     ElementType = type;
 }
예제 #27
0
파일: com.cs 프로젝트: kailer89/clrmd
 internal DesktopCCWData(DesktopGCHeap heap, Address ccw, ICCWData data)
 {
     _addr = ccw;
     _ccw = data;
     _heap = heap;
 }
예제 #28
0
        internal DesktopHeapType(string typeName, DesktopModule module, uint token, ulong mt, IMethodTableData mtData, DesktopGCHeap heap)
            : base(heap, module, token)
        {
            _name = typeName;

            _constructedMT = mt;
            Shared = mtData.Shared;
            _parent = mtData.Parent;
            _baseSize = mtData.BaseSize;
            _componentSize = mtData.ComponentSize;
            _containsPointers = mtData.ContainsPointers;
            _hasMethods = mtData.NumMethods > 0;
        }
예제 #29
0
 public DesktopThreadStaticField(DesktopGCHeap heap, IFieldData field, string name)
 {
     m_field = field;
     m_name  = name;
     m_type  = (BaseDesktopHeapType)heap.GetGCHeapType(field.TypeMethodTable, 0);
 }
예제 #30
0
파일: com.cs 프로젝트: kailer89/clrmd
 internal DesktopRCWData(DesktopGCHeap heap, Address rcw, IRCWData data)
 {
     _addr = rcw;
     _rcw = data;
     _heap = heap;
     _osThreadID = uint.MaxValue;
 }
예제 #31
0
 public BaseDesktopHeapType(DesktopGCHeap heap, DesktopBaseModule module, uint token)
 {
     DesktopHeap = heap;
     DesktopModule = module;
     _token = token;
 }
예제 #32
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);
                });
            }
        }
예제 #33
0
        internal DesktopHeapType(string typeName, DesktopModule module, uint token, ulong mt, IMethodTableData mtData, DesktopGCHeap heap, int index)
            : base(heap, module, token)
        {
            m_name = typeName;
            m_index = index;

            m_handle = mt;
            Shared = mtData.Shared;
            m_parent = mtData.Parent;
            m_baseSize = mtData.BaseSize;
            m_componentSize = mtData.ComponentSize;
            m_containsPointers = mtData.ContainsPointers;
            m_hasMethods = mtData.NumMethods > 0;
        }
예제 #34
0
파일: fields.cs 프로젝트: popotans/netext
        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;
            }
        }
예제 #35
0
파일: fields.cs 프로젝트: Pavel-Durov/msos
        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);
            }
        }
예제 #36
0
 public ErrorType(DesktopGCHeap heap)
     : base(0, heap, heap.DesktopRuntime.ErrorModule, 0)
 {
 }
예제 #37
0
파일: fields.cs 프로젝트: tomasr/clrmd
 public DesktopThreadStaticField(DesktopGCHeap heap, IFieldData field, string name)
 {
     _field = field;
     _name = name;
     _type = (BaseDesktopHeapType)heap.GetGCHeapType(field.TypeMethodTable, 0);
 }
예제 #38
0
        /// <summary>
        /// Flushes the dac cache.  This function MUST be called any time you expect to call the same function
        /// but expect different results.  For example, after walking the heap, you need to call Flush before
        /// attempting to walk the heap again.
        /// </summary>
        public override void Flush()
        {
            OnRuntimeFlushed();

            Revision++;
            _dacInterface.Flush();

            _modules.Clear();
            _moduleFiles = null;
            _moduleSizes = null;
            _domains = null;
            _system = null;
            _shared = null;
            _threads = null;
            MemoryReader = null;
            _heap = null;
            _threadpool = null;
        }
예제 #39
0
파일: fields.cs 프로젝트: tomasr/clrmd
        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;
            }
        }
예제 #40
0
 public DesktopPointerType(DesktopGCHeap heap, DesktopBaseModule module, ClrElementType eltype, uint token, string nameHint)
     : base(heap, module, token)
 {
     ElementType = ClrElementType.Pointer;
     _pointerElement = eltype;
     if (nameHint != null)
         BuildName(nameHint);
 }
예제 #41
0
        internal override IList <ClrStackFrame> GetExceptionStackTrace(ulong obj, ClrType type)
        {
            List <ClrStackFrame> result = new List <ClrStackFrame>();

            if (!GetStackTraceFromField(type, obj, out ulong _stackTrace))
            {
                if (!ReadPointer(obj + GetStackTraceOffset(), out _stackTrace))
                {
                    return(result);
                }
            }

            if (_stackTrace == 0)
            {
                return(result);
            }

            DesktopGCHeap heap           = (DesktopGCHeap)Heap;
            ClrType       stackTraceType = heap.GetObjectType(_stackTrace);

            if (stackTraceType == null)
            {
                stackTraceType = heap.ArrayType;
            }

            if (!stackTraceType.IsArray)
            {
                return(result);
            }

            int len = stackTraceType.GetArrayLength(_stackTrace);

            if (len == 0)
            {
                return(result);
            }

            int   elementSize = CLRVersion == DesktopVersion.v2 ? IntPtr.Size * 4 : IntPtr.Size * 3;
            ulong dataPtr     = _stackTrace + (ulong)(IntPtr.Size * 2);

            if (!ReadPointer(dataPtr, out ulong count))
            {
                return(result);
            }

            // Skip size and header
            dataPtr += (ulong)(IntPtr.Size * 2);

            DesktopThread thread = null;

            for (int i = 0; i < (int)count; ++i)
            {
                if (!ReadPointer(dataPtr, out ulong ip))
                {
                    break;
                }
                if (!ReadPointer(dataPtr + (ulong)IntPtr.Size, out ulong sp))
                {
                    break;
                }
                if (!ReadPointer(dataPtr + (ulong)(2 * IntPtr.Size), out ulong md))
                {
                    break;
                }

                if (i == 0)
                {
                    thread = (DesktopThread)GetThreadByStackAddress(sp);
                }

                result.Add(new DesktopStackFrame(this, thread, null, ip, sp, md));

                dataPtr += (ulong)elementSize;
            }

            return(result);
        }
예제 #42
0
 public DesktopArrayType(DesktopGCHeap heap, DesktopBaseModule module, ClrElementType eltype, int ranks, uint token, string nameHint)
     : base(heap, module, token)
 {
     ElementType = ClrElementType.Array;
     _arrayElement = eltype;
     _ranks = ranks;
     if (nameHint != null)
         BuildName(nameHint);
 }
예제 #43
0
 public ErrorType(DesktopGCHeap heap)
     : base(heap, heap.DesktopRuntime.ErrorModule, 0)
 {
 }