示例#1
0
 public ISymbolNode TypeGCStaticsSymbol(MetadataType type)
 {
     if (_compilationModuleGroup.ContainsType(type))
     {
         return(_GCStatics.GetOrAdd(type));
     }
     else
     {
         return(ExternSymbol(GCStaticsNode.GetMangledName(type, NodeFactory.NameMangler)));
     }
 }
示例#2
0
 public ISymbolNode TypeGCStaticsSymbol(MetadataType type)
 {
     Debug.Assert(!TypeCannotHaveEEType(type));
     if (_compilationModuleGroup.ContainsType(type))
     {
         return(_GCStatics.GetOrAdd(type));
     }
     else
     {
         return(ExternSymbol(GCStaticsNode.GetMangledName(type, NameMangler)));
     }
 }
 public override ISortableSymbolNode ImportedGCStaticNode(NodeFactory factory, MetadataType type)
 {
     return(new ExternSymbolNode(GCStaticsNode.GetMangledName(type, factory.NameMangler)));
 }
示例#4
0
 protected override sealed string GetNonImportedName(NameMangler nameMangler) => GCStaticsNode.GetMangledName(Type, nameMangler);
示例#5
0
        private void CreateNodeCaches()
        {
            _typeSymbols = new NodeCache <TypeDesc, IEETypeNode>((TypeDesc type) =>
            {
                Debug.Assert(!_compilationModuleGroup.ShouldReferenceThroughImportTable(type));
                if (_compilationModuleGroup.ContainsType(type))
                {
                    if (type.IsGenericDefinition)
                    {
                        return(new GenericDefinitionEETypeNode(this, type));
                    }
                    else if (type.IsCanonicalDefinitionType(CanonicalFormKind.Any))
                    {
                        return(new CanonicalDefinitionEETypeNode(this, type));
                    }
                    else if (type.IsCanonicalSubtype(CanonicalFormKind.Any))
                    {
                        return(new NecessaryCanonicalEETypeNode(this, type));
                    }
                    else
                    {
                        return(new EETypeNode(this, type));
                    }
                }
                else
                {
                    return(new ExternEETypeSymbolNode(this, type));
                }
            });

            _constructedTypeSymbols = new NodeCache <TypeDesc, IEETypeNode>((TypeDesc type) =>
            {
                // Canonical definition types are *not* constructed types (call NecessaryTypeSymbol to get them)
                Debug.Assert(!type.IsCanonicalDefinitionType(CanonicalFormKind.Any));
                Debug.Assert(!_compilationModuleGroup.ShouldReferenceThroughImportTable(type));

                if (_compilationModuleGroup.ContainsType(type))
                {
                    if (type.IsCanonicalSubtype(CanonicalFormKind.Any))
                    {
                        return(new CanonicalEETypeNode(this, type));
                    }
                    else
                    {
                        return(new ConstructedEETypeNode(this, type));
                    }
                }
                else
                {
                    return(new ExternEETypeSymbolNode(this, type));
                }
            });

            _clonedTypeSymbols = new NodeCache <TypeDesc, IEETypeNode>((TypeDesc type) =>
            {
                // Only types that reside in other binaries should be cloned
                Debug.Assert(_compilationModuleGroup.ShouldReferenceThroughImportTable(type));
                return(new ClonedConstructedEETypeNode(this, type));
            });

            _importedTypeSymbols = new NodeCache <TypeDesc, IEETypeNode>((TypeDesc type) =>
            {
                Debug.Assert(_compilationModuleGroup.ShouldReferenceThroughImportTable(type));
                return(new ImportedEETypeSymbolNode(this, type));
            });

            _nonGCStatics = new NodeCache <MetadataType, ISymbolNode>((MetadataType type) =>
            {
                if (_compilationModuleGroup.ContainsType(type))
                {
                    return(new NonGCStaticsNode(type, this));
                }
                else if (_compilationModuleGroup.ShouldReferenceThroughImportTable(type))
                {
                    return(new ImportedNonGCStaticsNode(this, type));
                }
                else
                {
                    return(new ExternSymbolNode(NonGCStaticsNode.GetMangledName(type, NameMangler)));
                }
            });

            _GCStatics = new NodeCache <MetadataType, ISymbolNode>((MetadataType type) =>
            {
                if (_compilationModuleGroup.ContainsType(type))
                {
                    return(new GCStaticsNode(type));
                }
                else if (_compilationModuleGroup.ShouldReferenceThroughImportTable(type))
                {
                    return(new ImportedGCStaticsNode(this, type));
                }
                else
                {
                    return(new ExternSymbolNode(GCStaticsNode.GetMangledName(type, NameMangler)));
                }
            });

            _GCStaticsPreInitDataNodes = new NodeCache <MetadataType, GCStaticsPreInitDataNode>((MetadataType type) =>
            {
                ISymbolNode gcStaticsNode = TypeGCStaticsSymbol(type);
                Debug.Assert(gcStaticsNode is GCStaticsNode);
                return(((GCStaticsNode)gcStaticsNode).NewPreInitDataNode());
            });

            _GCStaticIndirectionNodes = new NodeCache <MetadataType, EmbeddedObjectNode>((MetadataType type) =>
            {
                ISymbolNode gcStaticsNode = TypeGCStaticsSymbol(type);
                Debug.Assert(gcStaticsNode is GCStaticsNode);
                return(GCStaticsRegion.NewNode((GCStaticsNode)gcStaticsNode));
            });

            _threadStatics = new NodeCache <MetadataType, ISymbolDefinitionNode>(CreateThreadStaticsNode);

            _typeThreadStaticIndices = new NodeCache <MetadataType, TypeThreadStaticIndexNode>(type =>
            {
                return(new TypeThreadStaticIndexNode(type));
            });

            _GCStaticEETypes = new NodeCache <GCPointerMap, GCStaticEETypeNode>((GCPointerMap gcMap) =>
            {
                return(new GCStaticEETypeNode(Target, gcMap));
            });

            _readOnlyDataBlobs = new NodeCache <ReadOnlyDataBlobKey, BlobNode>(key =>
            {
                return(new BlobNode(key.Name, ObjectNodeSection.ReadOnlyDataSection, key.Data, key.Alignment));
            });

            _externSymbols = new NodeCache <string, ExternSymbolNode>((string name) =>
            {
                return(new ExternSymbolNode(name));
            });

            _pInvokeModuleFixups = new NodeCache <string, PInvokeModuleFixupNode>((string name) =>
            {
                return(new PInvokeModuleFixupNode(name));
            });

            _pInvokeMethodFixups = new NodeCache <Tuple <string, string>, PInvokeMethodFixupNode>((Tuple <string, string> key) =>
            {
                return(new PInvokeMethodFixupNode(key.Item1, key.Item2));
            });

            _methodEntrypoints = new NodeCache <MethodDesc, IMethodNode>(CreateMethodEntrypointNode);

            _unboxingStubs = new NodeCache <MethodDesc, IMethodNode>(CreateUnboxingStubNode);

            _fatFunctionPointers = new NodeCache <MethodKey, FatFunctionPointerNode>(method =>
            {
                return(new FatFunctionPointerNode(method.Method, method.IsUnboxingStub));
            });

            _gvmDependenciesNode = new NodeCache <MethodDesc, GVMDependenciesNode>(method =>
            {
                return(new GVMDependenciesNode(method));
            });

            _gvmTableEntries = new NodeCache <TypeDesc, TypeGVMEntriesNode>(type =>
            {
                return(new TypeGVMEntriesNode(type));
            });

            _reflectableMethods = new NodeCache <MethodDesc, ReflectableMethodNode>(method =>
            {
                return(new ReflectableMethodNode(method));
            });

            _shadowConcreteMethods = new NodeCache <MethodKey, IMethodNode>(methodKey =>
            {
                MethodDesc canonMethod = methodKey.Method.GetCanonMethodTarget(CanonicalFormKind.Specific);

                if (methodKey.IsUnboxingStub)
                {
                    return(new ShadowConcreteUnboxingThunkNode(methodKey.Method, MethodEntrypoint(canonMethod, true)));
                }
                else
                {
                    return(new ShadowConcreteMethodNode(methodKey.Method, MethodEntrypoint(canonMethod)));
                }
            });

            _runtimeDeterminedMethods = new NodeCache <MethodDesc, IMethodNode>(method =>
            {
                return(new RuntimeDeterminedMethodNode(method,
                                                       MethodEntrypoint(method.GetCanonMethodTarget(CanonicalFormKind.Specific))));
            });

            _virtMethods = new NodeCache <MethodDesc, VirtualMethodUseNode>((MethodDesc method) =>
            {
                // We don't need to track virtual method uses for types that have a vtable with a known layout.
                // It's a waste of CPU time and memory.
                Debug.Assert(!VTable(method.OwningType).HasFixedSlots);

                return(new VirtualMethodUseNode(method));
            });

            _readyToRunHelpers = new NodeCache <ReadyToRunHelperKey, ISymbolNode>(CreateReadyToRunHelperNode);

            _genericReadyToRunHelpersFromDict = new NodeCache <ReadyToRunGenericHelperKey, ISymbolNode>(data =>
            {
                return(new ReadyToRunGenericLookupFromDictionaryNode(this, data.HelperId, data.Target, data.DictionaryOwner));
            });

            _genericReadyToRunHelpersFromType = new NodeCache <ReadyToRunGenericHelperKey, ISymbolNode>(data =>
            {
                return(new ReadyToRunGenericLookupFromTypeNode(this, data.HelperId, data.Target, data.DictionaryOwner));
            });

            _indirectionNodes = new NodeCache <ISymbolNode, ISymbolNode>(indirectedNode =>
            {
                return(new IndirectionNode(Target, indirectedNode, 0));
            });

            _frozenStringNodes = new NodeCache <string, FrozenStringNode>((string data) =>
            {
                return(new FrozenStringNode(data, Target));
            });

            _frozenArrayNodes = new NodeCache <PreInitFieldInfo, FrozenArrayNode>((PreInitFieldInfo fieldInfo) =>
            {
                return(new FrozenArrayNode(fieldInfo));
            });

            _interfaceDispatchCells = new NodeCache <DispatchCellKey, InterfaceDispatchCellNode>(callSiteCell =>
            {
                return(new InterfaceDispatchCellNode(callSiteCell.Target, callSiteCell.CallsiteId));
            });

            _interfaceDispatchMaps = new NodeCache <TypeDesc, InterfaceDispatchMapNode>((TypeDesc type) =>
            {
                return(new InterfaceDispatchMapNode(type));
            });

            _runtimeMethodHandles = new NodeCache <MethodDesc, RuntimeMethodHandleNode>((MethodDesc method) =>
            {
                return(new RuntimeMethodHandleNode(method));
            });

            _runtimeFieldHandles = new NodeCache <FieldDesc, RuntimeFieldHandleNode>((FieldDesc field) =>
            {
                return(new RuntimeFieldHandleNode(field));
            });

            _interfaceDispatchMapIndirectionNodes = new NodeCache <TypeDesc, EmbeddedObjectNode>((TypeDesc type) =>
            {
                var dispatchMap = InterfaceDispatchMap(type);
                return(DispatchMapTable.NewNodeWithSymbol(dispatchMap, (indirectionNode) =>
                {
                    dispatchMap.SetDispatchMapIndex(this, DispatchMapTable.IndexOfEmbeddedObject(indirectionNode));
                }));
            });

            _genericCompositions = new NodeCache <GenericCompositionDetails, GenericCompositionNode>((GenericCompositionDetails details) =>
            {
                return(new GenericCompositionNode(details));
            });

            _eagerCctorIndirectionNodes = new NodeCache <MethodDesc, EmbeddedObjectNode>((MethodDesc method) =>
            {
                Debug.Assert(method.IsStaticConstructor);
                Debug.Assert(TypeSystemContext.HasEagerStaticConstructor((MetadataType)method.OwningType));
                return(EagerCctorTable.NewNode(MethodEntrypoint(method)));
            });

            _namedJumpStubNodes = new NodeCache <Tuple <string, ISymbolNode>, NamedJumpStubNode>((Tuple <string, ISymbolNode> id) =>
            {
                return(new NamedJumpStubNode(id.Item1, id.Item2));
            });

            _vTableNodes = new NodeCache <TypeDesc, VTableSliceNode>((TypeDesc type ) =>
            {
                if (CompilationModuleGroup.ShouldProduceFullVTable(type))
                {
                    return(new EagerlyBuiltVTableSliceNode(type));
                }
                else
                {
                    return(_vtableSliceProvider.GetSlice(type));
                }
            });

            _methodGenericDictionaries = new NodeCache <MethodDesc, ISymbolNode>(method =>
            {
                if (CompilationModuleGroup.ContainsMethodDictionary(method))
                {
                    return(new MethodGenericDictionaryNode(method, this));
                }
                else
                {
                    return(new ImportedMethodGenericDictionaryNode(this, method));
                }
            });

            _typeGenericDictionaries = new NodeCache <TypeDesc, ISymbolNode>(type =>
            {
                if (CompilationModuleGroup.ContainsType(type))
                {
                    Debug.Assert(!this.LazyGenericsPolicy.UsesLazyGenerics(type));
                    return(new TypeGenericDictionaryNode(type, this));
                }
                else
                {
                    return(new ImportedTypeGenericDictionaryNode(this, type));
                }
            });

            _typesWithMetadata = new NodeCache <MetadataType, TypeMetadataNode>(type =>
            {
                return(new TypeMetadataNode(type));
            });

            _methodsWithMetadata = new NodeCache <MethodDesc, MethodMetadataNode>(method =>
            {
                return(new MethodMetadataNode(method));
            });

            _fieldsWithMetadata = new NodeCache <FieldDesc, FieldMetadataNode>(field =>
            {
                return(new FieldMetadataNode(field));
            });

            _modulesWithMetadata = new NodeCache <ModuleDesc, ModuleMetadataNode>(module =>
            {
                return(new ModuleMetadataNode(module));
            });

            _genericDictionaryLayouts = new NodeCache <TypeSystemEntity, DictionaryLayoutNode>(_dictionaryLayoutProvider.GetLayout);

            _stringAllocators = new NodeCache <MethodDesc, IMethodNode>(constructor =>
            {
                return(new StringAllocatorMethodNode(constructor));
            });

            NativeLayout     = new NativeLayoutHelper(this);
            WindowsDebugData = new WindowsDebugDataHelper(this);
        }
示例#6
0
 public ImportedGCStaticsNode(NodeFactory factory, MetadataType type)
     : base("__imp_" + GCStaticsNode.GetMangledName(type, factory.NameMangler))
 {
 }