//
// fieldHandle - the "tkFieldDef" that identifies the field.
// definingType - the "tkTypeDef" that defined the field (this is where you get the metadata reader that created fieldHandle.)
// contextType - the type that supplies the type context (i.e. substitutions for generic parameters.) Though you
// get your raw information from "definingType", you report "contextType" as your DeclaringType property.
//
// For example:
//
// typeof(Foo<>).GetTypeInfo().DeclaredMembers
//
// The definingType and contextType are both Foo<>
//
// typeof(Foo<int,String>).GetTypeInfo().DeclaredMembers
//
// The definingType is "Foo<,>"
// The contextType is "Foo<int,String>"
//
// We don't report any DeclaredMembers for arrays or generic parameters so those don't apply.
//
private RuntimeFieldInfo(FieldHandle fieldHandle, RuntimeNamedTypeInfo definingTypeInfo, RuntimeTypeInfo contextTypeInfo)
{
_fieldHandle = fieldHandle;
_definingTypeInfo = definingTypeInfo;
_contextTypeInfo = contextTypeInfo;
_reader = definingTypeInfo.Reader;
_field = fieldHandle.GetField(_reader);
}
//
// fieldHandle - the "tkFieldDef" that identifies the field.
// definingType - the "tkTypeDef" that defined the field (this is where you get the metadata reader that created fieldHandle.)
// contextType - the type that supplies the type context (i.e. substitutions for generic parameters.) Though you
// get your raw information from "definingType", you report "contextType" as your DeclaringType property.
//
// For example:
//
// typeof(Foo<>).GetTypeInfo().DeclaredMembers
//
// The definingType and contextType are both Foo<>
//
// typeof(Foo<int,String>).GetTypeInfo().DeclaredMembers
//
// The definingType is "Foo<,>"
// The contextType is "Foo<int,String>"
//
// We don't report any DeclaredMembers for arrays or generic parameters so those don't apply.
//
private NativeFormatRuntimeFieldInfo(FieldHandle fieldHandle, NativeFormatRuntimeNamedTypeInfo definingTypeInfo, RuntimeTypeInfo contextTypeInfo, RuntimeTypeInfo reflectedType) :
base(contextTypeInfo, reflectedType)
{
_fieldHandle = fieldHandle;
_definingTypeInfo = definingTypeInfo;
_reader = definingTypeInfo.Reader;
_field = fieldHandle.GetField(_reader);
}
/// <summary>
/// Try to look up field acccess info for given canon in metadata blobs for all available modules.
/// </summary>
/// <param name="metadataReader">Metadata reader for the declaring type</param>
/// <param name="declaringTypeHandle">Declaring type for the method</param>
/// <param name="fieldHandle">Field handle</param>
/// <param name="canonFormKind">Canonical form to use</param>
/// <param name="fieldAccessMetadata">Output - metadata information for field accessor construction</param>
/// <returns>true when found, false otherwise</returns>
public static bool TryGetFieldAccessMetadata(
MetadataReader metadataReader,
RuntimeTypeHandle runtimeTypeHandle,
FieldHandle fieldHandle,
out FieldAccessMetadata fieldAccessMetadata)
{
fieldAccessMetadata = default(FieldAccessMetadata);
if (TryGetFieldAccessMetadataFromFieldAccessMap(
metadataReader,
runtimeTypeHandle,
fieldHandle,
CanonicalFormKind.Specific,
ref fieldAccessMetadata))
{
return true;
}
if (TryGetFieldAccessMetadataFromFieldAccessMap(
metadataReader,
runtimeTypeHandle,
fieldHandle,
CanonicalFormKind.Universal,
ref fieldAccessMetadata))
{
return true;
}
TypeSystemContext context = TypeSystemContextFactory.Create();
bool success = TryGetFieldAccessMetadataFromNativeFormatMetadata(
metadataReader,
runtimeTypeHandle,
fieldHandle,
context,
ref fieldAccessMetadata);
TypeSystemContextFactory.Recycle(context);
return success;
}
public abstract IEnumerable<CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, FieldHandle fieldHandle, TypeDefinitionHandle declaringTypeHandle);
public abstract FieldAccessor TryGetFieldAccessor(RuntimeTypeHandle declaringTypeHandle, RuntimeTypeHandle fieldTypeHandle, FieldHandle fieldHandle);
public abstract bool GetDefaultValueIfAny(MetadataReader reader, FieldHandle fieldHandle, Type declaredType, IEnumerable<CustomAttributeData> customAttributes, out Object defaultValue);
} // IsNull
internal bool IsNull(FieldHandle handle)
{
return (handle._value & 0x00FFFFFF) == 0;
} // IsNull
} // ToHandle
internal Handle ToHandle(FieldHandle handle)
{
return new Handle(handle._value);
} // ToHandle
} // Read
public static uint Read(this NativeReader reader, uint offset, out FieldHandle[] values)
{
uint count;
offset = reader.DecodeUnsigned(offset, out count);
#if !NETFX_45
if (count == 0)
{
values = Array.Empty<FieldHandle>();
}
else
#endif
{
values = new FieldHandle[count];
for (uint i = 0; i < count; ++i)
{
FieldHandle tmp;
offset = reader.Read(offset, out tmp);
values[i] = tmp;
}
}
return offset;
} // Read
} // Read
public static uint Read(this NativeReader reader, uint offset, out FieldHandle handle)
{
uint value;
offset = reader.DecodeUnsigned(offset, out value);
handle = new FieldHandle((int)value);
handle._Validate();
return offset;
} // Read
public abstract FieldAccessor TryGetFieldAccessor(MetadataReader reader, RuntimeTypeHandle declaringTypeHandle, RuntimeTypeHandle fieldTypeHandle, FieldHandle fieldHandle);
/// <summary>
/// Try to figure out field access information based on type metadata for native format types.
/// </summary>
/// <param name="metadataReader">Metadata reader for the declaring type</param>
/// <param name="declaringTypeHandle">Declaring type for the method</param>
/// <param name="fieldHandle">Field handle</param>
/// <param name="canonFormKind">Canonical form to use</param>
/// <param name="fieldAccessMetadata">Output - metadata information for field accessor construction</param>
/// <returns>true when found, false otherwise</returns>
private static bool TryGetFieldAccessMetadataFromNativeFormatMetadata(
MetadataReader metadataReader,
RuntimeTypeHandle declaringTypeHandle,
FieldHandle fieldHandle,
TypeSystemContext context,
ref FieldAccessMetadata fieldAccessMetadata)
{
Field field = metadataReader.GetField(fieldHandle);
string fieldName = metadataReader.GetString(field.Name);
TypeDesc declaringType = context.ResolveRuntimeTypeHandle(declaringTypeHandle);
#if SUPPORTS_NATIVE_METADATA_TYPE_LOADING
if (declaringType is MetadataType)
{
return TryGetFieldAccessMetadataForNativeFormatType(declaringType, fieldName, ref fieldAccessMetadata);
}
#endif
return false;
}
/// <summary>
/// Try to look up field acccess info for given canon in metadata blobs for all available modules.
/// </summary>
/// <param name="metadataReader">Metadata reader for the declaring type</param>
/// <param name="declaringTypeHandle">Declaring type for the method</param>
/// <param name="fieldHandle">Field handle</param>
/// <param name="canonFormKind">Canonical form to use</param>
/// <param name="fieldAccessMetadata">Output - metadata information for field accessor construction</param>
/// <returns>true when found, false otherwise</returns>
private static bool TryGetFieldAccessMetadataFromFieldAccessMap(
MetadataReader metadataReader,
RuntimeTypeHandle declaringTypeHandle,
FieldHandle fieldHandle,
CanonicalFormKind canonFormKind,
ref FieldAccessMetadata fieldAccessMetadata)
{
CanonicallyEquivalentEntryLocator canonWrapper = new CanonicallyEquivalentEntryLocator(declaringTypeHandle, canonFormKind);
IntPtr fieldHandleModule = ModuleList.Instance.GetModuleForMetadataReader(metadataReader);
bool isDynamicType = RuntimeAugments.IsDynamicType(declaringTypeHandle);
string fieldName = null;
RuntimeTypeHandle declaringTypeHandleDefinition = Instance.GetTypeDefinition(declaringTypeHandle);
foreach (IntPtr mappingTableModule in ModuleList.Enumerate(RuntimeAugments.GetModuleFromTypeHandle(declaringTypeHandle)))
{
NativeReader fieldMapReader;
if (!TryGetNativeReaderForBlob(mappingTableModule, ReflectionMapBlob.FieldAccessMap, out fieldMapReader))
continue;
NativeParser fieldMapParser = new NativeParser(fieldMapReader, 0);
NativeHashtable fieldHashtable = new NativeHashtable(fieldMapParser);
ExternalReferencesTable externalReferences = default(ExternalReferencesTable);
if (!externalReferences.InitializeCommonFixupsTable(mappingTableModule))
{
continue;
}
var lookup = fieldHashtable.Lookup(canonWrapper.LookupHashCode);
NativeParser entryParser;
while (!(entryParser = lookup.GetNext()).IsNull)
{
// Grammar of a hash table entry:
// Flags + DeclaringType + MdHandle or Name + Cookie or Ordinal or Offset
FieldTableFlags entryFlags = (FieldTableFlags)entryParser.GetUnsigned();
if ((canonFormKind == CanonicalFormKind.Universal) != entryFlags.HasFlag(FieldTableFlags.IsUniversalCanonicalEntry))
continue;
RuntimeTypeHandle entryDeclaringTypeHandle = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
if (!entryDeclaringTypeHandle.Equals(declaringTypeHandle)
&& !canonWrapper.IsCanonicallyEquivalent(entryDeclaringTypeHandle))
continue;
if (entryFlags.HasFlag(FieldTableFlags.HasMetadataHandle))
{
Handle entryFieldHandle = (((int)HandleType.Field << 24) | (int)entryParser.GetUnsigned()).AsHandle();
if (!fieldHandle.Equals(entryFieldHandle))
continue;
}
else
{
if (fieldName == null)
{
MetadataReader mdReader;
TypeDefinitionHandle typeDefHandleUnused;
bool success = Instance.TryGetMetadataForNamedType(
declaringTypeHandleDefinition,
out mdReader,
out typeDefHandleUnused);
Debug.Assert(success);
fieldName = mdReader.GetString(fieldHandle.GetField(mdReader).Name);
}
string entryFieldName = entryParser.GetString();
if (fieldName != entryFieldName)
continue;
}
int cookieOrOffsetOrOrdinal = (int)entryParser.GetUnsigned();
int fieldOffset;
IntPtr fieldAddressCookie = IntPtr.Zero;
if (canonFormKind == CanonicalFormKind.Universal)
{
if (!TypeLoaderEnvironment.Instance.TryGetFieldOffset(declaringTypeHandle, (uint)cookieOrOffsetOrOrdinal, out fieldOffset))
{
Debug.Assert(false);
return false;
}
}
else
{
#if CORERT
fieldOffset = cookieOrOffsetOrOrdinal;
#else
fieldOffset = (int)externalReferences.GetRvaFromIndex((uint)cookieOrOffsetOrOrdinal);
#endif
}
if ((entryFlags & FieldTableFlags.StorageClass) == FieldTableFlags.ThreadStatic)
{
if (canonFormKind != CanonicalFormKind.Universal)
{
fieldAddressCookie = RvaToNonGenericStaticFieldAddress(mappingTableModule, fieldOffset);
}
if (!entryDeclaringTypeHandle.Equals(declaringTypeHandle))
{
// In this case we didn't find an exact match, but we did find a canonically equivalent match
// We might be in the dynamic type case, or the canonically equivalent, but not the same case.
if (!RuntimeAugments.IsDynamicType(declaringTypeHandle))
{
int offsetToCreateCookieFor = fieldOffset;
// We're working with a statically generated type, but we didn't find an exact match in the tables
if (canonFormKind != CanonicalFormKind.Universal)
offsetToCreateCookieFor = checked((int)TypeLoaderEnvironment.GetThreadStaticTypeOffsetFromThreadStaticCookie(fieldAddressCookie));
fieldAddressCookie = TypeLoaderEnvironment.Instance.TryGetThreadStaticFieldOffsetCookieForTypeAndFieldOffset(declaringTypeHandle, checked((uint)offsetToCreateCookieFor));
}
}
}
fieldAccessMetadata.MappingTableModule = mappingTableModule;
fieldAccessMetadata.Cookie = fieldAddressCookie;
fieldAccessMetadata.Flags = entryFlags;
fieldAccessMetadata.Offset = fieldOffset;
return true;
}
}
return false;
}
public static bool TryGetFieldAccessMetadata(
MetadataReader metadataReader,
RuntimeTypeHandle runtimeTypeHandle,
FieldHandle fieldHandle,
out FieldAccessMetadata fieldAccessMetadata)
{
throw new NotImplementedException();
}
private FieldInfo GetFieldInfo(RuntimeTypeHandle declaringTypeHandle, FieldHandle fieldHandle)
{
RuntimeTypeInfo contextTypeInfo = declaringTypeHandle.GetTypeForRuntimeTypeHandle();
NativeFormatRuntimeNamedTypeInfo definingTypeInfo = contextTypeInfo.AnchoringTypeDefinitionForDeclaredMembers.CastToNativeFormatRuntimeNamedTypeInfo();
MetadataReader reader = definingTypeInfo.Reader;
// RuntimeFieldHandles always yield FieldInfo's whose ReflectedType equals the DeclaringType.
RuntimeTypeInfo reflectedType = contextTypeInfo;
return NativeFormatRuntimeFieldInfo.GetRuntimeFieldInfo(fieldHandle, definingTypeInfo, contextTypeInfo, reflectedType);
}
public abstract bool TryGetFieldFromHandleAndType(RuntimeFieldHandle runtimeFieldHandle, RuntimeTypeHandle declaringTypeHandle, out FieldHandle fieldHandle);
private FieldInfo GetFieldInfo(RuntimeTypeHandle declaringTypeHandle, FieldHandle fieldHandle)
{
RuntimeTypeInfo contextTypeInfo = declaringTypeHandle.GetTypeForRuntimeTypeHandle();
RuntimeNamedTypeInfo definingTypeInfo = contextTypeInfo.AnchoringTypeDefinitionForDeclaredMembers;
MetadataReader reader = definingTypeInfo.Reader;
return RuntimeFieldInfo.GetRuntimeFieldInfo(fieldHandle, definingTypeInfo, contextTypeInfo);
}
} // Equals
public bool Equals(FieldHandle handle)
{
return _value == handle._value;
} // Equals
} // Read
public static uint Read(this NativeReader reader, uint offset, out FieldHandle[] values)
{
uint count;
offset = reader.DecodeUnsigned(offset, out count);
if (count == 0)
{
values = s_emptyFieldHandleArray;
}
else
{
values = new FieldHandle[count];
for (uint i = 0; i < count; ++i)
{
FieldHandle tmp;
offset = reader.Read(offset, out tmp);
values[i] = tmp;
}
}
return offset;
} // Read
} // GetEvent
public Field GetField(FieldHandle handle)
{
var record = new Field() { _reader = this, _handle = handle };
var offset = (uint)handle.Offset;
offset = _streamReader.Read(offset, out record._flags);
offset = _streamReader.Read(offset, out record._name);
offset = _streamReader.Read(offset, out record._signature);
offset = _streamReader.Read(offset, out record._defaultValue);
offset = _streamReader.Read(offset, out record._offset);
offset = _streamReader.Read(offset, out record._customAttributes);
return record;
} // GetField
