public virtual bool IsEqualToEntryByComponentsComparison(GenericTypeEntry other) { if (!other._genericTypeDefinitionHandle.Equals(_genericTypeDefinitionHandle)) { return(false); } if (other._genericTypeArgumentHandles == null) { return(false); } if (other._genericTypeArgumentHandles.Length != _genericTypeArgumentHandles.Length) { return(false); } for (int i = 0; i < _genericTypeArgumentHandles.Length; i++) { if (!other._genericTypeArgumentHandles[i].Equals(_genericTypeArgumentHandles[i])) { return(false); } } return(true); }
internal override bool MatchGenericTypeEntry(GenericTypeEntry entry) { TypeSystemContext context = _typeToLookup.Context; DefType parsedTypeDefinition = (DefType)context.ResolveRuntimeTypeHandle(entry._genericTypeDefinitionHandle); Instantiation parsedArgs = context.ResolveRuntimeTypeHandles(entry._genericTypeArgumentHandles); DefType parsedGenericType = context.ResolveGenericInstantiation(parsedTypeDefinition, parsedArgs); return(parsedGenericType == _typeToLookup); }
internal override bool MatchGenericTypeEntry(GenericTypeEntry entry) { if (!entry._genericTypeDefinitionHandle.Equals(_genericTypeDefinitionHandle)) { return(false); } if (entry._genericTypeArgumentHandles == null) { return(false); } if (_typeToLookup != null) { int expectedArity = _typeToLookup.Instantiation.Length; if (entry._genericTypeArgumentHandles.Length != expectedArity) { return(false); } for (int i = 0; i < expectedArity; i++) { if (!entry._genericTypeArgumentHandles[i].Equals(_typeToLookup.Instantiation[i].RuntimeTypeHandle)) { return(false); } } } else { if (entry._genericTypeArgumentHandles.Length != _genericTypeArgumentHandles.Length) { return(false); } for (int i = 0; i < _genericTypeArgumentHandles.Length; i++) { if (!entry._genericTypeArgumentHandles[i].Equals(_genericTypeArgumentHandles[i])) { return(false); } } } return(true); }
internal abstract bool MatchGenericTypeEntry(GenericTypeEntry entry);
internal void RegisterDynamicGenericTypesAndMethods(DynamicGenericsRegistrationData registrationData) { using (LockHolder.Hold(_dynamicGenericsLock)) { int registeredTypesCount = 0; int registeredMethodsCount = 0; int nativeFormatTypesRegisteredCount = 0; TypeEntryToRegister[] registeredTypes = null; GenericMethodEntry[] registeredMethods = null; try { if (registrationData.TypesToRegister != null) { registeredTypes = new TypeEntryToRegister[registrationData.TypesToRegisterCount]; foreach (TypeEntryToRegister typeEntry in registrationData.TypesToRegister) { // Keep track of registered type handles so that that we can rollback the registration on exception registeredTypes[registeredTypesCount++] = typeEntry; // Information tracked in these dictionaries is (partially) redundant with information tracked by MRT. // We can save a bit of memory by avoiding the redundancy where possible. For now, we are keeping it simple. // Register type -> components mapping first so that we can use it during rollback below if (typeEntry.GenericTypeEntry != null) { GenericTypeEntry registeredTypeEntry = _dynamicGenericTypes.AddOrGetExisting(typeEntry.GenericTypeEntry); if (registeredTypeEntry != typeEntry.GenericTypeEntry && registeredTypeEntry._isRegisteredSuccessfully) { throw new ArgumentException(SR.Argument_AddingDuplicate); } registeredTypeEntry._instantiatedTypeHandle = typeEntry.GenericTypeEntry._instantiatedTypeHandle; registeredTypeEntry._isRegisteredSuccessfully = true; } else { MetadataType metadataType = typeEntry.MetadataDefinitionType; IntPtr nonGcStaticFields = IntPtr.Zero; IntPtr gcStaticFields = IntPtr.Zero; #if SUPPORTS_NATIVE_METADATA_TYPE_LOADING #if SUPPORTS_R2R_LOADING uint nonGcStaticsRva = 0; uint gcStaticsRva = 0; // For images where statics are directly embedded in the image, store the information about where // to find statics info if (TypeLoaderEnvironment.TryGetStaticsTableEntry(metadataType, out nonGcStaticsRva, out gcStaticsRva)) { ModuleInfo moduleInfo = TypeLoaderEnvironment.GetModuleInfoForType(metadataType); if (nonGcStaticsRva == 0) { nonGcStaticFields = TypeLoaderEnvironment.NoStaticsData; } else { nonGcStaticFields = moduleInfo.Handle + checked ((int)nonGcStaticsRva); } if (gcStaticsRva == 0) { gcStaticFields = TypeLoaderEnvironment.NoStaticsData; } else { gcStaticFields = moduleInfo.Handle + checked ((int)gcStaticsRva); } } #endif TypeSystem.NativeFormat.NativeFormatType nativeFormatType = metadataType as TypeSystem.NativeFormat.NativeFormatType; if (nativeFormatType != null) { RegisterNewNamedTypeRuntimeTypeHandle(new QTypeDefinition(nativeFormatType.MetadataReader, nativeFormatType.Handle), nativeFormatType.GetTypeBuilderState().HalfBakedRuntimeTypeHandle, nonGcStaticFields, gcStaticFields); } #if ECMA_METADATA_SUPPORT TypeSystem.Ecma.EcmaType ecmaFormatType = metadataType as TypeSystem.Ecma.EcmaType; if (ecmaFormatType != null) { RegisterNewNamedTypeRuntimeTypeHandle(new QTypeDefinition(ecmaFormatType.MetadataReader, ecmaFormatType.Handle), ecmaFormatType.GetTypeBuilderState().HalfBakedRuntimeTypeHandle, nonGcStaticFields, gcStaticFields); } #endif nativeFormatTypesRegisteredCount++; #else Environment.FailFast("Ready to Run module type?"); #endif } } } Debug.Assert(registeredTypesCount == registrationData.TypesToRegisterCount); if (registrationData.MethodsToRegister != null) { registeredMethods = new GenericMethodEntry[registrationData.MethodsToRegisterCount]; foreach (GenericMethodEntry methodEntry in registrationData.MethodsToRegister) { Debug.Assert(methodEntry._methodDictionary != IntPtr.Zero); // Keep track of registered method dictionaries so that that we can rollback the registration on exception registeredMethods[registeredMethodsCount++] = methodEntry; // Register method dictionary -> components mapping first so that we can use it during rollback below GenericMethodEntry registeredMethodComponentsEntry = _dynamicGenericMethodComponents.AddOrGetExisting(methodEntry); if (registeredMethodComponentsEntry != methodEntry && registeredMethodComponentsEntry._isRegisteredSuccessfully) { throw new ArgumentException(SR.Argument_AddingDuplicate); } GenericMethodEntry registeredMethodEntry = _dynamicGenericMethods.AddOrGetExisting(methodEntry); if (registeredMethodEntry != methodEntry && registeredMethodEntry._isRegisteredSuccessfully) { throw new ArgumentException(SR.Argument_AddingDuplicate); } Debug.Assert(registeredMethodComponentsEntry == registeredMethodEntry); registeredMethodEntry._methodDictionary = methodEntry._methodDictionary; registeredMethodEntry._isRegisteredSuccessfully = true; } } Debug.Assert(registeredMethodsCount == registrationData.MethodsToRegisterCount); } catch { // Catch and rethrow any exceptions instead of using finally block. Otherwise, filters that are run during // the first pass of exception unwind may see partially registered types. // TODO: Convert this to filter for better diagnostics once we switch to Roslyn // Undo types that were registered. There should be no memory allocations or other failure points. try { for (int i = 0; i < registeredTypesCount; i++) { var typeEntry = registeredTypes[i]; // There is no Remove feature in the LockFreeReaderHashtable... if (typeEntry.GenericTypeEntry != null) { GenericTypeEntry failedEntry = _dynamicGenericTypes.GetValueIfExists(typeEntry.GenericTypeEntry); if (failedEntry != null) { failedEntry._isRegisteredSuccessfully = false; } } else { #if SUPPORTS_NATIVE_METADATA_TYPE_LOADING TypeSystem.NativeFormat.NativeFormatType nativeFormatType = typeEntry.MetadataDefinitionType as TypeSystem.NativeFormat.NativeFormatType; if (nativeFormatType != null) { UnregisterNewNamedTypeRuntimeTypeHandle(new QTypeDefinition(nativeFormatType.MetadataReader, nativeFormatType.Handle), nativeFormatType.GetTypeBuilderState().HalfBakedRuntimeTypeHandle); } #if ECMA_METADATA_SUPPORT TypeSystem.Ecma.EcmaType ecmaFormatType = typeEntry.MetadataDefinitionType as TypeSystem.Ecma.EcmaType; if (ecmaFormatType != null) { UnregisterNewNamedTypeRuntimeTypeHandle(new QTypeDefinition(ecmaFormatType.MetadataReader, ecmaFormatType.Handle), ecmaFormatType.GetTypeBuilderState().HalfBakedRuntimeTypeHandle); } #endif #else Environment.FailFast("Ready to Run module type?"); #endif } } for (int i = 0; i < registeredMethodsCount; i++) { // There is no Remove feature in the LockFreeReaderHashtable... GenericMethodEntry failedEntry = _dynamicGenericMethods.GetValueIfExists(registeredMethods[i]); if (failedEntry != null) { failedEntry._isRegisteredSuccessfully = false; } failedEntry = _dynamicGenericMethodComponents.GetValueIfExists(registeredMethods[i]); if (failedEntry != null) { failedEntry._isRegisteredSuccessfully = false; } } } catch (Exception e) { // Catch any exceptions and fail fast just in case Environment.FailFast("Exception during registration rollback", e); } throw; } if (nativeFormatTypesRegisteredCount > 0) { FinishAddingNewNamedTypes(); } } }