void CrawlStatic()
{
var crawlStatic = new List <int>();
var managedTypes = m_Snapshot.managedTypes;
var staticManagedTypes = new List <int>(1024);
// Unity BUG: (Case 984330) PackedMemorySnapshot: Type contains staticFieldBytes, but has no static field
for (int n = 0, nend = managedTypes.Length; n < nend; ++n)
{
var type = managedTypes[n];
// Some static classes have no staticFieldBytes. As I understand this, the staticFieldBytes
// are only filled if that static class has been initialized (its cctor called), otherwise it's zero.
if (type.staticFieldBytes == null || type.staticFieldBytes.Length == 0)
{
continue;
}
//var hasStaticField = false;
for (int j = 0, jend = type.fields.Length; j < jend; ++j)
{
if (!type.fields[j].isStatic)
{
continue;
}
//var field = type.fields[j];
//var fieldType = managedTypes[field.managedTypesArrayIndex];
//hasStaticField = true;
var item = new PackedManagedStaticField
{
managedTypesArrayIndex = type.managedTypesArrayIndex,
fieldIndex = j,
staticFieldsArrayIndex = m_StaticFields.Count,
};
m_StaticFields.Add(item);
crawlStatic.Add(item.staticFieldsArrayIndex);
}
//if (hasStaticField)
staticManagedTypes.Add(type.managedTypesArrayIndex);
}
m_Snapshot.managedStaticTypes = staticManagedTypes.ToArray();
//var loopGuard = 0;
while (crawlStatic.Count > 0)
{
//if (++loopGuard > 100000)
//{
// m_snapshot.Error("Loop-guard kicked in while analyzing static fields.");
// break;
//}
m_TotalCrawled++;
if ((m_TotalCrawled % 1000) == 0)
{
UpdateProgress();
if (m_Snapshot.abortActiveStepRequested)
{
break;
}
}
var staticField = m_StaticFields[crawlStatic[crawlStatic.Count - 1]];
crawlStatic.RemoveAt(crawlStatic.Count - 1);
var staticClass = m_Snapshot.managedTypes[staticField.managedTypesArrayIndex];
var field = staticClass.fields[staticField.fieldIndex];
var fieldType = m_Snapshot.managedTypes[field.managedTypesArrayIndex];
var staticReader = new StaticMemoryReader(m_Snapshot, staticClass.staticFieldBytes);
if (fieldType.isValueType)
{
if (staticClass.staticFieldBytes == null || staticClass.staticFieldBytes.Length == 0)
{
continue;
}
var newObj = PackedManagedObject.New();
newObj.address = (ulong)field.offset;
// BUG: TODO: If staticFieldsArrayIndex=0, then it's detected as managedObject rather than staticField?
newObj.managedObjectsArrayIndex = -staticField.staticFieldsArrayIndex;
newObj.managedTypesArrayIndex = fieldType.managedTypesArrayIndex;
newObj.staticBytes = staticClass.staticFieldBytes;
SetObjectSize(ref newObj, fieldType);
m_Crawl.Add(newObj);
m_TotalCrawled++;
continue;
}
// If it's a reference type, it simply points to a ManagedObject on the heap and all
// we need to do it to create a new ManagedObject and add it to the list to crawl.
if (!fieldType.isValueType)
{
var addr = staticReader.ReadPointer((uint)field.offset);
if (addr == 0)
{
continue;
}
#if DEBUG_BREAK_ON_ADDRESS
if (addr == DebugBreakOnAddress)
{
int a = 0;
}
#endif
int newObjIndex;
if (!m_Seen.TryGetValue(addr, out newObjIndex))
{
var newObj = PackedManagedObject.New();
newObj.address = addr;
newObj.managedObjectsArrayIndex = m_ManagedObjects.Count;
// The static field could be a basetype, such as UnityEngine.Object, but actually point to a Texture2D.
// Therefore it's important to find the type of the specified address, rather than using the field type.
newObj.managedTypesArrayIndex = m_Snapshot.FindManagedObjectTypeOfAddress(addr);
if (newObj.managedTypesArrayIndex == -1)
{
newObj.managedTypesArrayIndex = fieldType.managedTypesArrayIndex;
}
// Check if the object has a GCHandle
var gcHandleIndex = m_Snapshot.FindGCHandleOfTargetAddress(addr);
if (gcHandleIndex != -1)
{
newObj.gcHandlesArrayIndex = gcHandleIndex;
m_Snapshot.gcHandles[gcHandleIndex].managedObjectsArrayIndex = newObj.managedObjectsArrayIndex;
m_Snapshot.AddConnection(PackedConnection.Kind.GCHandle, gcHandleIndex, PackedConnection.Kind.Managed, newObj.managedObjectsArrayIndex);
}
SetObjectSize(ref newObj, managedTypes[newObj.managedTypesArrayIndex]);
TryConnectNativeObject(ref newObj);
m_ManagedObjects.Add(newObj);
m_Seen[newObj.address] = newObj.managedObjectsArrayIndex;
m_Crawl.Add(newObj);
m_TotalCrawled++;
newObjIndex = newObj.managedObjectsArrayIndex;
}
m_Snapshot.AddConnection(PackedConnection.Kind.StaticField, staticField.staticFieldsArrayIndex, PackedConnection.Kind.Managed, newObjIndex);
continue;
}
}
}
void CrawlManagedObjects()
{
var virtualMachineInformation = m_Snapshot.virtualMachineInformation;
var nestedStructsIgnored = 0;
//var guard = 0;
while (m_Crawl.Count > 0)
{
//if (++guard > 10000000)
//{
// Debug.LogWarning("Loop guard kicked in");
// break;
//}
if ((m_TotalCrawled % 1000) == 0)
{
UpdateProgress();
if (m_Snapshot.abortActiveStepRequested)
{
break;
}
}
var mo = m_Crawl[m_Crawl.Count - 1];
m_Crawl.RemoveAt(m_Crawl.Count - 1);
#if DEBUG_BREAK_ON_ADDRESS
if (mo.address == DebugBreakOnAddress)
{
int a = 0;
}
#endif
var loopGuard = 0;
var typeIndex = mo.managedTypesArrayIndex;
while (typeIndex != -1)
{
if (++loopGuard > 264)
{
break;
}
AbstractMemoryReader memoryReader = m_MemoryReader;
if (mo.staticBytes != null)
{
memoryReader = new StaticMemoryReader(m_Snapshot, mo.staticBytes);
}
var baseType = m_Snapshot.managedTypes[typeIndex];
if (baseType.isArray)
{
if (baseType.baseOrElementTypeIndex < 0 || baseType.baseOrElementTypeIndex >= m_Snapshot.managedTypes.Length)
{
m_Snapshot.Error("'{0}.baseOrElementTypeIndex' = {1} at address '{2:X}', ignoring managed object.", baseType.name, baseType.baseOrElementTypeIndex, mo.address);
break;
}
var elementType = m_Snapshot.managedTypes[baseType.baseOrElementTypeIndex];
if (elementType.isValueType && elementType.isPrimitive)
{
break; // don't crawl int[], byte[], etc
}
if (elementType.isValueType && !ContainsReferenceType(elementType.managedTypesArrayIndex))
{
break;
}
var dim0Length = mo.address > 0 ? memoryReader.ReadArrayLength(mo.address, baseType) : 0;
//if (dim0Length > 1024 * 1024)
if (dim0Length > (32 * 1024) * (32 * 1024))
{
m_Snapshot.Error("Array (rank={2}) found at address '{0:X} with '{1}' elements, that doesn't seem right.", mo.address, dim0Length, baseType.arrayRank);
break;
}
for (var k = 0; k < dim0Length; ++k)
{
if ((m_TotalCrawled % 1000) == 0)
{
UpdateProgress();
}
ulong elementAddr = 0;
if (elementType.isArray)
{
elementAddr = memoryReader.ReadPointer(mo.address + (ulong)(k * virtualMachineInformation.pointerSize) + (ulong)virtualMachineInformation.arrayHeaderSize);
}
else if (elementType.isValueType)
{
elementAddr = mo.address + (ulong)(k * elementType.size) + (ulong)virtualMachineInformation.arrayHeaderSize - (ulong)virtualMachineInformation.objectHeaderSize;
}
else
{
elementAddr = memoryReader.ReadPointer(mo.address + (ulong)(k * virtualMachineInformation.pointerSize) + (ulong)virtualMachineInformation.arrayHeaderSize);
}
#if DEBUG_BREAK_ON_ADDRESS
if (elementAddr == DebugBreakOnAddress)
{
int a = 0;
}
#endif
if (elementAddr != 0)
{
int newObjectIndex;
if (!m_Seen.TryGetValue(elementAddr, out newObjectIndex))
{
var newObj = PackedManagedObject.New();
newObj.address = elementAddr;
newObj.managedTypesArrayIndex = elementType.managedTypesArrayIndex;
newObj.managedObjectsArrayIndex = m_ManagedObjects.Count;
if (elementType.isValueType)
{
newObj.managedObjectsArrayIndex = mo.managedObjectsArrayIndex;
newObj.staticBytes = mo.staticBytes;
}
else
{
newObj.managedTypesArrayIndex = m_Snapshot.FindManagedObjectTypeOfAddress(elementAddr);
if (newObj.managedTypesArrayIndex == -1)
{
newObj.managedTypesArrayIndex = elementType.managedTypesArrayIndex;
}
TryConnectNativeObject(ref newObj);
}
SetObjectSize(ref newObj, m_Snapshot.managedTypes[newObj.managedTypesArrayIndex]);
if (!elementType.isValueType)
{
m_ManagedObjects.Add(newObj);
}
m_Seen[newObj.address] = newObj.managedObjectsArrayIndex;
m_Crawl.Add(newObj);
m_TotalCrawled++;
newObjectIndex = newObj.managedObjectsArrayIndex;
}
// If we do not connect the Slot elements at Slot[] 0x1DB2A512EE0
if (!elementType.isValueType)
{
if (mo.managedObjectsArrayIndex >= 0)
{
m_Snapshot.AddConnection(PackedConnection.Kind.Managed, mo.managedObjectsArrayIndex, PackedConnection.Kind.Managed, newObjectIndex);
}
else
{
m_Snapshot.AddConnection(PackedConnection.Kind.StaticField, -mo.managedObjectsArrayIndex, PackedConnection.Kind.Managed, newObjectIndex);
}
}
}
}
break;
}
for (var n = 0; n < baseType.fields.Length; ++n)
{
var field = baseType.fields[n];
if (field.isStatic)
{
continue;
}
var fieldType = m_Snapshot.managedTypes[field.managedTypesArrayIndex];
if (fieldType.isValueType)
{
if (fieldType.isPrimitive)
{
continue;
}
if (s_IgnoreNestedStructs && mo.managedTypesArrayIndex == fieldType.managedTypesArrayIndex)
{
nestedStructsIgnored++;
continue;
}
var newObj = PackedManagedObject.New();
if (mo.staticBytes == null)
{
newObj.address = mo.address + (uint)field.offset - (uint)virtualMachineInformation.objectHeaderSize;
}
else
{
newObj.address = mo.address + (uint)field.offset - (uint)virtualMachineInformation.objectHeaderSize;
}
newObj.managedObjectsArrayIndex = mo.managedObjectsArrayIndex;
newObj.managedTypesArrayIndex = fieldType.managedTypesArrayIndex;
newObj.staticBytes = mo.staticBytes;
SetObjectSize(ref newObj, fieldType);
m_Crawl.Add(newObj); // Crawl, but do not add value types to the managedlist
m_TotalCrawled++;
continue;
}
if (!fieldType.isValueType)
{
ulong addr = 0;
if (mo.staticBytes == null)
{
addr = memoryReader.ReadPointer(mo.address + (uint)field.offset);
}
else
{
addr = memoryReader.ReadPointer(mo.address + (uint)field.offset - (uint)virtualMachineInformation.objectHeaderSize);
}
if (addr == 0)
{
continue;
}
#if DEBUG_BREAK_ON_ADDRESS
if (addr == DebugBreakOnAddress)
{
int a = 0;
}
#endif
int newObjIndex;
if (!m_Seen.TryGetValue(addr, out newObjIndex))
{
var newObj = PackedManagedObject.New();
newObj.address = addr;
newObj.managedObjectsArrayIndex = m_ManagedObjects.Count;
newObj.managedTypesArrayIndex = m_Snapshot.FindManagedObjectTypeOfAddress(addr);
if (newObj.managedTypesArrayIndex == -1)
{
newObj.managedTypesArrayIndex = fieldType.managedTypesArrayIndex;
}
SetObjectSize(ref newObj, m_Snapshot.managedTypes[newObj.managedTypesArrayIndex]);
TryConnectNativeObject(ref newObj);
m_Seen[newObj.address] = newObj.managedObjectsArrayIndex;
m_ManagedObjects.Add(newObj);
m_Crawl.Add(newObj);
m_TotalCrawled++;
newObjIndex = newObj.managedObjectsArrayIndex;
}
if (mo.managedObjectsArrayIndex >= 0)
{
m_Snapshot.AddConnection(PackedConnection.Kind.Managed, mo.managedObjectsArrayIndex, PackedConnection.Kind.Managed, newObjIndex);
}
else
{
m_Snapshot.AddConnection(PackedConnection.Kind.StaticField, -mo.managedObjectsArrayIndex, PackedConnection.Kind.Managed, newObjIndex);
}
continue;
}
}
if (typeIndex == baseType.baseOrElementTypeIndex || baseType.isArray)
{
break;
}
typeIndex = baseType.baseOrElementTypeIndex;
}
}
if (nestedStructsIgnored > 0)
{
m_Snapshot.Warning("HeapExplorer: {0} nested structs ignored (Workaround for Unity bug Case 1104590).", nestedStructsIgnored);
}
}
