//
// 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);
}
//
// 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);
}
/// <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;
}
