public override IEnumerable <ClrGenericParameter> EnumerateGenericParameters()
{
// We won't recover from Module being null, so we'll return an empty params list from that.
ClrModule?module = Module;
if (module is null)
{
yield break;
}
// We'll return default if we can't get MetdataImport. This effectively means we'll try again
// to get MetadataImport later.
MetadataImport?import = module.MetadataImport;
if (import == null)
{
yield break;
}
foreach (int token in import.EnumerateGenericParams(MetadataToken))
{
if (import.GetGenericParamProps(token, out int index, out GenericParameterAttributes attributes, out string?name))
{
yield return(new ClrGenericParameter(token, index, attributes, name));
}
}
}
public ClrmdType(ClrHeap heap, ClrType?baseType, ClrModule?module, ITypeData data)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
Helpers = data.Helpers;
MethodTable = data.MethodTable;
Heap = heap;
BaseType = baseType;
Module = module;
MetadataToken = data.Token;
Shared = data.IsShared;
StaticSize = data.BaseSize;
ContainsPointers = data.ContainsPointers;
IsShared = data.IsShared;
// If there are no methods, preempt the expensive work to create methods
if (data.MethodCount == 0)
{
_methods = Array.Empty <ClrMethod>();
}
DebugOnlyLoadLazyValues();
}
public ClrmdGenericType(IClrObjectHelpers helpers, ClrHeap heap, ClrModule?module, ClrGenericParameter clrGenericParameter)
{
ClrObjectHelpers = helpers ?? throw new ArgumentNullException(nameof(helpers));
Heap = heap ?? throw new ArgumentNullException(nameof(heap));
Module = module;
GenericParameter = clrGenericParameter;
}
private ILInfo?GetILInfo()
{
IDataReader?dataReader = _helpers.DataReader;
if (dataReader is null)
{
return(null);
}
ClrModule?module = Type?.Module;
if (module is null)
{
return(null);
}
MetadataImport?mdImport = module.MetadataImport;
if (mdImport is null)
{
return(null);
}
uint rva = mdImport.GetRva(MetadataToken);
ulong il = _helpers.GetILForModule(module.Address, rva);
if (il != 0)
{
if (dataReader.Read(il, out byte b))
{
bool isTinyHeader = (b & (IMAGE_COR_ILMETHOD.FormatMask >> 1)) == IMAGE_COR_ILMETHOD.TinyFormat;
if (isTinyHeader)
{
ulong address = il + 1;
int len = b >> (int)(IMAGE_COR_ILMETHOD.FormatShift - 1);
uint localToken = IMAGE_COR_ILMETHOD.mdSignatureNil;
return(new ILInfo(address, len, 0, localToken));
}
else if (dataReader.Read(il, out uint flags))
{
int len = dataReader.Read <int>(il + 4);
uint localToken = dataReader.Read <uint>(il + 8);
ulong address = il + 12;
return(new ILInfo(address, len, flags, localToken));
}
}
}
return(null);
}
public bool Equals(ClrModule?other)
{
if (ReferenceEquals(this, other))
{
return(true);
}
if (other is null)
{
return(false);
}
return(Address == other.Address);
}
public ClrmdArrayType(ClrHeap heap, ClrType?baseType, ClrModule?module, ITypeData data, string?name = null)
: base(heap, baseType, module, data, name)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
ComponentSize = data.ComponentSize;
ulong componentMT = data.ComponentMethodTable;
if (componentMT != 0)
{
_componentType = Helpers.Factory.GetOrCreateType(heap, componentMT, 0);
}
}
/// <summary>
/// Flushes the DAC cache. This function <b>must</b> 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 FlushCachedData()
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(ClrRuntime));
}
_heap = null;
_bcl = null;
_threads = default;
_domains = default;
_systemDomain = null;
_sharedDomain = null;
_helpers.DataReader.FlushCachedData();
_helpers.FlushCachedData();
}
internal static ClrType?GetTypeForFieldSig(ITypeFactory factory, SigParser sigParser, ClrHeap heap, ClrModule?module)
{
ClrType?result = null;
bool res;
int etype = 0;
if (res = sigParser.GetCallingConvInfo(out int sigType))
{
DebugOnly.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)
{
ClrType inner = factory.GetOrCreateBasicType((ClrElementType)etype);
result = factory.GetOrCreateArrayType(inner, ranks);
}
}
else if (type == ClrElementType.SZArray)
{
sigParser.PeekElemType(out etype);
type = (ClrElementType)etype;
if (type.IsObjectReference())
{
result = factory.GetOrCreateBasicType(ClrElementType.SZArray);
}
else
{
ClrType inner = factory.GetOrCreateBasicType((ClrElementType)etype);
result = factory.GetOrCreateArrayType(inner, 1);
}
}
else if (type == ClrElementType.Pointer)
{
// Only deal with single pointers for now and types that have already been constructed
sigParser.GetElemType(out etype);
type = (ClrElementType)etype;
sigParser.GetToken(out int token);
if (module != null)
{
ClrType?innerType = factory.GetOrCreateTypeFromToken(module, (uint)token);
if (innerType is null)
{
innerType = factory.GetOrCreateBasicType(type);
}
result = factory.GetOrCreatePointerType(innerType, 1);
}
}
else if (type == ClrElementType.Object || type == ClrElementType.Class)
{
result = heap.ObjectType;
}
else
{
// struct, then try to get the token
int token = 0;
if (etype == 0x11 || etype == 0x12)
{
sigParser.GetToken(out token);
}
if (token != 0 && module != null)
{
result = factory.GetOrCreateTypeFromToken(module, (uint)token);
}
if (result is null)
{
result = factory.GetOrCreateBasicType((ClrElementType)etype);
}
}
}
if (result is null)
{
return(result);
}
if (result.IsArray && result.ComponentType is null && result is ClrmdArrayType clrmdType)
{
etype = 0;
if (res = sigParser.GetCallingConvInfo(out sigType))
{
DebugOnly.Assert(sigType == SigParser.IMAGE_CEE_CS_CALLCONV_FIELD);
}
res = res && sigParser.SkipCustomModifiers();
res = res && sigParser.GetElemType(out etype);
_ = res && sigParser.GetElemType(out etype);
// Generic instantiation
if (etype == 0x15)
{
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)
{
sigParser.GetToken(out token);
}
if (token != 0 && module != null)
{
clrmdType.SetComponentType(factory.GetOrCreateTypeFromToken(module, (uint)token));
}
else
{
clrmdType.SetComponentType(factory.GetOrCreateBasicType((ClrElementType)etype));
}
}
return(result);
}
public void Initialize()
{
_ = AppDomains;
_bcl = _helpers.GetBaseClassLibrary(this);
}
