internal static IEnumerable <ClrObject> EnumerateHandlers(ClrObject clrObject)
{
ClrObject target = clrObject[TargetFieldName];
ulong targetAddress = target.Address;
if (targetAddress != clrObject.Address)
{
yield return(clrObject);
}
else
{
var invocCount = clrObject[InvocationCountFieldName];
var v = invocCount.SimpleValue;
var invocCountValue = (long)v;
var invocList = clrObject[InvocationListFieldName];
if (!invocList.IsNull)
{
for (int i = 0; i < invocCountValue; i++)
{
var targetObject = invocList[i];
yield return(targetObject);
}
}
}
}
public LoneTargetInformation(ClrDump clrDump, ClrObject target, ClrMethod methInfo, ClrObject owner)
{
this.clrDump = clrDump;
this.target = target;
this.methInfo = methInfo;
this.owner = owner;
}
public LoneTargetInformation(ClrDump clrDump, ClrObject target, ClrMethod methInfo, ClrObject owner)
{
this.clrDump = clrDump;
this.target = target;
this.methInfo = methInfo;
this.owner = owner;
}
public static object GetFieldValueImpl(ulong address, ClrType type, ClrInstanceField field)
{
ClrObject obj = new ClrObject(address, type);
var fieldValue = obj[field];
return(fieldValue.IsNull ? null : fieldValue.HasSimpleValue?fieldValue.SimpleValue : fieldValue.Address);
}
private static ClrMethod GetDelegateMethod(ClrDump clrDump, ClrObject handler, ClrObject target)
{
var targetType = target.Type;
var methPtrObj = handler[MethodPtrFieldName];
var methPtrLong = (long)methPtrObj.SimpleValue;
var methPtr = (ulong)methPtrLong;
return(GetDelegateMethod(methPtr, clrDump));
}
public ArrayElementsAddressContainer(ClrDumpObject clrDumpObject)
{
this.clrDumpObject = clrDumpObject;
if (!clrDumpObject.ClrType.IsArray)
{
throw new ArgumentException($"{clrDumpObject.TypeName} is not an array !");
}
clrObject = new ClrObject(clrDumpObject.Address, clrDumpObject.ClrType, clrDumpObject.IsInterior);
Count = clrDumpObject.ArrayLength;
}
public ArrayElementsAddressContainer(ClrDumpObject clrDumpObject)
{
this.clrDumpObject = clrDumpObject;
if (!clrDumpObject.ClrType.IsArray)
{
throw new ArgumentException($"{clrDumpObject.TypeName} is not an array !");
}
clrObject = new ClrObject(clrDumpObject.Address, clrDumpObject.ClrType, clrDumpObject.IsInterior);
Count = clrDumpObject.ArrayLength;
}
private object GetValue()
{
var clrObject = new ClrObject(Address, ClrType, IsInterior);
if (clrObject.HasSimpleValue && ! clrObject.IsNull)
{
return clrObject.SimpleValue;
}
else
{
return null;
}
}
private object GetValue()
{
var clrObject = new ClrObject(Address, ClrType, IsInterior);
if (clrObject.HasSimpleValue && !clrObject.IsNull)
{
return(clrObject.SimpleValue);
}
else
{
return(null);
}
}
internal static List <FieldValueInformation> GetElements(ClrDumpObject clrDumpObject) => clrDumpObject.ClrDump.Eval(() =>
{
var clrObject = new ClrObject(clrDumpObject.Address, clrDumpObject.ClrType, clrDumpObject.IsInterior);
var l = new List <FieldValueInformation>();
int length = clrDumpObject.ClrType.GetArrayLength(clrDumpObject.Address);
var n = Math.Min(length, 1024);
for (int i = 0; i < n; i++)
{
var fieldValue = clrObject[i];
var fieldValueInfo = new FieldValueInformation($"[{i}]", new ClrDumpObject(clrDumpObject.ClrDump, fieldValue.Type, fieldValue.Address, fieldValue.IsInterior));
l.Add(fieldValueInfo);
}
return(l);
});
public string GetFieldNameReferenceImpl(ulong refAddress, ulong address, bool prefixWithType)
{
ClrType type = GetObjectTypeImpl(address);
if (type == null)
{
return("Unknown");
}
string fieldName = "???";
ClrObject obj = new ClrObject(address, type);
if (type.IsArray)
{
fieldName = "[ ? ]";
var length = type.GetArrayLength(address);
for (int i = 0; i < length; i++)
{
if (obj[i].Address == refAddress)
{
fieldName = $"[ {i} ]";
}
}
}
else
{
foreach (var field in type.Fields)
{
switch (field.ElementType)
{
case ClrElementType.Struct:
case ClrElementType.String:
case ClrElementType.Array:
case ClrElementType.SZArray:
case ClrElementType.Object:
var fieldValue = obj[field];
if (fieldValue.Address == refAddress)
{
fieldName = field.Name;
}
break;
}
}
}
if (prefixWithType)
{
fieldName = $"{fieldName}@{type.Name}";
}
return(fieldName);
}
public static long CountTargets(ulong address, ClrType clrType, ClrInstanceField targetField, ClrInstanceField invocCountField)
{
ClrObject clrObject = new ClrObject(address, clrType);
ClrObject target = clrObject[targetField];
if (target.Address != address)
{
return(1);
}
var invocCount = clrObject[invocCountField];
var value = invocCount.SimpleValue;
return((long)value);
}
internal static List <FieldValueInformation> GetValues(ClrDumpObject clrDumpObject) => clrDumpObject.ClrDump.Eval(() =>
{
var clrObject = new ClrObject(clrDumpObject.Address, clrDumpObject.ClrType, clrDumpObject.IsInterior);
var l = new List <FieldValueInformation>();
if (clrDumpObject.ClrType != null)
{
foreach (var field in clrDumpObject.ClrType.Fields)
{
var fieldValue = clrObject[field];
var fieldValueInfo = new FieldValueInformation(field.RealName(), new ClrDumpObject(clrDumpObject.ClrDump, fieldValue.Type, fieldValue.Address, fieldValue.IsInterior));
l.Add(fieldValueInfo);
}
}
return(l);
});
internal static List <DelegateTargetInformation> GetDelegateTargetInformations(ClrDumpObject clrDumpObject)
{
var targetInformations = new List <DelegateTargetInformation>();
ClrObject clrObject = clrDumpObject.ClrObject;
ClrDump clrDump = clrDumpObject.ClrDump;
foreach (var handlerObject in EnumerateHandlers(clrObject))
{
var target = handlerObject[TargetFieldName];
var methInfo = GetDelegateMethod(clrDump, handlerObject, target);
var targetInfo = new DelegateTargetInformation(target.Address, new ClrDumpType(clrDump, target.Type), methInfo);
targetInformations.Add(targetInfo);
}
return(targetInformations);
}
public static object GetFieldValueImpl(ulong address, ClrType type, List <ClrInstanceField> fields)
{
ClrObject obj = new ClrObject(address, type);
for (int i = 0; i < fields.Count; i++)
{
var field = fields[i];
obj = obj[field];
if (obj.IsNull)
{
return(null);
}
}
return(obj.HasSimpleValue ? obj.SimpleValue : obj.Address);
}
public static string GetSimpleValueString(ClrObject obj)
{
object value = obj.SimpleValue;
if (value == null)
{
return("null");
}
ClrType type = obj.Type;
if (type?.IsEnum == true)
{
return(type.GetEnumName(value) ?? value.ToString());
}
DateTime?dateTime = value as DateTime?;
return(dateTime != null?GetDateTimeString(dateTime.Value) : value.ToString());
}
public object GetFieldValueImpl(ulong address, ClrType type, List <string> fieldNames)
{
ClrObject obj = new ClrObject(address, type);
for (int i = 0; i < fieldNames.Count; i++)
{
var fieldName = fieldNames[i];
ClrInstanceField field = obj.GetField(fieldName);
if (field == null)
{
return(null);
}
obj = obj[field];
if (obj.IsNull)
{
return(null);
}
}
return(obj.HasSimpleValue ? obj.SimpleValue : obj.Address);
}
internal static IEnumerable<ClrObject> EnumerateHandlers(ClrObject clrObject)
{
ClrObject target = clrObject[TargetFieldName];
ulong targetAddress = target.Address;
if (targetAddress != clrObject.Address)
{
yield return clrObject;
}
else
{
var invocCount = clrObject[InvocationCountFieldName];
var v = invocCount.SimpleValue;
var invocCountValue = (long)v;
var invocList = clrObject[InvocationListFieldName];
for (int i = 0; i < invocCountValue; i++)
{
var targetObject = invocList[i];
yield return targetObject;
}
}
}
private static IPAddress GetIPAddress(ClrObject ipAddress)
{
const int AddressFamilyInterNetworkV6 = 23;
const int IPv4AddressBytes = 4;
const int IPv6AddressBytes = 16;
const int NumberOfLabels = IPv6AddressBytes / 2;
byte[] bytes;
int family = (int)ipAddress["m_Family"].SimpleValue;
if (family == AddressFamilyInterNetworkV6)
{
bytes = new byte[IPv6AddressBytes];
int j = 0;
var numbers = ipAddress["m_Numbers"];
for (int i = 0; i < NumberOfLabels; i++)
{
ushort number = (ushort)numbers[i].SimpleValue;
bytes[j++] = (byte)((number >> 8) & 0xFF);
bytes[j++] = (byte)(number & 0xFF);
}
}
else
{
long address = (long)ipAddress["m_Address"].SimpleValue;
bytes = new byte[IPv4AddressBytes];
bytes[0] = (byte)(address);
bytes[1] = (byte)(address >> 8);
bytes[2] = (byte)(address >> 16);
bytes[3] = (byte)(address >> 24);
}
return(new IPAddress(bytes));
}
public static List<LoneTargetInformation> GetLoneTargetInformations(ClrDump clrDump)
{
CancellationTokenSource token = new CancellationTokenSource();
clrDump.MessageBus.BeginTask("Analyzing lone targets...", token);
Dictionary<ClrObject, ClrObject> loneTargetAddresses = new Dictionary<ClrObject, ClrObject>();
// For each instance of every delegate types
// let's find all the target objects
// and select those with only referenced once
var types = GetDelegateTypes(clrDump);
foreach(var type in types)
{
clrDump.MessageBus.Status($"Analyzing delegate type: {type.Name}");
if (token.IsCancellationRequested)
{
break;
}
int n = 0;
foreach (var address in clrDump.EnumerateInstances(type)) {
if (n++ % 128 == 0)
{
clrDump.MessageBus.Status($"Analyzing delegate type: {type.Name}, instance #{n:###,###,###,##0}");
}
var handlerObject = new ClrObject(address, type);
foreach(var subHandlerObject in EnumerateHandlers(handlerObject))
{
if (token.IsCancellationRequested)
{
break;
}
var target = subHandlerObject[TargetFieldName];
int count = clrDump.CountReferers(target.Address);
if( count == 1)
{
loneTargetAddresses[target] = subHandlerObject;
}
}
}
}
List<LoneTargetInformation> loneTargets = new List<LoneTargetInformation>();
// foreach lone target, in its reference tree, we try to find the first
// object that is not a delegate type or an array of object (ie invocationList)
var delegateType = clrDump.GetClrType(typeof(MulticastDelegate).FullName);
var arrayObjType = clrDump.GetClrType(typeof(object[]).FullName);
HashSet<ulong> visited = new HashSet<ulong>();
foreach (var kvp in loneTargetAddresses)
{
var loneTarget = kvp.Key;
var handler = kvp.Value;
var methInfo = GetDelegateMethod(clrDump, handler, loneTarget);
visited.Clear();
ulong ownerAddress = FindOwner(handler.Address, clrDump, delegateType, arrayObjType, visited);
ClrObject owner = new ClrObject(ownerAddress, clrDump.GetObjectType(ownerAddress));
var loneTargetInformation = new LoneTargetInformation(clrDump, loneTarget, methInfo, owner);
loneTargets.Add(loneTargetInformation);
}
string status = token.IsCancellationRequested ? "cancelled" : "done";
clrDump.MessageBus.EndTask($"Analyzing lone targets: {status}. Found: {loneTargets.Count}");
return loneTargets;
}
private object GetValue()
{
var clrObject = new ClrObject(Address, ClrType, IsInterior);
return(clrObject.HasSimpleValue && !clrObject.IsNull ? clrObject.SimpleValue : null);
}
public static long CountTargets(ulong address, ClrType clrType, ClrInstanceField targetField, ClrInstanceField invocCountField)
{
ClrObject clrObject = new ClrObject(address, clrType);
ClrObject target = clrObject[targetField];
if (target.Address != address)
{
return 1;
}
var invocCount = clrObject[invocCountField];
var value = invocCount.SimpleValue;
return (long)value;
}
private static IPAddress GetIPAddress(ClrObject ipAddress)
{
const int AddressFamilyInterNetworkV6 = 23;
const int IPv4AddressBytes = 4;
const int IPv6AddressBytes = 16;
const int NumberOfLabels = IPv6AddressBytes / 2;
byte[] bytes;
int family = (int)ipAddress["m_Family"].SimpleValue;
if (family == AddressFamilyInterNetworkV6)
{
bytes = new byte[IPv6AddressBytes];
int j = 0;
var numbers = ipAddress["m_Numbers"];
for (int i = 0; i < NumberOfLabels; i++)
{
ushort number = (ushort)numbers[i].SimpleValue;
bytes[j++] = (byte)((number >> 8) & 0xFF);
bytes[j++] = (byte)(number & 0xFF);
}
}
else
{
long address = (long)ipAddress["m_Address"].SimpleValue;
bytes = new byte[IPv4AddressBytes];
bytes[0] = (byte)(address);
bytes[1] = (byte)(address >> 8);
bytes[2] = (byte)(address >> 16);
bytes[3] = (byte)(address >> 24);
}
return new IPAddress(bytes);
}
public static List <LoneTargetInformation> GetLoneTargetInformations(ClrDump clrDump)
{
CancellationTokenSource token = new CancellationTokenSource();
clrDump.MessageBus.BeginTask("Analyzing lone targets...", token);
Dictionary <ClrObject, ClrObject> loneTargetAddresses = new Dictionary <ClrObject, ClrObject>();
// For each instance of every delegate types
// let's find all the target objects
// and select those with only referenced once
foreach (var type in GetDelegateTypes(clrDump))
{
clrDump.MessageBus.Status($"Analyzing delegate type: {type.Name}");
if (token.IsCancellationRequested)
{
break;
}
int n = 0;
foreach (var address in clrDump.EnumerateInstances(type))
{
if (n++ % 128 == 0)
{
clrDump.MessageBus.Status($"Analyzing delegate type: {type.Name}, instance #{n:###,###,###,##0}");
}
var handlerObject = new ClrObject(address, type);
foreach (var subHandlerObject in EnumerateHandlers(handlerObject))
{
if (token.IsCancellationRequested)
{
break;
}
var target = subHandlerObject[TargetFieldName];
int count = clrDump.CountReferers(target.Address);
if (count == 1)
{
loneTargetAddresses[target] = subHandlerObject;
}
}
}
}
List <LoneTargetInformation> loneTargets = new List <LoneTargetInformation>();
// foreach lone target, in its reference tree, we try to find the first
// object that is not a delegate type or an array of object (ie invocationList)
var delegateType = clrDump.GetClrType(typeof(MulticastDelegate).FullName);
var arrayObjType = clrDump.GetClrType(typeof(object[]).FullName);
HashSet <ulong> visited = new HashSet <ulong>();
foreach (var kvp in loneTargetAddresses)
{
var loneTarget = kvp.Key;
var handler = kvp.Value;
var methInfo = GetDelegateMethod(clrDump, handler, loneTarget);
visited.Clear();
ulong ownerAddress = FindOwner(handler.Address, clrDump, delegateType, arrayObjType, visited);
ClrObject owner = new ClrObject(ownerAddress, clrDump.GetObjectType(ownerAddress));
var loneTargetInformation = new LoneTargetInformation(clrDump, loneTarget, methInfo, owner);
loneTargets.Add(loneTargetInformation);
}
string status = token.IsCancellationRequested ? "cancelled" : "done";
clrDump.MessageBus.EndTask($"Analyzing lone targets: {status}. Found: {loneTargets.Count}");
return(loneTargets);
}
public static object GetSimpleValue(ClrObject obj)
{
return GetSimpleValue(obj.Address, obj.Type, obj.IsInterior);
}
public static string GetSimpleValueString(ClrObject obj)
{
object value = obj.SimpleValue;
if (value == null)
return "null";
ClrType type = obj.Type;
if (type != null && type.IsEnum)
return type.GetEnumName(value) ?? value.ToString();
DateTime? dateTime = value as DateTime?;
if (dateTime != null)
return GetDateTimeString(dateTime.Value);
return value.ToString();
}
public static object GetSimpleValue(ClrObject obj) => GetSimpleValue(obj.Address, obj.Type, obj.IsInterior);
private static ClrMethod GetDelegateMethod(ClrDump clrDump, ClrObject handler, ClrObject target)
{
var targetType = target.Type;
var methPtrObj = handler[MethodPtrFieldName];
var methPtrLong = (long)methPtrObj.SimpleValue;
var methPtr = (ulong)methPtrLong;
var methInfo = GetDelegateMethod(methPtr, clrDump);
return methInfo;
}
public static object GetSimpleValue(ClrObject obj)
{
return(GetSimpleValue(obj.Address, obj.Type, obj.IsInterior));
}
