public static void RuntimeTypeHandleTest() { RuntimeTypeHandle h = typeof(int).TypeHandle; Assert.NotEqual(h, typeof(uint).TypeHandle); Assert.True(h.Value != IntPtr.Zero); Assert.Equal(h.GetHashCode(), h.GetHashCode()); Assert.Equal(default(RuntimeTypeHandle).GetHashCode(), default(RuntimeTypeHandle).GetHashCode()); Assert.True(h.Equals(h)); Assert.False(h.Equals(default(RuntimeTypeHandle))); Assert.False(default(RuntimeTypeHandle).Equals(h)); Assert.True(default(RuntimeTypeHandle).Equals(default(RuntimeTypeHandle))); Assert.True(h.Equals((object)h)); Assert.False(h.Equals(typeof(int))); Assert.False(h.Equals(new object())); Assert.False(h.Equals(null)); Assert.False(h == null); Assert.False(null == h); Assert.True(h != null); Assert.True(null != h); }
public static void RuntimeTypeHandleTest() { RuntimeTypeHandle h = typeof(int).TypeHandle; Assert.NotEqual(h, typeof(uint).TypeHandle); Assert.True(h.Value != IntPtr.Zero); Assert.Equal(h.GetHashCode(), h.GetHashCode()); Assert.Equal(default(RuntimeTypeHandle).GetHashCode(), default(RuntimeTypeHandle).GetHashCode()); Assert.True(h.Equals(h)); Assert.False(h.Equals(default(RuntimeTypeHandle))); Assert.False(default(RuntimeTypeHandle).Equals(h)); Assert.True(default(RuntimeTypeHandle).Equals(default(RuntimeTypeHandle))); Assert.True(h.Equals((object)h)); Assert.True(((IEquatable <RuntimeTypeHandle>)h).Equals(h)); Assert.False(h.Equals(typeof(int))); Assert.False(h.Equals(new object())); Assert.False(h.Equals(null)); Assert.False(h == null); Assert.False(null == h); Assert.True(h != null); Assert.True(null != h); IntPtr hPtr = RuntimeTypeHandle.ToIntPtr(h); RuntimeTypeHandle hNew = RuntimeTypeHandle.FromIntPtr(hPtr); Assert.True(h.Equals(hNew)); Assert.True(hNew.Equals(h)); }
internal virtual void InternalSerialize(XmlWriterDelegator xmlWriter, object obj, bool isDeclaredType, bool writeXsiType, int declaredTypeID, RuntimeTypeHandle declaredTypeHandle) #endif { if (writeXsiType) { Type declaredType = Globals.TypeOfObject; SerializeWithXsiType(xmlWriter, obj, obj.GetType().TypeHandle, null /*type*/, -1, declaredType.TypeHandle, declaredType); } else if (isDeclaredType) { DataContract contract = GetDataContract(declaredTypeID, declaredTypeHandle); SerializeWithoutXsiType(contract, xmlWriter, obj, declaredTypeHandle); } else { RuntimeTypeHandle objTypeHandle = obj.GetType().TypeHandle; if (declaredTypeHandle.GetHashCode() == objTypeHandle.GetHashCode()) // semantically the same as Value == Value; Value is not available in SL { DataContract dataContract = (declaredTypeID >= 0) ? GetDataContract(declaredTypeID, declaredTypeHandle) : GetDataContract(declaredTypeHandle, null /*type*/); SerializeWithoutXsiType(dataContract, xmlWriter, obj, declaredTypeHandle); } else { SerializeWithXsiType(xmlWriter, obj, objTypeHandle, null /*type*/, declaredTypeID, declaredTypeHandle, Type.GetTypeFromHandle(declaredTypeHandle)); } } }
/// <summary> /// Setter for RuntimeTypeHandle. Seperate from normal property as all uses should be done with great care. /// Must not be set with partially constructed type handles /// </summary> public void SetRuntimeTypeHandleUnsafe(RuntimeTypeHandle runtimeTypeHandle) { Debug.Assert(!runtimeTypeHandle.IsNull()); Debug.Assert(_runtimeTypeHandle.IsNull() || runtimeTypeHandle.Equals(_runtimeTypeHandle)); Debug.Assert(runtimeTypeHandle.GetHashCode() == GetHashCode()); _runtimeTypeHandle = runtimeTypeHandle; }
private unsafe bool TryGetStructData(RuntimeTypeHandle structTypeHandle, out ExternalReferencesTable externalReferences, out NativeParser entryParser) { int structHashcode = structTypeHandle.GetHashCode(); externalReferences = default(ExternalReferencesTable); entryParser = default(NativeParser); foreach (NativeFormatModuleInfo module in ModuleList.EnumerateModules()) { NativeReader structMapReader; if (TryGetNativeReaderForBlob(module, ReflectionMapBlob.StructMarshallingStubMap, out structMapReader)) { NativeParser structMapParser = new NativeParser(structMapReader, 0); NativeHashtable structHashtable = new NativeHashtable(structMapParser); externalReferences.InitializeCommonFixupsTable(module); var lookup = structHashtable.Lookup(structHashcode); while (!(entryParser = lookup.GetNext()).IsNull) { RuntimeTypeHandle foundStructType = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (foundStructType.Equals(structTypeHandle)) { return(true); } } } } return(false); }
public bool TryLookupExactMethodPointerForComponents(RuntimeTypeHandle declaringType, MethodNameAndSignature nameAndSignature, RuntimeTypeHandle[] genericMethodArgumentHandles, out IntPtr result) { int lookupHashcode = declaringType.GetHashCode(); NativeHashtable hashtable; ExternalReferencesTable externalReferencesLookup; HandleBasedGenericMethodLookup lookupData = new HandleBasedGenericMethodLookup(declaringType, nameAndSignature, genericMethodArgumentHandles); foreach (NativeFormatModuleInfo module in ModuleList.EnumerateModules()) { if (!GetHashtableFromBlob(module, ReflectionMapBlob.ExactMethodInstantiationsHashtable, out hashtable, out externalReferencesLookup)) { continue; } var enumerator = hashtable.Lookup(lookupHashcode); NativeParser entryParser; while (!(entryParser = enumerator.GetNext()).IsNull) { if (!lookupData.MatchParsedEntry(ref entryParser, ref externalReferencesLookup, module.Handle)) { continue; } // We found a match result = externalReferencesLookup.GetIntPtrFromIndex(entryParser.GetUnsigned()); return(true); } } result = IntPtr.Zero; return(false); }
public unsafe IntPtr TryGetMarshallerForDelegate(RuntimeTypeHandle delegateTypeHandle) { int delegateHashcode = delegateTypeHandle.GetHashCode(); foreach (NativeFormatModuleInfo module in ModuleList.EnumerateModules()) { NativeReader delegateMapReader; if (TryGetNativeReaderForBlob(module, ReflectionMapBlob.DelegateMarshallingStubMap, out delegateMapReader)) { NativeParser delegateMapParser = new NativeParser(delegateMapReader, 0); NativeHashtable delegateHashtable = new NativeHashtable(delegateMapParser); ExternalReferencesTable externalReferences = default(ExternalReferencesTable); externalReferences.InitializeCommonFixupsTable(module); var lookup = delegateHashtable.Lookup(delegateHashcode); NativeParser entryParser; while (!(entryParser = lookup.GetNext()).IsNull) { RuntimeTypeHandle foundDelegateType = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (foundDelegateType.Equals(delegateTypeHandle)) { byte *pByte = (byte *)externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned()); return((IntPtr)pByte); } } } } return(IntPtr.Zero); }
private NativeParser GetStaticInfo(RuntimeTypeHandle instantiatedType, out ExternalReferencesTable staticsInfoLookup) { TypeManagerHandle moduleHandle = RuntimeAugments.GetModuleFromTypeHandle(instantiatedType); NativeFormatModuleInfo module = ModuleList.Instance.GetModuleInfoByHandle(moduleHandle); NativeHashtable staticsInfoHashtable; ExternalReferencesTable externalReferencesLookup; if (!GetStaticsInfoHashtable(module, out staticsInfoHashtable, out externalReferencesLookup, out staticsInfoLookup)) { return(new NativeParser()); } int lookupHashcode = instantiatedType.GetHashCode(); var enumerator = staticsInfoHashtable.Lookup(lookupHashcode); NativeParser entryParser; while (!(entryParser = enumerator.GetNext()).IsNull) { RuntimeTypeHandle parsedInstantiatedType = externalReferencesLookup.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (!parsedInstantiatedType.Equals(instantiatedType)) { continue; } return(entryParser); } return(new NativeParser()); }
public override int GetHashCode() { if (!_hashCode.HasValue) { _hashCode = _declaringTypeHandle.GetHashCode() ^ TypeHashingAlgorithms.ComputeGenericInstanceHashCode(TypeHashingAlgorithms.ComputeNameHashCode(_methodNameAndSignature.Name), _genericMethodArgumentHandles); } return(_hashCode.Value); }
public override int GetHashCode() { if (!_hashCode.HasValue) { _hashCode = TypeHashingAlgorithms.ComputeGenericInstanceHashCode(_genericTypeDefinitionHandle.GetHashCode(), _genericTypeArgumentHandles); } return(_hashCode.Value); }
public RuntimeMethodHandleKey(RuntimeTypeHandle declaringType, string methodName, RuntimeSignature signature, RuntimeTypeHandle[] genericArgs) { Debug.Assert(genericArgs != null); _declaringType = declaringType; _methodName = methodName; _signature = signature; _genericArgs = genericArgs; int methodNameHashCode = methodName == null ? 0 : methodName.GetHashCode(); _hashcode = TypeHashingAlgorithms.ComputeGenericInstanceHashCode(declaringType.GetHashCode(), genericArgs) ^ methodNameHashCode ^ signature.GetHashCode(); }
public unsafe static IntPtr TryGetStaticClassConstructionContext(RuntimeTypeHandle typeHandle) { if (RuntimeAugments.HasCctor(typeHandle)) { if (RuntimeAugments.IsDynamicType(typeHandle)) { // For dynamic types, its always possible to get the non-gc static data section directly. byte *ptr = (byte *)*(IntPtr *)RuntimeAugments.GetNonGcStaticFieldData(typeHandle); // what we have now is the base address of the non-gc statics of the type // what we need is the cctor context, which is just before that ptr = ptr - sizeof(System.Runtime.CompilerServices.StaticClassConstructionContext); return((IntPtr)ptr); } else { // Non-dynamic types do not provide a way to directly get at the non-gc static region. // Use the CctorContextMap instead. var moduleHandle = RuntimeAugments.GetModuleFromTypeHandle(typeHandle); Debug.Assert(moduleHandle != IntPtr.Zero); NativeReader typeMapReader; if (TryGetNativeReaderForBlob(moduleHandle, ReflectionMapBlob.CCtorContextMap, out typeMapReader)) { NativeParser typeMapParser = new NativeParser(typeMapReader, 0); NativeHashtable typeHashtable = new NativeHashtable(typeMapParser); ExternalReferencesTable externalReferences = default(ExternalReferencesTable); externalReferences.InitializeCommonFixupsTable(moduleHandle); var lookup = typeHashtable.Lookup(typeHandle.GetHashCode()); NativeParser entryParser; while (!(entryParser = lookup.GetNext()).IsNull) { RuntimeTypeHandle foundType = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (foundType.Equals(typeHandle)) { byte *pNonGcStaticBase = (byte *)externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned()); // cctor context is located before the non-GC static base return((IntPtr)(pNonGcStaticBase - sizeof(System.Runtime.CompilerServices.StaticClassConstructionContext))); } } } } } return(IntPtr.Zero); }
private bool VerifyHashCode(Object o) { bool retVal = true; RuntimeTypeHandle handle = o.GetType().TypeHandle; int value1 = handle.GetHashCode(); int value2 = handle.GetHashCode(); m_ErrorNo++; if (value1 == 0) { TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "RuntimeTypeHandle.GetHashCode returns 0"); retVal = false; } m_ErrorNo++; if (value1 != value2) { TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Call RuntimeTypeHandle.GetHashCode twice returns wrong hash code"); retVal = false; } return(retVal); }
internal RuntimeTypeHandleMap(int size, Func <int, RuntimeTypeHandle> getHandle) : base(size) { m_getHandle = getHandle; for (int i = 0; i < size; i++) { RuntimeTypeHandle handle = getHandle(i); if (!handle.Equals(McgModule.s_DependencyReductionTypeRemovedTypeHandle)) { Add(handle.GetHashCode(), i); } } }
internal int Lookup(RuntimeTypeHandle handle) { for (int slot = GetFirst(handle.GetHashCode()); slot >= 0; slot = GetNext(slot)) { int index = GetIndex(slot); if (handle.Equals(m_getHandle(index))) { return(index); } } return(-1); }
public override int GetHashCode() { unchecked { int hash = Type.GetHashCode(); if (AdditionalImplementedTypes != null) { foreach (var h in AdditionalImplementedTypes) { hash = 37 * hash + h.GetHashCode(); } } return(hash); } }
private bool VerifyHashCode(Object o1, Object o2, bool desiredValue) { bool retVal = true; RuntimeTypeHandle handle1 = o1.GetType().TypeHandle; RuntimeTypeHandle handle2 = o2.GetType().TypeHandle; int value1 = handle1.GetHashCode(); int value2 = handle2.GetHashCode(); bool actualValue = value1 == value2; m_ErrorNo++; if (actualValue != desiredValue) { TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Compare the hash code for handle1 with handle2 returns ACTUAL: " + actualValue.ToString() + ", DESIRED: " + desiredValue.ToString()); retVal = false; } return(retVal); }
private unsafe bool TryGetMarshallersForDelegate(RuntimeTypeHandle delegateTypeHandle, out IntPtr openStub, out IntPtr closedStub, out IntPtr delegateCreationStub) { int delegateHashcode = delegateTypeHandle.GetHashCode(); openStub = IntPtr.Zero; closedStub = IntPtr.Zero; delegateCreationStub = IntPtr.Zero; foreach (NativeFormatModuleInfo module in ModuleList.EnumerateModules()) { NativeReader delegateMapReader; if (TryGetNativeReaderForBlob(module, ReflectionMapBlob.DelegateMarshallingStubMap, out delegateMapReader)) { NativeParser delegateMapParser = new NativeParser(delegateMapReader, 0); NativeHashtable delegateHashtable = new NativeHashtable(delegateMapParser); ExternalReferencesTable externalReferences = default(ExternalReferencesTable); externalReferences.InitializeCommonFixupsTable(module); var lookup = delegateHashtable.Lookup(delegateHashcode); NativeParser entryParser; while (!(entryParser = lookup.GetNext()).IsNull) { RuntimeTypeHandle foundDelegateType = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (foundDelegateType.Equals(delegateTypeHandle)) { byte *pOpen = (byte *)externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned()); byte *pClose = (byte *)externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned()); byte *pDelegateCreation = (byte *)externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned()); openStub = (IntPtr)pOpen; closedStub = (IntPtr)pClose; delegateCreationStub = (IntPtr)pDelegateCreation; return(true); } } } } return(false); }
public unsafe bool TryGetMetadataForNamedType(RuntimeTypeHandle runtimeTypeHandle, out MetadataReader metadataReader, out TypeDefinitionHandle typeDefHandle) { // Iterate over all modules, starting with the module that defines the EEType foreach (IntPtr moduleHandle in ModuleList.Enumerate(RuntimeAugments.GetModuleFromTypeHandle(runtimeTypeHandle))) { NativeReader typeMapReader; if (TryGetNativeReaderForBlob(moduleHandle, ReflectionMapBlob.TypeMap, out typeMapReader)) { NativeParser typeMapParser = new NativeParser(typeMapReader, 0); NativeHashtable typeHashtable = new NativeHashtable(typeMapParser); ExternalReferencesTable externalReferences = default(ExternalReferencesTable); externalReferences.InitializeCommonFixupsTable(moduleHandle); var lookup = typeHashtable.Lookup(runtimeTypeHandle.GetHashCode()); NativeParser entryParser; while (!(entryParser = lookup.GetNext()).IsNull) { RuntimeTypeHandle foundType = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (foundType.Equals(runtimeTypeHandle)) { Handle entryMetadataHandle = entryParser.GetUnsigned().AsHandle(); if (entryMetadataHandle.HandleType == HandleType.TypeDefinition) { metadataReader = ModuleList.Instance.GetMetadataReaderForModule(moduleHandle); typeDefHandle = entryMetadataHandle.ToTypeDefinitionHandle(metadataReader); return(true); } } } } } metadataReader = null; typeDefHandle = default(TypeDefinitionHandle); return(false); }
public RuntimeMethodHandleKey(RuntimeTypeHandle declaringType, string methodName, RuntimeSignature signature, RuntimeTypeHandle[] genericArgs) { // genericArgs will be null if this is a (typical or not) method definition // genericArgs are non-null only for instantiated generic methods. Debug.Assert(genericArgs == null || genericArgs.Length > 0); _declaringType = declaringType; _methodName = methodName; _signature = signature; _genericArgs = genericArgs; int methodNameHashCode = methodName == null ? 0 : methodName.GetHashCode(); _hashcode = methodNameHashCode ^ signature.GetHashCode(); if (genericArgs != null) { _hashcode ^= TypeHashingAlgorithms.ComputeGenericInstanceHashCode(declaringType.GetHashCode(), genericArgs); } else { _hashcode ^= declaringType.GetHashCode(); } }
private static unsafe bool GetMarshallersForDelegate(RuntimeTypeHandle delegateTypeHandle, out IntPtr openStub, out IntPtr closedStub, out IntPtr delegateCreationStub) { int delegateHashcode = delegateTypeHandle.GetHashCode(); openStub = IntPtr.Zero; closedStub = IntPtr.Zero; delegateCreationStub = IntPtr.Zero; foreach (TypeManagerHandle module in RuntimeAugments.GetLoadedModules()) { NativeReader delegateMapReader; if (TryGetNativeReaderForBlob(module, ReflectionMapBlob.DelegateMarshallingStubMap, out delegateMapReader)) { NativeParser delegateMapParser = new NativeParser(delegateMapReader, 0); NativeHashtable delegateHashtable = new NativeHashtable(delegateMapParser); ExternalReferencesTable externalReferences = default(ExternalReferencesTable); externalReferences.InitializeCommonFixupsTable(module); var lookup = delegateHashtable.Lookup(delegateHashcode); NativeParser entryParser; while (!(entryParser = lookup.GetNext()).IsNull) { RuntimeTypeHandle foundDelegateType = externalReferences.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (foundDelegateType.Equals(delegateTypeHandle)) { openStub = externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned()); closedStub = externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned()); delegateCreationStub = externalReferences.GetIntPtrFromIndex(entryParser.GetUnsigned()); return(true); } } } } return(false); }
public override int GetHashCode() { return(m_handle.GetHashCode()); }
internal override int LookupHashCode() { return(_typeToLookup != null?_typeToLookup.GetHashCode() : TypeHashingAlgorithms.ComputeGenericInstanceHashCode(_genericTypeDefinitionHandle.GetHashCode(), _genericTypeArgumentHandles)); }
private bool ResolveInterfaceGenericVirtualMethodSlot_Static(RuntimeTypeHandle targetTypeHandle, ref RuntimeTypeHandle declaringType, ref MethodNameAndSignature methodNameAndSignature) { // Get the open type definition of the containing type of the generic virtual method being resolved RuntimeTypeHandle openCallingTypeHandle = GetTypeDefinition(declaringType); // Get the open type definition of the current type of the object instance on which the GVM is being resolved RuntimeTypeHandle openTargetTypeHandle; RuntimeTypeHandle[] targetTypeInstantiation; openTargetTypeHandle = GetOpenTypeDefinition(targetTypeHandle, out targetTypeInstantiation); #if REFLECTION_EXECUTION_TRACE ReflectionExecutionLogger.WriteLine("INTERFACE GVM call = " + GetTypeNameDebug(declaringType) + "." + methodNameAndSignature.Name); #endif foreach (NativeFormatModuleInfo module in ModuleList.EnumerateModules(RuntimeAugments.GetModuleFromTypeHandle(openTargetTypeHandle))) { NativeReader gvmTableReader; if (!TryGetNativeReaderForBlob(module, ReflectionMapBlob.InterfaceGenericVirtualMethodTable, out gvmTableReader)) { continue; } NativeReader nativeLayoutReader; if (!TryGetNativeReaderForBlob(module, ReflectionMapBlob.NativeLayoutInfo, out nativeLayoutReader)) { continue; } NativeParser gvmTableParser = new NativeParser(gvmTableReader, 0); NativeHashtable gvmHashtable = new NativeHashtable(gvmTableParser); ExternalReferencesTable extRefs = default(ExternalReferencesTable); extRefs.InitializeCommonFixupsTable(module); var lookup = gvmHashtable.Lookup(openCallingTypeHandle.GetHashCode()); NativeParser entryParser; while (!(entryParser = lookup.GetNext()).IsNull) { RuntimeTypeHandle interfaceTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (!openCallingTypeHandle.Equals(interfaceTypeHandle)) { continue; } uint nameAndSigToken = extRefs.GetExternalNativeLayoutOffset(entryParser.GetUnsigned()); MethodNameAndSignature interfaceMethodNameAndSignature = GetMethodNameAndSignatureFromNativeReader(nativeLayoutReader, module.Handle, nameAndSigToken); if (!interfaceMethodNameAndSignature.Equals(methodNameAndSignature)) { continue; } // For each of the possible GVM slot targets for the current interface call, we will do the following: // // Step 1: Scan the types that currently provide implementations for the current GVM slot target, and look // for ones that match the target object's type. // // Step 2: For each type that we find in step #1, get a list of all the interfaces that the current GVM target // provides an implementation for // // Step 3: For each interface in the list in step #2, parse the signature of that interface, do the generic argument // substitution (in case of a generic interface), and check if this interface signature is assignable from the // calling interface signature (from the name and sig input). if there is an exact match based on // interface type, then we've found the right slot. Otherwise, re-scan the entry again and see if some interface // type is compatible with the initial slots interface by means of variance. // This is done by calling the TypeLoaderEnvironment helper function. // // Example: // public interface IFoo<out T, out U> // { // string M1<V>(); // } // public class Foo1<T, U> : IFoo<T, U>, IFoo<Kvp<T, string>, U> // { // string IFoo<T, U>.M1<V>() { ... } // public virtual string M1<V>() { ... } // } // public class Foo2<T, U> : Foo1<object, U>, IFoo<U, T> // { // string IFoo<U, T>.M1<V>() { ... } // } // // GVM Table layout for IFoo<T, U>.M1<V>: // { // InterfaceTypeHandle = IFoo<T, U> // InterfaceMethodNameAndSignature = { "M1", SigOf(string M1) } // GVMTargetSlots[] = // { // { // TargetMethodNameAndSignature = { "M1", SigOf(M1) } // TargetTypeHandle = Foo1<T, U> // ImplementingTypes[] = { // ImplementingTypeHandle = Foo1<T, U> // ImplementedInterfacesSignatures[] = { SigOf(IFoo<!0, !1>) } // } // }, // // { // TargetMethodNameAndSignature = { "M1", SigOf(M1) } // TargetTypeHandle = Foo1<T, U> // ImplementingTypes[] = { // ImplementingTypeHandle = Foo1<T, U> // ImplementedInterfacesSignatures[] = { SigOf(IFoo<Kvp<!0, string>, !1>) } // } // }, // // { // TargetMethodNameAndSignature = { "M1", SigOf(M1) } // TargetTypeHandle = Foo2<T, U> // ImplementingTypes = { // ImplementingTypeHandle = Foo2<T, U> // ImplementedInterfacesSignatures[] = { SigOf(IFoo<!1, !0>) } // } // }, // } // } // uint currentOffset = entryParser.Offset; // Non-variant dispatch of a variant generic interface generic virtual method. if (FindMatchingInterfaceSlot(module, nativeLayoutReader, ref entryParser, ref extRefs, ref declaringType, ref methodNameAndSignature, openTargetTypeHandle, targetTypeInstantiation, false)) { return(true); } entryParser.Offset = currentOffset; // Variant dispatch of a variant generic interface generic virtual method. if (FindMatchingInterfaceSlot(module, nativeLayoutReader, ref entryParser, ref extRefs, ref declaringType, ref methodNameAndSignature, openTargetTypeHandle, targetTypeInstantiation, true)) { return(true); } } } return(false); }
/// <summary> /// Construct McgModule /// </summary> public unsafe McgModule( int mcgDataModulePriority, McgInterfaceData[] interfaceData, CCWTemplateData[] ccwTemplateData, FixupRuntimeTypeHandle[] supportedInterfaceList, McgClassData[] classData, McgBoxingData[] boxingData, McgAdditionalClassData[] additionalClassData, McgCollectionData[] collectionData, McgPInvokeDelegateData[] pinvokeDelegateData, McgCCWFactoryInfoEntry[] ccwFactories, McgStructMarshalData[] structMarshalData, McgUnsafeStructFieldOffsetData[] unsafeStructFieldOffsetData, McgGenericArgumentMarshalInfo[] genericArgumentMarshalInfo, McgHashcodeVerifyEntry[] hashcodeVerifyData) { m_mcgDataModulePriority = mcgDataModulePriority; m_interfaceData = interfaceData; m_classData = classData; m_boxingData = boxingData; m_collectionData = collectionData; m_pinvokeDelegateData = pinvokeDelegateData; m_additionalClassData = additionalClassData; m_ccwFactories = ccwFactories; m_structMarshalData = structMarshalData; m_unsafeStructOffsetData = unsafeStructFieldOffsetData; m_genericArgumentMarshalInfo = genericArgumentMarshalInfo; m_ccwTemplateData = ccwTemplateData; // Following code is disabled due to lazy static constructor dependency from McgModule which is // static eager constructor. Undo this when McgCurrentModule is using ModuleConstructorAttribute // -- Today McgCurrentModule cannot use ModuleConstructor attribute. Module constructors are called // after ReflectionExecution has been initialized but ReflectionExecution.Initialize requires // McgCurrentModule to have already been initialized because the assembly binder needs MCG support // for assembly (scope) name enumeration while registering the new module for reflection. #if EAGER_CTOR_WORKAROUND Debug.Assert(m_interfaceTypeInfo != null); #endif if (supportedInterfaceList != null) { m_supportedInterfaceList = new RuntimeTypeHandle[supportedInterfaceList.Length]; for (int i = 0; i < supportedInterfaceList.Length; i++) { m_supportedInterfaceList[i] = supportedInterfaceList[i].RuntimeTypeHandle; } } else { m_supportedInterfaceList = null; } m_hashcodeVerifyData = hashcodeVerifyData; #if DEBUG // Check no duplicate RuntimeTypeHandle in hashtable if (m_interfaceData != null) { System.Collections.Generic.Internal.HashSet <EquatableRuntimeTypeHandle> intfHashSet = new System.Collections.Generic.Internal.HashSet <EquatableRuntimeTypeHandle>(m_interfaceData.Length); foreach (McgInterfaceData item in m_interfaceData) { RuntimeTypeHandle typeHnd = item.ItfType; if (!typeHnd.Equals(s_DependencyReductionTypeRemovedTypeHandle) && !typeHnd.Equals(default(RuntimeTypeHandle))) { if (intfHashSet.Add(new EquatableRuntimeTypeHandle(typeHnd), typeHnd.GetHashCode())) { Debug.Fail("Duplicate RuntimeTypeHandle found in m_interfaceData"); } } } } if (m_classData != null) { System.Collections.Generic.Internal.HashSet <EquatableRuntimeTypeHandle> classHashSet = new System.Collections.Generic.Internal.HashSet <EquatableRuntimeTypeHandle>(m_classData.Length); foreach (McgClassData item in m_classData) { RuntimeTypeHandle typeHnd = item.ClassType; if (!typeHnd.Equals(s_DependencyReductionTypeRemovedTypeHandle) && !typeHnd.Equals(default(RuntimeTypeHandle))) { if (classHashSet.Add(new EquatableRuntimeTypeHandle(typeHnd), typeHnd.GetHashCode())) { Debug.Fail("Duplicate RuntimeTypeHandle found in m_classData"); } } } } Debug.Assert(this.VerifyHashCodes()); #endif }
private unsafe bool ResolveGenericVirtualMethodTarget_Static(RuntimeTypeHandle targetTypeHandle, RuntimeTypeHandle declaringType, RuntimeTypeHandle[] genericArguments, MethodNameAndSignature callingMethodNameAndSignature, out IntPtr methodPointer, out IntPtr dictionaryPointer) { methodPointer = dictionaryPointer = IntPtr.Zero; // Get the open type definition of the containing type of the generic virtual method being resolved RuntimeTypeHandle openCallingTypeHandle = GetTypeDefinition(declaringType); // Get the open type definition of the current type of the object instance on which the GVM is being resolved RuntimeTypeHandle openTargetTypeHandle = GetTypeDefinition(targetTypeHandle); int hashCode = openCallingTypeHandle.GetHashCode(); hashCode = ((hashCode << 13) ^ hashCode) ^ openTargetTypeHandle.GetHashCode(); #if REFLECTION_EXECUTION_TRACE ReflectionExecutionLogger.WriteLine("GVM Target Resolution = " + GetTypeNameDebug(targetTypeHandle) + "." + callingMethodNameAndSignature.Name); #endif foreach (NativeFormatModuleInfo module in ModuleList.EnumerateModules(RuntimeAugments.GetModuleFromTypeHandle(openTargetTypeHandle))) { NativeReader gvmTableReader; if (!TryGetNativeReaderForBlob(module, ReflectionMapBlob.GenericVirtualMethodTable, out gvmTableReader)) { continue; } NativeReader nativeLayoutReader; if (!TryGetNativeReaderForBlob(module, ReflectionMapBlob.NativeLayoutInfo, out nativeLayoutReader)) { continue; } NativeParser gvmTableParser = new NativeParser(gvmTableReader, 0); NativeHashtable gvmHashtable = new NativeHashtable(gvmTableParser); ExternalReferencesTable extRefs = default(ExternalReferencesTable); extRefs.InitializeCommonFixupsTable(module); var lookup = gvmHashtable.Lookup(hashCode); NativeParser entryParser; while (!(entryParser = lookup.GetNext()).IsNull) { RuntimeTypeHandle parsedCallingTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (!parsedCallingTypeHandle.Equals(openCallingTypeHandle)) { continue; } RuntimeTypeHandle parsedTargetTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned()); if (!parsedTargetTypeHandle.Equals(openTargetTypeHandle)) { continue; } uint parsedCallingNameAndSigToken = extRefs.GetExternalNativeLayoutOffset(entryParser.GetUnsigned()); MethodNameAndSignature parsedCallingNameAndSignature = GetMethodNameAndSignatureFromNativeReader(nativeLayoutReader, module.Handle, parsedCallingNameAndSigToken); if (!parsedCallingNameAndSignature.Equals(callingMethodNameAndSignature)) { continue; } uint parsedTargetMethodNameAndSigToken = extRefs.GetExternalNativeLayoutOffset(entryParser.GetUnsigned()); MethodNameAndSignature targetMethodNameAndSignature = GetMethodNameAndSignatureFromNativeReader(nativeLayoutReader, module.Handle, parsedTargetMethodNameAndSigToken); Debug.Assert(targetMethodNameAndSignature != null); if (!TryGetGenericVirtualMethodPointer(targetTypeHandle, targetMethodNameAndSignature, genericArguments, out methodPointer, out dictionaryPointer)) { Environment.FailFast("GVM method pointer lookup failure"); } return(true); } } return(false); }
public RuntimeFieldHandleKey(RuntimeTypeHandle declaringType, string fieldName) { _declaringType = declaringType; _fieldName = fieldName; _hashcode = declaringType.GetHashCode() ^ fieldName.GetHashCode(); }
internal override int LookupHashCode() { // Todo: Signatures in the hash code. return(_methodToLookup != null?_methodToLookup.GetHashCode() : (_declaringType.GetHashCode() ^ TypeHashingAlgorithms.ComputeGenericInstanceHashCode(TypeHashingAlgorithms.ComputeNameHashCode(_nameAndSignature.Name), _genericMethodArgumentHandles))); }
public override int GetHashCode() { return(CalcHashCode(_resolveType, _handle, _methodHandleOrSlotOrCodePointer.GetHashCode(), _declaringType.GetHashCode())); }
public TypeDesc ResolveRuntimeTypeHandle(RuntimeTypeHandle rtth) { TypeDesc returnedType; if (_runtimeTypeHandleResolutionCache.TryGetValue(rtth, out returnedType)) { return(returnedType); } if (rtth.Equals(CanonType.RuntimeTypeHandle)) { returnedType = CanonType; } else if (rtth.Equals(UniversalCanonType.RuntimeTypeHandle)) { returnedType = UniversalCanonType; } else if (RuntimeAugments.IsGenericTypeDefinition(rtth)) { returnedType = TryGetMetadataBasedTypeFromRuntimeTypeHandle_Uncached(rtth); if (returnedType == null) { unsafe { TypeDesc[] genericParameters = new TypeDesc[rtth.ToEETypePtr()->GenericArgumentCount]; for (int i = 0; i < genericParameters.Length; i++) { genericParameters[i] = GetSignatureVariable(i, false); } returnedType = new NoMetadataType(this, rtth, null, new Instantiation(genericParameters), rtth.GetHashCode()); } } } else if (RuntimeAugments.IsGenericType(rtth)) { RuntimeTypeHandle typeDefRuntimeTypeHandle; RuntimeTypeHandle[] genericArgRuntimeTypeHandles; typeDefRuntimeTypeHandle = RuntimeAugments.GetGenericInstantiation(rtth, out genericArgRuntimeTypeHandles); DefType typeDef = (DefType)ResolveRuntimeTypeHandle(typeDefRuntimeTypeHandle); Instantiation genericArgs = ResolveRuntimeTypeHandles(genericArgRuntimeTypeHandles); returnedType = ResolveGenericInstantiation(typeDef, genericArgs); } else if (RuntimeAugments.IsArrayType(rtth)) { RuntimeTypeHandle elementTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth); TypeDesc elementType = ResolveRuntimeTypeHandle(elementTypeHandle); unsafe { if (rtth.ToEETypePtr()->IsSzArray) { returnedType = GetArrayType(elementType); } else { returnedType = GetArrayType(elementType, rtth.ToEETypePtr()->ArrayRank); } } } else if (RuntimeAugments.IsUnmanagedPointerType(rtth)) { RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth); TypeDesc targetType = ResolveRuntimeTypeHandle(targetTypeHandle); returnedType = GetPointerType(targetType); } else if (RuntimeAugments.IsByRefType(rtth)) { RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth); TypeDesc targetType = ResolveRuntimeTypeHandle(targetTypeHandle); returnedType = GetByRefType(targetType); } else { returnedType = TryGetMetadataBasedTypeFromRuntimeTypeHandle_Uncached(rtth); if (returnedType == null) { returnedType = new NoMetadataType(this, rtth, null, Instantiation.Empty, rtth.GetHashCode()); } } // We either retrieved an existing DefType that is already registered with the runtime // or one that is not associated with an MethodTable yet. If it's not associated, associate it. if (returnedType.RuntimeTypeHandle.IsNull()) { TypeBuilderState state = returnedType.GetTypeBuilderStateIfExist(); bool skipStoringRuntimeTypeHandle = false; // If we've already attempted to lookup and failed to retrieve this type handle, we // may have already decided to create a new one. In that case, do not attempt to abort // that creation process as it may have already begun the process of type creation if (state != null && state.AttemptedAndFailedToRetrieveTypeHandle) { skipStoringRuntimeTypeHandle = true; } if (!skipStoringRuntimeTypeHandle) { returnedType.SetRuntimeTypeHandleUnsafe(rtth); } } _runtimeTypeHandleResolutionCache.Add(rtth, returnedType); return(returnedType.WithDebugName()); }