Implemented "empty shell detection", see https://forum.unity.com/threads/heap-explorer-memory-profiler-debugger-and-analyzer-for-unity.527949/page-5#post-5896832 for details.

An empty shell is an Unity object that's kept alive due to C# holding a reference to it, but the native side has been destroyed already.

Author: pschraut

Documentation~/images/cs_empty_shell_objects_01.png

@@ -0,0 +1,98 @@
+//
+// Heap Explorer for Unity. Copyright (c) 2019-2020 Peter Schraut (www.console-dev.de). See LICENSE.md
+// https://github.com/pschraut/UnityHeapExplorer/
+//
+using System.Collections;
+using System.Collections.Generic;
+using Unity.Collections.LowLevel.Unsafe;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace HeapExplorer
+{
+    public class ManagedEmptyShellObjectsControl : AbstractManagedObjectsControl
+    {
+        public Progress progress = new Progress();
+
+        public ManagedEmptyShellObjectsControl(HeapExplorerWindow window, string editorPrefsKey, TreeViewState state)
+            : base(window, editorPrefsKey, state)
+        {
+        }
+
+        protected override void OnBuildTree(TreeViewItem root)
+        {
+            progress.value = 0;
+
+            var lookup = new Dictionary<string, AbstractItem>();
+            var memoryReader = new MemoryReader(m_Snapshot);
+
+            for (int n = 0, nend = m_Snapshot.managedObjects.Length; n < nend; ++n)
+            {
+                progress.value = (n + 1.0f) / nend;
+
+                var obj = m_Snapshot.managedObjects[n];
+                if (obj.address == 0)
+                    continue; // points to null
+
+                if (obj.nativeObjectsArrayIndex != -1)
+                    continue; // has a native object, thus can't be an empty shell object
+
+                var type = m_Snapshot.managedTypes[obj.managedTypesArrayIndex];
+
+                // Only UnityEngine.Object objects can have a m_CachedPtr connection to a native object.
+                if (!type.isUnityEngineObject)
+                    continue;
+
+                // Could be an array of an UnityEngine.Object, such as Texture[]
+                if (type.isArray)
+                    continue;
+
+                // Get type as a "higher level" representation that is easier to work with
+                var richType = new RichManagedType(m_Snapshot, obj.managedTypesArrayIndex);
+
+                // Try to get the m_InstanceID field
+                PackedManagedField packedField;
+                if (!richType.FindField("m_InstanceID", out packedField))
+                    continue;
+
+                // The editor contains various empty shell objects whose instanceID all contain 0.
+                // I guess it's some kind of special object? In this case we just ignore them.
+                var instanceID = memoryReader.ReadInt32(obj.address + (ulong)packedField.offset);
+                if (instanceID == 0)
+                    continue;
+
+                // Check if we already have a grouping node for that type.
+                // Create a new node if we don't have it.
+                AbstractItem parent;
+                if (!lookup.TryGetValue(type.name, out parent))
+                {
+                    var group = new GroupItem()
+                    {
+                        id = m_UniqueId++,
+                        depth = root.depth + 1,
+                        displayName = ""
+                    };
+                    group.Initialize(m_Snapshot, type);
+
+                    lookup[type.name] = parent = group;
+                    root.AddChild(group);
+                }
+
+                // Create and add the managed object item
+                var item = new ManagedObjectItem
+                {
+                    id = m_UniqueId++,
+                    depth = parent.depth + 1,
+                    displayName = ""
+                };
+                item.Initialize(this, m_Snapshot, obj);
+                parent.AddChild(item);
+
+                m_ManagedObjectCount++;
+                m_ManagedObjectSize += item.size;
+            }
+
+            progress.value = 1;
+        }
+    }
+}

Editor/Scripts/ManagedEmptyShellObjectsView.meta

@@ -0,0 +1,82 @@
+//
+// Heap Explorer for Unity. Copyright (c) 2019-2020 Peter Schraut (www.console-dev.de). See LICENSE.md
+// https://github.com/pschraut/UnityHeapExplorer/
+//
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using System;
+
+namespace HeapExplorer
+{
+    public class ManagedEmptyShellObjectsView : AbstractManagedObjectsView
+    {
+        [InitializeOnLoadMethod]
+        static void Register()
+        {
+            HeapExplorerWindow.Register<ManagedEmptyShellObjectsView>();
+        }
+
+        public override void Awake()
+        {
+            base.Awake();
+
+            titleContent = new GUIContent("C# Empty Shell Objects", "");
+            viewMenuOrder = 258;
+        }
+
+        protected override void OnCreate()
+        {
+            base.OnCreate();
+
+            var job = new Job();
+            job.snapshot = snapshot;
+            job.control = (ManagedEmptyShellObjectsControl)m_ObjectsControl;
+            ScheduleJob(job);
+        }
+
+        protected override AbstractManagedObjectsControl CreateObjectsTreeView(string editorPrefsKey, TreeViewState state)
+        {
+            return new ManagedEmptyShellObjectsControl(window, editorPrefsKey, state);
+        }
+
+        protected override void OnDrawHeader()
+        {
+            var text = string.Format("{0} empty shell object(s)", m_ObjectsControl.managedObjectsCount);
+            window.SetStatusbarString(text);
+            EditorGUILayout.LabelField(titleContent, EditorStyles.boldLabel);
+        }
+
+        public override void OnGUI()
+        {
+            base.OnGUI();
+
+            var control = (ManagedEmptyShellObjectsControl)m_ObjectsControl;
+            if (control.progress.value < 1)
+            {
+                window.SetBusy(string.Format("Analyzing Managed Objects, {0:F0}% done", control.progress.value * 100));
+            }
+        }
+
+        class Job : AbstractThreadJob
+        {
+            public ManagedEmptyShellObjectsControl control;
+            public PackedMemorySnapshot snapshot;
+
+            // Output
+            TreeViewItem tree;
+
+            public override void ThreadFunc()
+            {
+                tree = control.BuildTree(snapshot);
+            }
+
+            public override void IntegrateFunc()
+            {
+                control.SetTree(tree);
+            }
+        }
+    }
+}

Editor/Scripts/ManagedEmptyShellObjectsView/ManagedEmptyShellObjectsControl.cs

@@ -149,6 +149,10 @@ public TreeViewItem BuildTree(PackedMemorySnapshot snapshot)
                 }
             }
 
+            // For the TreeView to work, make this at least one item exists
+            if (!root.hasChildren)
+                root.AddChild(new TreeViewItem { id = 1, depth = -1, displayName = "" });
+
             return root;
         }
 

Editor/Scripts/ManagedEmptyShellObjectsView/ManagedEmptyShellObjectsControl.cs.meta

@@ -200,6 +200,14 @@ For example, if you have ten "Banana" strings and ten "Apple" strings, these wou
 
 The view can be sorted by various columns. The most interesting ones likely being "Size" and "Count".  Sorting the view by "Size" allows to quickly see where most memory is wasted due duplicated objects.
 
+# C# Empty Shell Objects
+
+The C# Empty Shell Objects View analyzes managed objects of type UnityEngine.Object if their native object counter-part has been destroyed, which can be a memory leak.
+
+If the m_CachedPtr value of a managed unity engine object points to null, it means its native object underneath has already been destroyed, but it leaked the managed shell. Please see [this post](https://forum.unity.com/threads/help-understanding-diff-data-from-memory-profiler.862813/#post-5684956) for more details.
+
+![alt text](Documentation~/images/cs_empty_shell_objects_01.png "Empty Shell Objects")
+
 
 # C# Delegates