public void Print(ClrObject clrObject)
{
if (clrObject.Type == null)
{
return;
}
var items = clrObject.GetObjectField("_items");
if (items.Type == null)
{
return;
}
var len = items.Type.GetArrayLength(items);
for (var i = 0; i < len; ++i)
{
var elementAddress = items.Type.GetArrayElementAddress(items, i);
items.Type.Heap.ReadPointer(elementAddress, out var objectAddress);
var obj = new ClrObject(
objectAddress,
items.Type.Heap.GetObjectType(objectAddress));
if (obj.Type == null)
{
return;
}
var strKey = ClrMdHelper.ToString(obj);
Console.WriteLine(strKey);
}
}
public static string GetDisplayValue(this ClrInstanceField self, ClrObject clrObject)
{
if (self.IsObjectReference)
{
var obj = clrObject.GetObjectField(self.Name);
if (obj.IsNull)
{
return("null");
}
return($"0x{obj.Address:X} [{obj.Type.Name}:0x{obj.Type.MethodTable:X}]");
}
else if (self.HasSimpleValue)
{
return(self.GetValue(clrObject.Address).ToString());
}
else if (self.IsValueClass)
{
var vt = clrObject.GetValueClassField(self.Name);
return($"0x{vt.Address:X} [struct {vt.Type.Name}:0x{vt.Type.MethodTable:X}]");
}
else
{
return("<unknown value>");
}
}
private static void PrintDictionary(ClrObject dictClrObject)
{
var entries = dictClrObject.GetObjectField("entries");
if (entries.IsNull)
{
return;
}
var count = dictClrObject.GetField <int>("count");
var arrayType = entries.Type;
var elementType = arrayType.ComponentType;
var entriesLength = Math.Min(count, arrayType.GetArrayLength(entries.Address));
var heap = arrayType.Heap;
var keyField = elementType.GetFieldByName("key");
var valueField = elementType.GetFieldByName("value");
var hashField = elementType.GetFieldByName("hashCode");
for (var i = 0; i < entriesLength; i++)
{
var entryAddr = arrayType.GetArrayElementAddress(entries.Address, i);
var hash = (int)hashField.GetValue(entryAddr, true);
if (hash < 0)
{
continue;
}
var key = Repr(heap, keyField.GetValue(entryAddr, true));
var value = Repr(heap, valueField.GetValue(entryAddr, true));
Console.WriteLine(key + ": " + value);
}
}
public void Print(ClrObject clrObject)
{
var entries = clrObject.GetObjectField("_entries");
if (entries.IsNull)
{
return;
}
var count = clrObject.GetField <int>("_count");
var arrayType = entries.Type;
var elementType = arrayType.ComponentType;
var entriesLength = count;
for (var i = 0; i < entriesLength; i++)
{
var entryAddr = arrayType.GetArrayElementAddress(entries.Address, i);
var dictEntry = ClrValueClassFactory.Create(entryAddr, elementType);
var hash = dictEntry.GetField <int>("hashCode");
if (hash < 0)
{
continue;
}
var key = ClrMdHelper.ToString(dictEntry.GetObjectField("key"));
var value = ClrMdHelper.ToString(dictEntry.GetObjectField("value"));
Console.WriteLine(key + ": " + value);
}
}
public void GetObjectField_WhenFieldDoesNotExistInType_ThrowsArgumentException(ClrObject clrObject, string unexistingField)
{
// Act
Action locateUnexistingField = () => clrObject.GetObjectField(unexistingField);
// Assert
locateUnexistingField.Should().Throw <ArgumentException>();
}
private static void PrintImmutableListNode(ClrObject clrObject)
{
while (true)
{
if (clrObject.Type == null)
{
return;
}
var key = clrObject.GetObjectField("_key");
if (key.Type == null)
{
return;
}
PrintImmutableListNode(clrObject.GetObjectField("_left"));
var strKey = ClrMdHelper.ToString(key);
Console.WriteLine(strKey);
clrObject = clrObject.GetObjectField("_right");
}
}
public void GetObjectField_WhenNullObject_ThrowsNullReference(string fieldName)
{
// Arrange
var nullObject = new ClrObject(0, type: null);
// Act
Action locateFieldFromNullObject = () => nullObject.GetObjectField(fieldName);
// Assert
locateFieldFromNullObject.Should().Throw <NullReferenceException>();
}
public void GetObjectField_WhenTypeHasValueTypeField_ThrowsArgumentException([Frozen] ClrType objectType, ClrObject clrObject, ClrInstanceField valueField)
{
// Arrange
valueField.IsObjectReference.Returns(false);
// Act
Action locateObjectFromValueTypeField = () => clrObject.GetObjectField(valueField.Name);
// Assert
locateObjectFromValueTypeField.Should().Throw <ArgumentException>();
}
public void Print(ClrObject clrObject)
{
if (clrObject.Type == null)
{
return;
}
var rootNode = clrObject.GetObjectField("_root");
PrintImmutableListNode(rootNode);
}
public void GetObjectField_WhenHeapWasUnableToReadPointer_ThrowsMemoryReadException([Frozen] ClrHeap heap, [Frozen] ClrType objectType, ClrObject clrObject, ClrInstanceField clrField, ulong corruptedFieldPointer)
{
// Arrange
clrField.IsObjectReference.Returns(true);
clrField.GetAddress(clrObject.Address).Returns(corruptedFieldPointer);
heap.ReadPointer(corruptedFieldPointer, out var whatever).Returns(false);
// Act
Action locateObjectFromValueTypeField = () => clrObject.GetObjectField(clrField.Name);
// Assert
locateObjectFromValueTypeField.Should().Throw <MemoryReadException>();
}
public void GetObjectField_WhenFieldDoesNotExistInType_ThrowsArgumentException(ClrHeap heap, ClrType type, ulong address, string unexistingField)
{
// Arrange
heap.GetObjectType(address).Returns(type);
type.Heap.Returns(heap);
var clrObject = new ClrObject(address, type);
// Act
Action locateUnexistingField = () => clrObject.GetObjectField(unexistingField);
// Assert
locateUnexistingField.Should().Throw <ArgumentException>();
}
public void GetObjectField_WhenTypeHasValueTypeField_ThrowsArgumentException(ClrHeap heap, ClrType objectType, ClrInstanceField valueField, ulong clrObj, string valueFieldName)
{
// Arrange
heap.GetObjectType(clrObj).Returns(objectType);
objectType.GetFieldByName(valueFieldName).Returns(valueField);
valueField.IsObjectReference.Returns(false);
objectType.Heap.Returns(heap);
var clrObject = new ClrObject(clrObj, objectType);
// Act
Action locateObjectFromValueTypeField = () => clrObject.GetObjectField(valueFieldName);
// Assert
locateObjectFromValueTypeField.Should().Throw <ArgumentException>();
}
private static bool ExtractRefObject(Pair p, ClrInstanceField field, ClrObject obj, out object reff)
{
reff = null;
var reference = obj.GetObjectField(field.Name);
if (reference.IsNull)
{
return(true);
}
if (reference.Type.IsString)
{
var value = GetStringContents(reference);
reff = value;
return(true);
}
if (reference.Type.IsPrimitive)
{
reff = field.GetValue(obj.Address);
return(true);
}
if (Pair.Cache.TryGetValue(reference.Address, out reff))
{
return(true);
}
Type type = null;
if (!GetType(p, reference.Type, out type))
{
return(false);
}
var par = Export(Yield(reference), type).Single();
reff = par.RuntimeObject;
p.Warnings.AddRange(par.Warnings);
p.Errors.AddRange(par.Errors);
return(true);
}
public void GetObjectField_WhenTypeHasFieldWithName_FindsField([Frozen] ClrHeap heap, [Frozen] ClrType objectType, ClrObject source, ClrInstanceField clrField, ulong fieldAddress, ClrObject target)
{
// Arrange
clrField.IsObjectReference.Returns(true);
clrField.GetAddress(source.Address).Returns(fieldAddress);
heap.ReadPointer(fieldAddress, out var whatever)
.Returns(call =>
{
call[1] = target.Address;
return(true);
});
// Act
var fieldFoundByName = source.GetObjectField(clrField.Name);
// Assert
fieldFoundByName.Address.Should().Be(target);
}
public void EnumerateGCRefsArray()
{
using DataTarget dataTarget = TestTargets.GCRoot.LoadFullDump();
using ClrRuntime runtime = dataTarget.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrModule module = heap.Runtime.GetMainModule();
ClrType mainType = module.GetTypeByName("GCRootTarget");
ClrObject obj = mainType.GetStaticObjectValue("TheRoot");
obj = obj.GetObjectField("Item1");
Assert.Equal("System.Object[]", obj.Type.Name);
ClrObject[] refs = obj.EnumerateReferences(false).ToArray();
Assert.Single(refs);
Assert.Equal("DoubleRef", refs[0].Type.Name);
}
private static void PrintConcurrentDictionary(ClrObject dictClrObject)
{
var tables = dictClrObject.GetObjectField("m_tables");
var nodes = tables.GetObjectField("m_buckets");
var arrayType = nodes.Type;
var heap = arrayType.Heap;
foreach (var item in nodes.EnumerateObjectReferences())
{
var node = item;
while (!node.IsNull)
{
var key = Repr(heap, node.GetObjectField("m_key").Address);
var value = Repr(heap, node.GetObjectField("m_value").Address);
Console.WriteLine($"{key}:{value}");
node = node.GetObjectField("m_next");
}
}
Console.WriteLine();
}
private static void PrintConcurrentDictionary(ClrObject dictClrObject)
{
var tables = dictClrObject.GetObjectField("m_tables");
//TODO: print items
}
private static bool ExtractArray(Pair p, ClrObject obj, ClrInstanceField field, out Array arr)
{
arr = null;
var array = obj.GetObjectField(field.Name);
if (array.Type.ComponentType.IsString || array.Type.ComponentType.IsPrimitive)
{
arr = CreatePrimitiveArray(array);
}
else
{
int len = field.Type.GetArrayLength(array.Address);
Type type = null;;
if (!GetType(p, array.Type.ComponentType, out type))
{
return(false);
}
arr = Array.CreateInstance(type, len);
for (int i = 0; i < len; i++)
{
ulong address = (ulong)array.Type.GetArrayElementValue(array.Address, i);
if (address == 0)
{
continue;
}
ClrType otype = Program._runtime.Heap.GetObjectType(address);
Type type1 = null;;
if (!GetType(p, otype, out type1))
{
continue;
}
var clrObject = new ClrObject(address, otype);
if (clrObject.IsNull)
{
continue;
}
object value1 = null;
if (clrObject.Type.IsString)
{
value1 = GetStringContents(clrObject);
}
else if (clrObject.Type.IsPrimitive)
{
value1 = field.GetValue(obj.Address);
}
else
{
var value = Export(Yield(clrObject), type1).FirstOrDefault();
p.Warnings.AddRange(value.Warnings);
p.Errors.AddRange(value.Errors);
value1 = value.RuntimeObject;
}
arr.SetValue(value1, i);
}
}
return(true);
}
/// <summary> /// Gets the given object reference field from this ClrObject. Throws ArgumentException if the given field does /// not exist in the object. Throws NullReferenceException if IsNull is true. /// </summary> /// <param name="fieldName">The name of the field to retrieve.</param> /// <returns>A ClrObject of the given field.</returns> /// <inheritdoc /> public IClrObject GetObjectField(string fieldName) => Converter.Convert(Object.GetObjectField(fieldName));
