public static bool ShouldInclude(this ITypeDefinitionMember member, EmitContext context) { if (context.IncludePrivateMembers) { return(true); } var method = member as IMethodDefinition; if (method != null && method.IsVirtual) { return(true); } switch (member.Visibility) { case TypeMemberVisibility.Private: return(context.IncludePrivateMembers); case TypeMemberVisibility.Assembly: case TypeMemberVisibility.FamilyAndAssembly: return(context.IncludePrivateMembers || context.Module.SourceAssemblyOpt?.InternalsAreVisible == true); } return(true); }
public static MetadataWriter Create( EmitContext context, CommonMessageProvider messageProvider, bool metadataOnly, bool deterministic, bool emitTestCoverageData, bool hasPdbStream, CancellationToken cancellationToken) { var builder = new MetadataBuilder(); MetadataBuilder?debugBuilderOpt; switch (context.Module.DebugInformationFormat) { case DebugInformationFormat.PortablePdb: debugBuilderOpt = hasPdbStream ? new MetadataBuilder() : null; break; case DebugInformationFormat.Embedded: debugBuilderOpt = metadataOnly ? null : new MetadataBuilder(); break; default: debugBuilderOpt = null; break; } var dynamicAnalysisDataWriterOpt = emitTestCoverageData ? new DynamicAnalysisDataWriter(context.Module.DebugDocumentCount, context.Module.HintNumberOfMethodDefinitions) : null; return(new FullMetadataWriter(context, builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, messageProvider, metadataOnly, deterministic, emitTestCoverageData, cancellationToken)); }
internal Cci.IMetadataConstant GetMetadataConstantValue(EmitContext context) { if (!HasMetadataConstantValue) { return null; } ConstantValue constant = this.ExplicitDefaultConstantValue; TypeSymbol type; if (constant.SpecialType != SpecialType.None) { // preserve the exact type of the constant for primitive types, // e.g. it should be Int16 for [DefaultParameterValue((short)1)]int x type = this.ContainingAssembly.GetSpecialType(constant.SpecialType); } else { // default(struct), enum type = this.Type; } return ((PEModuleBuilder)context.Module).CreateConstant(type, constant.Value, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics); }
public static MetadataWriter Create( EmitContext context, CommonMessageProvider messageProvider, bool allowMissingMethodBodies, bool deterministic, bool hasPdbStream, CancellationToken cancellationToken) { var heaps = new MetadataHeapsBuilder(); MetadataHeapsBuilder debugHeapsOpt; switch (context.ModuleBuilder.EmitOptions.DebugInformationFormat) { case DebugInformationFormat.PortablePdb: debugHeapsOpt = hasPdbStream ? new MetadataHeapsBuilder() : null; break; case DebugInformationFormat.Embedded: debugHeapsOpt = heaps; break; default: debugHeapsOpt = null; break; } return(new FullMetadataWriter(context, heaps, debugHeapsOpt, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken)); }
public static MetadataWriter Create( EmitContext context, CommonMessageProvider messageProvider, bool allowMissingMethodBodies, bool deterministic, bool hasPdbStream, CancellationToken cancellationToken) { var builder = new MetadataBuilder(); MetadataBuilder debugBuilderOpt; switch (context.ModuleBuilder.EmitOptions.DebugInformationFormat) { case DebugInformationFormat.PortablePdb: debugBuilderOpt = hasPdbStream ? new MetadataBuilder() : null; break; case DebugInformationFormat.Embedded: debugBuilderOpt = new MetadataBuilder(); break; default: debugBuilderOpt = null; break; } var dynamicAnalysisDataWriterOpt = context.ModuleBuilder.EmitOptions.EmitDynamicAnalysisData ? new DynamicAnalysisDataWriter(context.Module.DebugDocumentCount, context.Module.HintNumberOfMethodDefinitions) : null; return(new FullMetadataWriter(context, builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken)); }
Cci.INamedTypeReference Cci.IGenericTypeInstanceReference.GetGenericType(EmitContext context) { System.Diagnostics.Debug.Assert(UnderlyingNamedType.OriginalDefinition.IsDefinition); PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module; return moduleBeingBuilt.Translate(this.UnderlyingNamedType.OriginalDefinition, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics, needDeclaration: true); }
public PEDeltaAssemblyBuilder( SourceAssemblySymbol sourceAssembly, string outputName, OutputKind outputKind, ModulePropertiesForSerialization serializationProperties, IEnumerable<ResourceDescription> manifestResources, Func<AssemblySymbol, AssemblyIdentity> assemblySymbolMapper, EmitBaseline previousGeneration, IEnumerable<SemanticEdit> edits) : base(sourceAssembly, outputName, outputKind, serializationProperties, manifestResources, assemblySymbolMapper, additionalTypes: ImmutableArray<NamedTypeSymbol>.Empty, metadataOnly:false) { var context = new EmitContext(this, null, new DiagnosticBag()); var module = previousGeneration.OriginalMetadata; var compilation = sourceAssembly.DeclaringCompilation; var metadataAssembly = compilation.GetBoundReferenceManager().CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata.Create(module), MetadataImportOptions.All); var metadataDecoder = new Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE.MetadataDecoder(metadataAssembly.PrimaryModule); previousGeneration = EnsureInitialized(previousGeneration, metadataDecoder); var matchToMetadata = new SymbolMatcher(previousGeneration.AnonymousTypeMap, sourceAssembly, context, metadataAssembly); SymbolMatcher matchToPrevious = null; if (previousGeneration.Ordinal > 0) { var previousAssembly = ((CSharpCompilation)previousGeneration.Compilation).SourceAssembly; var previousContext = new EmitContext((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag()); matchToPrevious = new SymbolMatcher(previousGeneration.AnonymousTypeMap, sourceAssembly, context, previousAssembly, previousContext); } this.previousDefinitions = new CSharpDefinitionMap(previousGeneration.OriginalMetadata.Module, edits, metadataDecoder, matchToMetadata, matchToPrevious); this.previousGeneration = previousGeneration; this.changes = new SymbolChanges(this.previousDefinitions, edits); }
private FullMetadataWriter( EmitContext context, MetadataHeapsBuilder heaps, CommonMessageProvider messageProvider, bool allowMissingMethodBodies, bool deterministic, CancellationToken cancellationToken) : base(heaps, context, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken) { // EDMAURER make some intelligent guesses for the initial sizes of these things. int numMethods = this.module.HintNumberOfMethodDefinitions; int numTypeDefsGuess = numMethods / 6; int numFieldDefsGuess = numTypeDefsGuess * 4; int numPropertyDefsGuess = numMethods / 4; _typeDefs = new DefinitionIndex <ITypeDefinition>(numTypeDefsGuess); _eventDefs = new DefinitionIndex <IEventDefinition>(0); _fieldDefs = new DefinitionIndex <IFieldDefinition>(numFieldDefsGuess); _methodDefs = new DefinitionIndex <IMethodDefinition>(numMethods); _propertyDefs = new DefinitionIndex <IPropertyDefinition>(numPropertyDefsGuess); _parameterDefs = new DefinitionIndex <IParameterDefinition>(numMethods); _genericParameters = new DefinitionIndex <IGenericParameter>(0); _fieldDefIndex = new Dictionary <ITypeDefinition, uint>(numTypeDefsGuess); _methodDefIndex = new Dictionary <ITypeDefinition, uint>(numTypeDefsGuess); _parameterListIndex = new Dictionary <IMethodDefinition, uint>(numMethods); _assemblyRefIndex = new HeapOrReferenceIndex <IAssemblyReference>(this, AssemblyReferenceComparer.Instance); _moduleRefIndex = new HeapOrReferenceIndex <string>(this); _memberRefIndex = new InstanceAndStructuralReferenceIndex <ITypeMemberReference>(this, new MemberRefComparer(this)); _methodSpecIndex = new InstanceAndStructuralReferenceIndex <IGenericMethodInstanceReference>(this, new MethodSpecComparer(this)); _typeRefIndex = new HeapOrReferenceIndex <ITypeReference>(this); _typeSpecIndex = new InstanceAndStructuralReferenceIndex <ITypeReference>(this, new TypeSpecComparer(this)); _standAloneSignatureIndex = new HeapOrReferenceIndex <uint>(this); }
Cci.INestedTypeReference Cci.ISpecializedNestedTypeReference.GetUnspecializedVersion(EmitContext context) { Debug.Assert(UnderlyingNamedType.OriginalDefinition.IsDefinition); var result = ((PEModuleBuilder)context.Module).Translate(this.UnderlyingNamedType.OriginalDefinition, (CSharpSyntaxNode)context.SyntaxNodeOpt, context.Diagnostics, needDeclaration: true).AsNestedTypeReference; Debug.Assert(result != null); return result; }
IEnumerable<Cci.ITypeReference> Cci.IGenericMethodInstanceReference.GetGenericArguments(EmitContext context) { PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module; foreach (var arg in UnderlyingMethod.TypeArguments) { yield return moduleBeingBuilt.Translate(arg, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics); } }
Cci.IMethodReference Cci.IGenericMethodInstanceReference.GetGenericMethod(EmitContext context) { // NoPia method might come through here. return ((PEModuleBuilder)context.Module).Translate( UnderlyingMethod.OriginalDefinition, syntaxNodeOpt: context.SyntaxNodeOpt, diagnostics: context.Diagnostics, needDeclaration: true); }
public byte[] SerializeMethodDebugInfo(EmitContext context, IMethodBody methodBody, uint methodToken, bool isEncDelta, bool suppressNewCustomDebugInfo, out bool emitExternNamespaces) { emitExternNamespaces = false; // CONSIDER: this may not be the same "first" method as in Dev10, but // it shouldn't matter since all methods will still forward to a method // containing the appropriate information. if (_methodBodyWithModuleInfo == null) //UNDONE: || edit-and-continue { // This module level information could go on every method (and does in // the edit-and-continue case), but - as an optimization - we'll just // put it on the first method we happen to encounter and then put a // reference to the first method's token in every other method (so they // can find the information). if (context.Module.GetAssemblyReferenceAliases(context).Any()) { _methodTokenWithModuleInfo = methodToken; _methodBodyWithModuleInfo = methodBody; emitExternNamespaces = true; } } var customDebugInfo = ArrayBuilder<MemoryStream>.GetInstance(); SerializeIteratorClassMetadata(methodBody, customDebugInfo); // NOTE: This is an attempt to match Dev10's apparent behavior. For iterator methods (i.e. the method // that appears in source, not the synthesized ones), Dev10 only emits the ForwardIterator and IteratorLocal // custom debug info (e.g. there will be no information about the usings that were in scope). // NOTE: There seems to be an unusual behavior in ISymUnmanagedWriter where, if all the methods in a type are // iterator methods, no custom debug info is emitted for any method. Adding a single non-iterator // method causes the custom debug info to be produced for all methods (including the iterator methods). // Since we are making the same ISymUnmanagedWriter calls as Dev10, we see the same behavior (i.e. this // is not a regression). if (methodBody.StateMachineTypeName == null) { SerializeNamespaceScopeMetadata(context, methodBody, customDebugInfo); SerializeStateMachineLocalScopes(methodBody, customDebugInfo); } if (!suppressNewCustomDebugInfo) { SerializeDynamicLocalInfo(methodBody, customDebugInfo); // delta doesn't need this information - we use information recorded by previous generation emit if (!isEncDelta) { var encMethodInfo = MetadataWriter.GetEncMethodDebugInfo(methodBody); SerializeCustomDebugInformation(encMethodInfo, customDebugInfo); } } byte[] result = SerializeCustomDebugMetadata(customDebugInfo); customDebugInfo.Free(); return result; }
Cci.IAssemblyReference Cci.IModuleReference.GetContainingAssembly(EmitContext context) { if (this.moduleBeingBuilt.OutputKind.IsNetModule() && ReferenceEquals(moduleBeingBuilt.SourceModule.ContainingAssembly, underlyingModule.ContainingAssembly)) { return null; } return moduleBeingBuilt.Translate(underlyingModule.ContainingAssembly, context.Diagnostics); }
public PEDeltaAssemblyBuilder( SourceAssemblySymbol sourceAssembly, EmitOptions emitOptions, OutputKind outputKind, Cci.ModulePropertiesForSerialization serializationProperties, IEnumerable<ResourceDescription> manifestResources, EmitBaseline previousGeneration, IEnumerable<SemanticEdit> edits, Func<ISymbol, bool> isAddedSymbol) : base(sourceAssembly, emitOptions, outputKind, serializationProperties, manifestResources, additionalTypes: ImmutableArray<NamedTypeSymbol>.Empty) { var initialBaseline = previousGeneration.InitialBaseline; var context = new EmitContext(this, null, new DiagnosticBag()); // Hydrate symbols from initial metadata. Once we do so it is important to reuse these symbols across all generations, // in order for the symbol matcher to be able to use reference equality once it maps symbols to initial metadata. var metadataSymbols = GetOrCreateMetadataSymbols(initialBaseline, sourceAssembly.DeclaringCompilation); var metadataDecoder = (MetadataDecoder)metadataSymbols.MetadataDecoder; var metadataAssembly = (PEAssemblySymbol)metadataDecoder.ModuleSymbol.ContainingAssembly; var matchToMetadata = new CSharpSymbolMatcher(metadataSymbols.AnonymousTypes, sourceAssembly, context, metadataAssembly); CSharpSymbolMatcher matchToPrevious = null; if (previousGeneration.Ordinal > 0) { var previousAssembly = ((CSharpCompilation)previousGeneration.Compilation).SourceAssembly; var previousContext = new EmitContext((PEModuleBuilder)previousGeneration.PEModuleBuilder, null, new DiagnosticBag()); matchToPrevious = new CSharpSymbolMatcher( previousGeneration.AnonymousTypeMap, sourceAssembly: sourceAssembly, sourceContext: context, otherAssembly: previousAssembly, otherContext: previousContext, otherSynthesizedMembersOpt: previousGeneration.SynthesizedMembers); } _previousDefinitions = new CSharpDefinitionMap(previousGeneration.OriginalMetadata.Module, edits, metadataDecoder, matchToMetadata, matchToPrevious); _previousGeneration = previousGeneration; _changes = new SymbolChanges(_previousDefinitions, edits, isAddedSymbol); // Workaround for https://github.com/dotnet/roslyn/issues/3192. // When compiling state machine we stash types of awaiters and state-machine hoisted variables, // so that next generation can look variables up and reuse their slots if possible. // // When we are about to allocate a slot for a lifted variable while compiling the next generation // we map its type to the previous generation and then check the slot types that we stashed earlier. // If the variable type matches we reuse it. In order to compare the previous variable type with the current one // both need to be completely lowered (translated). Standard translation only goes one level deep. // Generic arguments are not translated until they are needed by metadata writer. // // In order to get the fully lowered form we run the type symbols of stashed variables thru a deep translator // that translates the symbol recursively. _deepTranslator = new CSharpSymbolMatcher.DeepTranslator(sourceAssembly.GetSpecialType(SpecialType.System_Object)); }
public static MetadataWriter Create( EmitContext context, CommonMessageProvider messageProvider, bool allowMissingMethodBodies, bool deterministic, CancellationToken cancellationToken) { var heaps = new MetadataHeapsBuilder(); return(new FullMetadataWriter(context, heaps, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken)); }
Cci.PrimitiveTypeCode Cci.ITypeReference.TypeCode(EmitContext context) { Debug.Assert(this.IsDefinitionOrDistinct()); if (this.IsDefinition) { return this.PrimitiveTypeCode; } return Cci.PrimitiveTypeCode.NotPrimitive; }
internal static void GetConsolidatedTypeArguments(this ITypeReference typeReference, ArrayBuilder<ITypeReference> consolidatedTypeArguments, EmitContext context) { INestedTypeReference nestedTypeReference = typeReference.AsNestedTypeReference; nestedTypeReference?.GetContainingType(context).GetConsolidatedTypeArguments(consolidatedTypeArguments, context); IGenericTypeInstanceReference genTypeInstance = typeReference.AsGenericTypeInstanceReference; if (genTypeInstance != null) { consolidatedTypeArguments.AddRange(genTypeInstance.GetGenericArguments(context)); } }
ImmutableArray<Cci.ITypeReference> Cci.IGenericTypeInstanceReference.GetGenericArguments(EmitContext context) { PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module; var builder = ArrayBuilder<Cci.ITypeReference>.GetInstance(); foreach (TypeSymbol type in UnderlyingNamedType.TypeArgumentsNoUseSiteDiagnostics) { builder.Add(moduleBeingBuilt.Translate(type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics)); } return builder.ToImmutableAndFree(); }
private static void VisitTypeReference(Cci.ITypeReference typeReference, EmitContext context) { Debug.Assert(typeReference != null); Cci.IArrayTypeReference arrayType = typeReference as Cci.IArrayTypeReference; if (arrayType != null) { VisitTypeReference(arrayType.GetElementType(context), context); return; } Cci.IPointerTypeReference pointerType = typeReference as Cci.IPointerTypeReference; if (pointerType != null) { VisitTypeReference(pointerType.GetTargetType(context), context); return; } Debug.Assert(!(typeReference is Cci.IManagedPointerTypeReference)); //Cci.IManagedPointerTypeReference managedPointerType = typeReference as Cci.IManagedPointerTypeReference; //if (managedPointerType != null) //{ // VisitTypeReference(managedPointerType.GetTargetType(this.context)); // return; //} Cci.IModifiedTypeReference modifiedType = typeReference as Cci.IModifiedTypeReference; if (modifiedType != null) { foreach (var custModifier in modifiedType.CustomModifiers) { VisitTypeReference(custModifier.GetModifier(context), context); } VisitTypeReference(modifiedType.UnmodifiedType, context); return; } // Visit containing type Cci.INestedTypeReference nestedType = typeReference.AsNestedTypeReference; if (nestedType != null) { VisitTypeReference(nestedType.GetContainingType(context), context); } // Visit generic arguments Cci.IGenericTypeInstanceReference genericInstance = typeReference.AsGenericTypeInstanceReference; if (genericInstance != null) { foreach (var arg in genericInstance.GetGenericArguments(context)) { VisitTypeReference(arg, context); } } }
Cci.ITypeReference Cci.ITypeMemberReference.GetContainingType(EmitContext context) { PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module; Debug.Assert(this.IsDefinitionOrDistinct()); if (!this.IsDefinition) { return moduleBeingBuilt.Translate(this.ContainingType, context.SyntaxNodeOpt, context.Diagnostics); } return (Cci.ITypeReference)this.ContainingType; }
Cci.ITypeReference Cci.IPointerTypeReference.GetTargetType(EmitContext context) { var type = ((PEModuleBuilder)context.Module).Translate(this.PointedAtType, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics); if (this.CustomModifiers.Length == 0) { return type; } else { return new Cci.ModifiedTypeReference(type, this.CustomModifiers.As<Cci.ICustomModifier>()); } }
Cci.ITypeReference Cci.IFieldReference.GetType(EmitContext context) { var customModifiers = underlyingField.CustomModifiers; var type = ((PEModuleBuilder)context.Module).Translate(underlyingField.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics); if (customModifiers.Length == 0) { return type; } else { return new Cci.ModifiedTypeReference(type, customModifiers); } }
/// <summary> /// Zero or more named arguments that specify values for fields and properties of the attribute. /// </summary> public ImmutableArray<Cci.IMetadataNamedArgument> GetNamedArguments(EmitContext context) { // Perform fixup Cci.ITypeReference stringType = context.Module.GetPlatformType(Cci.PlatformType.SystemString, context); #if DEBUG // Must have exactly 1 named argument. var namedArgs = this.sourceAttribute.GetNamedArguments(context); Debug.Assert(namedArgs.Count() == 1); // Named argument must be 'File' property of string type var fileArg = namedArgs.First(); Debug.Assert(fileArg.ArgumentName == FilePropertyName); Debug.Assert(context.Module.IsPlatformType(fileArg.Type, Cci.PlatformType.SystemString)); // Named argument value must be a non-empty string Debug.Assert(fileArg.ArgumentValue is Cci.IMetadataConstant); var fileName = (string)((Cci.IMetadataConstant)fileArg.ArgumentValue).Value; Debug.Assert(!String.IsNullOrEmpty(fileName)); // PermissionSetAttribute type must have a writable public string type property member 'Hex' Debug.Assert(((INamedTypeSymbol)this.sourceAttribute.GetType(context)).GetMembers(HexPropertyName).Any( member => member.Kind == SymbolKind.Property && ((IPropertySymbol)member).Type.SpecialType == SpecialType.System_String)); #endif string hexFileContent; // Read the file contents at the resolved file path into a byte array. // May throw PermissionSetFileReadException, which is handled in Compilation.Emit. var resolver = context.ModuleBuilder.CommonCompilation.Options.XmlReferenceResolver; // If the resolver isn't available we won't get here since we had to use it to resolve the path. Debug.Assert(resolver != null); try { using (Stream stream = resolver.OpenReadChecked(resolvedPermissionSetFilePath)) { // Convert the byte array contents into a string in hexa-decimal format. hexFileContent = ConvertToHex(stream); } } catch (IOException e) { throw new PermissionSetFileReadException(e.Message, resolvedPermissionSetFilePath); } // Synthesize a named attribute argument "Hex = hexFileContent". return ImmutableArray.Create<Cci.IMetadataNamedArgument>(new HexPropertyMetadataNamedArgument(stringType, new MetadataConstant(stringType, hexFileContent))); }
public static MetadataWriter Create( EmitContext context, CommonMessageProvider messageProvider, bool allowMissingMethodBodies, bool deterministic, bool hasPdbStream, CancellationToken cancellationToken) { var heaps = new MetadataHeapsBuilder(); // Portable PDBs not supported yet: MetadataHeapsBuilder debugHeapsOpt = null; return(new FullMetadataWriter(context, heaps, debugHeapsOpt, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken)); }
ImmutableArray<Cci.IMetadataNamedArgument> Cci.ICustomAttribute.GetNamedArguments(EmitContext context) { var commonArgs = this.CommonNamedArguments; if (commonArgs.IsEmpty) { return ImmutableArray<Cci.IMetadataNamedArgument>.Empty; } var builder = ArrayBuilder<Cci.IMetadataNamedArgument>.GetInstance(); foreach (var namedArgument in commonArgs) { builder.Add(CreateMetadataNamedArgument(namedArgument.Key, namedArgument.Value, context)); } return builder.ToImmutableAndFree(); }
Cci.ITypeReference Cci.IArrayTypeReference.GetElementType(EmitContext context) { PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module; var type = moduleBeingBuilt.Translate(this.ElementType, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics); if (this.CustomModifiers.Length == 0) { return type; } else { return new Cci.ModifiedTypeReference(type, this.CustomModifiers.As<Cci.ICustomModifier>()); } }
ImmutableArray<Cci.IMetadataExpression> Cci.ICustomAttribute.GetArguments(EmitContext context) { var commonArgs = this.CommonConstructorArguments; if (commonArgs.IsEmpty) { return ImmutableArray<Cci.IMetadataExpression>.Empty; } var builder = ArrayBuilder<Cci.IMetadataExpression>.GetInstance(); foreach (var argument in commonArgs) { Debug.Assert(argument.Kind != TypedConstantKind.Error); builder.Add(CreateMetadataExpression(argument, context)); } return builder.ToImmutableAndFree(); }
internal static ITypeReference GetUninstantiatedGenericType(this ITypeReference typeReference, EmitContext context) { IGenericTypeInstanceReference genericTypeInstanceReference = typeReference.AsGenericTypeInstanceReference; if (genericTypeInstanceReference != null) { return genericTypeInstanceReference.GetGenericType(context); } ISpecializedNestedTypeReference specializedNestedType = typeReference.AsSpecializedNestedTypeReference; if (specializedNestedType != null) { return specializedNestedType.GetUnspecializedVersion(context); } return typeReference; }
/// <summary> /// When emitting ref assemblies, some members will not be included. /// </summary> public static bool ShouldInclude(this ITypeDefinitionMember member, EmitContext context) { if (context.IncludePrivateMembers) { return(true); } var method = member as IMethodDefinition; if (method != null && method.IsVirtual) { return(true); } bool acceptBasedOnVisibility = true; switch (member.Visibility) { case TypeMemberVisibility.Private: acceptBasedOnVisibility = context.IncludePrivateMembers; break; case TypeMemberVisibility.Assembly: case TypeMemberVisibility.FamilyAndAssembly: acceptBasedOnVisibility = context.IncludePrivateMembers || context.Module.SourceAssemblyOpt?.InternalsAreVisible == true; break; } if (acceptBasedOnVisibility) { return(true); } if (method?.IsStatic == true) { foreach (var methodImplementation in method.ContainingTypeDefinition.GetExplicitImplementationOverrides(context)) { if (methodImplementation.ImplementingMethod == method) { return(true); } } } return(false); }
Cci.ITypeReference Cci.IFieldReference.GetType(EmitContext context) { PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module; var customModifiers = this.CustomModifiers; var isFixed = this.IsFixed; var implType = isFixed ? this.FixedImplementationType(moduleBeingBuilt) : this.Type; var type = moduleBeingBuilt.Translate(implType, context.SyntaxNodeOpt, context.Diagnostics); if (isFixed || customModifiers.Length == 0) { return type; } else { return new Cci.ModifiedTypeReference(type, customModifiers.As<Cci.ICustomModifier>()); } }
private Cci.IMetadataExpression CreateMetadataExpression(TypedConstant argument, EmitContext context) { if (argument.IsNull) { return CreateMetadataConstant(argument.Type, null, context); } switch (argument.Kind) { case TypedConstantKind.Array: return CreateMetadataArray(argument, context); case TypedConstantKind.Type: return CreateType(argument, context); default: return CreateMetadataConstant(argument.Type, argument.Value, context); } }
Cci.ITypeReference Cci.ITypeMemberReference.GetContainingType(EmitContext context) { Debug.Assert(this.IsDefinitionOrDistinct()); var synthesizedGlobalMethod = this as SynthesizedGlobalMethodSymbol; if ((object)synthesizedGlobalMethod != null) { return synthesizedGlobalMethod.ContainingPrivateImplementationDetailsType; } if (!this.IsDefinition) { PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module; return moduleBeingBuilt.Translate(this.ContainingType, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics); } return this.ContainingType; }
private FullMetadataWriter( EmitContext context, MetadataBuilder builder, MetadataBuilder debugBuilderOpt, DynamicAnalysisDataWriter dynamicAnalysisDataWriterOpt, CommonMessageProvider messageProvider, bool metadataOnly, bool deterministic, bool emitTestCoverageData, CancellationToken cancellationToken) : base(builder, debugBuilderOpt, dynamicAnalysisDataWriterOpt, context, messageProvider, metadataOnly, deterministic, emitTestCoverageData, cancellationToken) { // EDMAURER make some intelligent guesses for the initial sizes of these things. int numMethods = this.module.HintNumberOfMethodDefinitions; int numTypeDefsGuess = numMethods / 6; int numFieldDefsGuess = numTypeDefsGuess * 4; int numPropertyDefsGuess = numMethods / 4; _typeDefs = new DefinitionIndex <ITypeDefinition>(numTypeDefsGuess); _eventDefs = new DefinitionIndex <IEventDefinition>(0); _fieldDefs = new DefinitionIndex <IFieldDefinition>(numFieldDefsGuess); _methodDefs = new DefinitionIndex <IMethodDefinition>(numMethods); _propertyDefs = new DefinitionIndex <IPropertyDefinition>(numPropertyDefsGuess); _parameterDefs = new DefinitionIndex <IParameterDefinition>(numMethods); _genericParameters = new DefinitionIndex <IGenericParameter>(0); _fieldDefIndex = new Dictionary <ITypeDefinition, int>(numTypeDefsGuess); _methodDefIndex = new Dictionary <ITypeDefinition, int>(numTypeDefsGuess); _parameterListIndex = new Dictionary <IMethodDefinition, int>(numMethods); _assemblyRefIndex = new HeapOrReferenceIndex <AssemblyIdentity>(this); _moduleRefIndex = new HeapOrReferenceIndex <string>(this); _memberRefIndex = new InstanceAndStructuralReferenceIndex <ITypeMemberReference>(this, new MemberRefComparer(this)); _methodSpecIndex = new InstanceAndStructuralReferenceIndex <IGenericMethodInstanceReference>(this, new MethodSpecComparer(this)); _typeRefIndex = new HeapOrReferenceIndex <ITypeReference>(this); _typeSpecIndex = new InstanceAndStructuralReferenceIndex <ITypeReference>(this, new TypeSpecComparer(this)); _standAloneSignatureIndex = new HeapOrReferenceIndex <BlobHandle>(this); }
IEnumerable<Cci.IFileReference> Cci.IAssembly.GetFiles(EmitContext context) { if (_lazyFiles.IsDefault) { var builder = ArrayBuilder<Cci.IFileReference>.GetInstance(); try { var modules = _sourceAssembly.Modules; for (int i = 1; i < modules.Length; i++) { builder.Add((Cci.IFileReference)Translate(modules[i], context.Diagnostics)); } foreach (ResourceDescription resource in ManifestResources) { if (!resource.IsEmbedded) { builder.Add(resource); } } // Dev12 compilers don't report ERR_CryptoHashFailed if there are no files to be hashed. if (ImmutableInterlocked.InterlockedInitialize(ref _lazyFiles, builder.ToImmutable()) && _lazyFiles.Length > 0) { if (!CryptographicHashProvider.IsSupportedAlgorithm(_sourceAssembly.AssemblyHashAlgorithm)) { context.Diagnostics.Add(new CSDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_CryptoHashFailed), NoLocation.Singleton)); } } } finally { builder.Free(); } } return _lazyFiles; }
public static void VisitReference(Cci.IReference reference, EmitContext context) { var typeReference = reference as Cci.ITypeReference; if (typeReference != null) { VisitTypeReference(typeReference, context); return; } var methodReference = reference as Cci.IMethodReference; if (methodReference != null) { VisitMethodReference(methodReference, context); return; } var fieldReference = reference as Cci.IFieldReference; if (fieldReference != null) { VisitFieldReference(fieldReference, context); return; } }
/// <summary> /// Returns true if the namespace scope for this method should be forwarded to another method. /// Returns non-null <paramref name="forwardToMethod"/> if the forwarding should be done directly via UsingNamespace, /// null if the forwarding is done via custom debug info. /// </summary> public bool ShouldForwardNamespaceScopes(EmitContext context, IMethodBody methodBody, uint methodToken, out IMethodDefinition forwardToMethod) { if (ShouldForwardToPreviousMethodWithUsingInfo(context, methodBody) || methodBody.ImportScope == null) { // SerializeNamespaceScopeMetadata will do the actual forwarding in case this is a CSharp method. // VB on the other hand adds a "@methodtoken" to the scopes instead. if (context.Module.GenerateVisualBasicStylePdb) { forwardToMethod = _previousMethodBodyWithUsingInfo.MethodDefinition; } else { forwardToMethod = null; } return true; } _previousMethodBodyWithUsingInfo = methodBody; _previousMethodTokenWithUsingInfo = methodToken; forwardToMethod = null; return false; }
/// <summary> /// A list of the files that constitute the assembly. Empty for netmodule. These are not the source language files that may have been /// used to compile the assembly, but the files that contain constituent modules of a multi-module assembly as well /// as any external resources. It corresponds to the File table of the .NET assembly file format. /// </summary> public abstract IEnumerable <Cci.IFileReference> GetFiles(EmitContext context);
IEnumerable <Cci.ICustomAttribute> Cci.IReference.GetAttributes(EmitContext context) => SpecializedCollections.EmptyEnumerable <Cci.ICustomAttribute>();
/// <summary> /// Anonymous types defined in the compilation. /// </summary> public abstract IEnumerable <Cci.INamespaceTypeDefinition> GetAnonymousTypeDefinitions(EmitContext context);
/// <summary> /// Top-level embedded types (e.g. attribute types that are not present in referenced assemblies). /// </summary> public abstract IEnumerable <Cci.INamespaceTypeDefinition> GetEmbeddedTypeDefinitions(EmitContext context);
internal TypeReferenceIndexer(EmitContext context) : base(context) { }
public override IEnumerable <Cci.INamespaceTypeDefinition> GetEmbeddedTypeDefinitions(EmitContext context) => GetEmbeddedTypes(context.Diagnostics);
public static bool WritePeToStream( EmitContext context, CommonMessageProvider messageProvider, Func <Stream> getPeStream, Func <Stream> getPortablePdbStreamOpt, PdbWriter nativePdbWriterOpt, string pdbPathOpt, bool allowMissingMethodBodies, bool isDeterministic, CancellationToken cancellationToken) { // If PDB writer is given, we have to have PDB path. Debug.Assert(nativePdbWriterOpt == null || pdbPathOpt != null); var mdWriter = FullMetadataWriter.Create(context, messageProvider, allowMissingMethodBodies, isDeterministic, getPortablePdbStreamOpt != null, cancellationToken); var properties = context.Module.SerializationProperties; nativePdbWriterOpt?.SetMetadataEmitter(mdWriter); // Since we are producing a full assembly, we should not have a module version ID // imposed ahead-of time. Instead we will compute a deterministic module version ID // based on the contents of the generated stream. Debug.Assert(properties.PersistentIdentifier == default(Guid)); var ilBuilder = new BlobBuilder(32 * 1024); var mappedFieldDataBuilder = new BlobBuilder(); var managedResourceBuilder = new BlobBuilder(1024); Blob mvidFixup, mvidStringFixup; mdWriter.BuildMetadataAndIL( nativePdbWriterOpt, ilBuilder, mappedFieldDataBuilder, managedResourceBuilder, out mvidFixup, out mvidStringFixup); MethodDefinitionHandle entryPointHandle; MethodDefinitionHandle debugEntryPointHandle; mdWriter.GetEntryPoints(out entryPointHandle, out debugEntryPointHandle); if (!debugEntryPointHandle.IsNil) { nativePdbWriterOpt?.SetEntryPoint((uint)MetadataTokens.GetToken(debugEntryPointHandle)); } if (nativePdbWriterOpt != null) { if (context.Module.SourceLinkStreamOpt != null) { nativePdbWriterOpt.EmbedSourceLink(context.Module.SourceLinkStreamOpt); } if (mdWriter.Module.OutputKind == OutputKind.WindowsRuntimeMetadata) { // Dev12: If compiling to winmdobj, we need to add to PDB source spans of // all types and members for better error reporting by WinMDExp. nativePdbWriterOpt.WriteDefinitionLocations(mdWriter.Module.GetSymbolToLocationMap()); } else { #if DEBUG // validate that all definitions are writable // if same scenario would happen in an winmdobj project nativePdbWriterOpt.AssertAllDefinitionsHaveTokens(mdWriter.Module.GetSymbolToLocationMap()); #endif } // embedded text not currently supported for native PDB and we should have validated that Debug.Assert(!mdWriter.Module.DebugDocumentsBuilder.EmbeddedDocuments.Any()); } Stream peStream = getPeStream(); if (peStream == null) { return(false); } BlobContentId pdbContentId = nativePdbWriterOpt?.GetContentId() ?? default(BlobContentId); // the writer shall not be used after this point for writing: nativePdbWriterOpt = null; ushort portablePdbVersion = 0; var metadataRootBuilder = mdWriter.GetRootBuilder(); var peHeaderBuilder = new PEHeaderBuilder( machine: properties.Machine, sectionAlignment: properties.SectionAlignment, fileAlignment: properties.FileAlignment, imageBase: properties.BaseAddress, majorLinkerVersion: properties.LinkerMajorVersion, minorLinkerVersion: properties.LinkerMinorVersion, majorOperatingSystemVersion: 4, minorOperatingSystemVersion: 0, majorImageVersion: 0, minorImageVersion: 0, majorSubsystemVersion: properties.MajorSubsystemVersion, minorSubsystemVersion: properties.MinorSubsystemVersion, subsystem: properties.Subsystem, dllCharacteristics: properties.DllCharacteristics, imageCharacteristics: properties.ImageCharacteristics, sizeOfStackReserve: properties.SizeOfStackReserve, sizeOfStackCommit: properties.SizeOfStackCommit, sizeOfHeapReserve: properties.SizeOfHeapReserve, sizeOfHeapCommit: properties.SizeOfHeapCommit); var deterministicIdProvider = isDeterministic ? new Func <IEnumerable <Blob>, BlobContentId>(content => BlobContentId.FromHash(CryptographicHashProvider.ComputeSha1(content))) : null; BlobBuilder portablePdbToEmbed = null; if (mdWriter.EmitStandaloneDebugMetadata) { mdWriter.AddRemainingEmbeddedDocuments(mdWriter.Module.DebugDocumentsBuilder.EmbeddedDocuments); var portablePdbBlob = new BlobBuilder(); var portablePdbBuilder = mdWriter.GetPortablePdbBuilder(metadataRootBuilder.Sizes.RowCounts, debugEntryPointHandle, deterministicIdProvider); pdbContentId = portablePdbBuilder.Serialize(portablePdbBlob); portablePdbVersion = portablePdbBuilder.FormatVersion; if (getPortablePdbStreamOpt == null) { // embed to debug directory: portablePdbToEmbed = portablePdbBlob; } else { // write to Portable PDB stream: Stream portablePdbStream = getPortablePdbStreamOpt(); if (portablePdbStream != null) { portablePdbBlob.WriteContentTo(portablePdbStream); } } } DebugDirectoryBuilder debugDirectoryBuilder; if (pdbPathOpt != null || isDeterministic || portablePdbToEmbed != null) { debugDirectoryBuilder = new DebugDirectoryBuilder(); if (pdbPathOpt != null) { string paddedPath = isDeterministic ? pdbPathOpt : PadPdbPath(pdbPathOpt); debugDirectoryBuilder.AddCodeViewEntry(paddedPath, pdbContentId, portablePdbVersion); } if (isDeterministic) { debugDirectoryBuilder.AddReproducibleEntry(); } if (portablePdbToEmbed != null) { debugDirectoryBuilder.AddEmbeddedPortablePdbEntry(portablePdbToEmbed, portablePdbVersion); } } else { debugDirectoryBuilder = null; } var peBuilder = new ManagedPEBuilder( peHeaderBuilder, metadataRootBuilder, ilBuilder, mappedFieldDataBuilder, managedResourceBuilder, CreateNativeResourceSectionSerializer(context.Module), debugDirectoryBuilder, CalculateStrongNameSignatureSize(context.Module), entryPointHandle, properties.CorFlags, deterministicIdProvider); var peBlob = new BlobBuilder(); var peContentId = peBuilder.Serialize(peBlob); PatchModuleVersionIds(mvidFixup, mvidStringFixup, peContentId.Guid); try { peBlob.WriteContentTo(peStream); } catch (Exception e) when(!(e is OperationCanceledException)) { throw new PeWritingException(e); } return(true); }
internal ReferenceIndexerBase(EmitContext context) : base(context) { }
internal NoPiaReferenceIndexer(EmitContext context) : base(context) { }
/// <summary> /// Returns all top-level (not nested) types defined in the module. /// </summary> public override IEnumerable <Cci.INamespaceTypeDefinition> GetTopLevelTypeDefinitions(EmitContext context) { Cci.TypeReferenceIndexer typeReferenceIndexer = null; HashSet <string> names; // First time through, we need to collect emitted names of all top level types. if (_namesOfTopLevelTypes == null) { names = new HashSet <string>(); } else { names = null; } // First time through, we need to push things through TypeReferenceIndexer // to make sure we collect all to be embedded NoPia types and members. if (EmbeddedTypesManagerOpt != null && !EmbeddedTypesManagerOpt.IsFrozen) { typeReferenceIndexer = new Cci.TypeReferenceIndexer(context); Debug.Assert(names != null); // Run this reference indexer on the assembly- and module-level attributes first. // We'll run it on all other types below. // The purpose is to trigger Translate on all types. Dispatch(typeReferenceIndexer); } AddTopLevelType(names, RootModuleType); VisitTopLevelType(typeReferenceIndexer, RootModuleType); yield return(RootModuleType); foreach (var typeDef in GetAnonymousTypeDefinitions(context)) { AddTopLevelType(names, typeDef); VisitTopLevelType(typeReferenceIndexer, typeDef); yield return(typeDef); } foreach (var typeDef in GetTopLevelTypeDefinitionsCore(context)) { AddTopLevelType(names, typeDef); VisitTopLevelType(typeReferenceIndexer, typeDef); yield return(typeDef); } var privateImpl = PrivateImplClass; if (privateImpl != null) { AddTopLevelType(names, privateImpl); VisitTopLevelType(typeReferenceIndexer, privateImpl); yield return(privateImpl); } if (EmbeddedTypesManagerOpt != null) { foreach (var embedded in EmbeddedTypesManagerOpt.GetTypes(context.Diagnostics, names)) { AddTopLevelType(names, embedded); yield return(embedded); } } if (names != null) { Debug.Assert(_namesOfTopLevelTypes == null); _namesOfTopLevelTypes = names; } }
/// <summary> /// Top-level named types defined in source. /// </summary> public abstract IEnumerable <Cci.INamespaceTypeDefinition> GetTopLevelSourceTypeDefinitions(EmitContext context);
public Cci.IAssemblyReference GetContainingAssembly(EmitContext context) { return(OutputKind == OutputKind.NetModule ? null : (Cci.IAssemblyReference) this); }
/// <summary> /// Assembly reference aliases (C# only). /// </summary> public ImmutableArray <Cci.AssemblyReferenceAlias> GetAssemblyReferenceAliases(EmitContext context) { if (_lazyAssemblyReferenceAliases.IsDefault) { ImmutableInterlocked.InterlockedCompareExchange(ref _lazyAssemblyReferenceAliases, CalculateAssemblyReferenceAliases(context), default(ImmutableArray <Cci.AssemblyReferenceAlias>)); } return(_lazyAssemblyReferenceAliases); }
public void BaseInterfacesInMetadata() { var text = @" interface I1 { } interface I2 : I1 { } class C : I2 { } "; var comp = CreateCompilationWithMscorlib(text); var global = comp.GlobalNamespace; var baseInterface = global.GetMember<NamedTypeSymbol>("I1"); var derivedInterface = global.GetMember<NamedTypeSymbol>("I2"); var @class = global.GetMember<NamedTypeSymbol>("C"); var bothInterfaces = ImmutableArray.Create<NamedTypeSymbol>(baseInterface, derivedInterface); Assert.Equal(baseInterface, derivedInterface.AllInterfaces.Single()); Assert.Equal(derivedInterface, @class.Interfaces.Single()); Assert.True(@class.AllInterfaces.SetEquals(bothInterfaces, EqualityComparer<NamedTypeSymbol>.Default)); var typeDef = (Cci.ITypeDefinition)@class; var module = new PEAssemblyBuilder((SourceAssemblySymbol)@class.ContainingAssembly, EmitOptions.Default, OutputKind.DynamicallyLinkedLibrary, GetDefaultModulePropertiesForSerialization(), SpecializedCollections.EmptyEnumerable<ResourceDescription>()); var context = new EmitContext(module, null, new DiagnosticBag()); var cciInterfaces = typeDef.Interfaces(context).Cast<NamedTypeSymbol>().AsImmutable(); Assert.True(cciInterfaces.SetEquals(bothInterfaces, EqualityComparer<NamedTypeSymbol>.Default)); context.Diagnostics.Verify(); }
Cci.IDefinition Cci.IReference.AsDefinition(EmitContext context) { Debug.Assert(ReferenceEquals(context.Module, this)); return(this); }
private ImmutableArray <Cci.AssemblyReferenceAlias> CalculateAssemblyReferenceAliases(EmitContext context) { var result = ArrayBuilder <Cci.AssemblyReferenceAlias> .GetInstance(); foreach (var assemblyAndAliases in CommonCompilation.GetBoundReferenceManager().GetReferencedAssemblyAliases()) { var assembly = assemblyAndAliases.Item1; var aliases = assemblyAndAliases.Item2; for (int i = 0; i < aliases.Length; i++) { string alias = aliases[i]; // filter out duplicates and global aliases: if (alias != MetadataReferenceProperties.GlobalAlias && aliases.IndexOf(alias, 0, i) < 0) { result.Add(new Cci.AssemblyReferenceAlias(alias, Translate(assembly, context.Diagnostics))); } } } return(result.ToImmutableAndFree()); }
/// <summary> /// CorLibrary assembly referenced by this module. /// </summary> public Cci.IAssemblyReference GetCorLibrary(EmitContext context) { return(Translate(CommonCorLibrary, context.Diagnostics)); }
public override IEnumerable <Cci.INamespaceTypeDefinition> GetAdditionalTopLevelTypeDefinitions(EmitContext context) => GetAdditionalTopLevelTypes(context.Diagnostics);
internal static bool WritePeToStream( EmitContext context, CommonMessageProvider messageProvider, Func <Stream> getPeStream, Func <Stream> getPortablePdbStreamOpt, PdbWriter nativePdbWriterOpt, string pdbPathOpt, bool metadataOnly, bool isDeterministic, bool emitTestCoverageData, RSAParameters?privateKeyOpt, CancellationToken cancellationToken) { // If PDB writer is given, we have to have PDB path. Debug.Assert(nativePdbWriterOpt == null || pdbPathOpt != null); var mdWriter = FullMetadataWriter.Create(context, messageProvider, metadataOnly, isDeterministic, emitTestCoverageData, getPortablePdbStreamOpt != null, cancellationToken); var properties = context.Module.SerializationProperties; nativePdbWriterOpt?.SetMetadataEmitter(mdWriter); // Since we are producing a full assembly, we should not have a module version ID // imposed ahead-of time. Instead we will compute a deterministic module version ID // based on the contents of the generated stream. Debug.Assert(properties.PersistentIdentifier == default(Guid)); var ilBuilder = new BlobBuilder(32 * 1024); var mappedFieldDataBuilder = new BlobBuilder(); var managedResourceBuilder = new BlobBuilder(1024); Blob mvidFixup, mvidStringFixup; mdWriter.BuildMetadataAndIL( nativePdbWriterOpt, ilBuilder, mappedFieldDataBuilder, managedResourceBuilder, out mvidFixup, out mvidStringFixup); MethodDefinitionHandle entryPointHandle; MethodDefinitionHandle debugEntryPointHandle; mdWriter.GetEntryPoints(out entryPointHandle, out debugEntryPointHandle); if (!debugEntryPointHandle.IsNil) { nativePdbWriterOpt?.SetEntryPoint(MetadataTokens.GetToken(debugEntryPointHandle)); } if (nativePdbWriterOpt != null) { if (context.Module.SourceLinkStreamOpt != null) { nativePdbWriterOpt.EmbedSourceLink(context.Module.SourceLinkStreamOpt); } if (mdWriter.Module.OutputKind == OutputKind.WindowsRuntimeMetadata) { // Dev12: If compiling to winmdobj, we need to add to PDB source spans of // all types and members for better error reporting by WinMDExp. nativePdbWriterOpt.WriteDefinitionLocations(mdWriter.Module.GetSymbolToLocationMap()); } else { #if DEBUG // validate that all definitions are writable // if same scenario would happen in an winmdobj project nativePdbWriterOpt.AssertAllDefinitionsHaveTokens(mdWriter.Module.GetSymbolToLocationMap()); #endif } nativePdbWriterOpt.WriteRemainingEmbeddedDocuments(mdWriter.Module.DebugDocumentsBuilder.EmbeddedDocuments); } Stream peStream = getPeStream(); if (peStream == null) { return(false); } BlobContentId pdbContentId = nativePdbWriterOpt?.GetContentId() ?? default; // the writer shall not be used after this point for writing: nativePdbWriterOpt = null; ushort portablePdbVersion = 0; var metadataRootBuilder = mdWriter.GetRootBuilder(); var peHeaderBuilder = new PEHeaderBuilder( machine: properties.Machine, sectionAlignment: properties.SectionAlignment, fileAlignment: properties.FileAlignment, imageBase: properties.BaseAddress, majorLinkerVersion: properties.LinkerMajorVersion, minorLinkerVersion: properties.LinkerMinorVersion, majorOperatingSystemVersion: 4, minorOperatingSystemVersion: 0, majorImageVersion: 0, minorImageVersion: 0, majorSubsystemVersion: properties.MajorSubsystemVersion, minorSubsystemVersion: properties.MinorSubsystemVersion, subsystem: properties.Subsystem, dllCharacteristics: properties.DllCharacteristics, imageCharacteristics: properties.ImageCharacteristics, sizeOfStackReserve: properties.SizeOfStackReserve, sizeOfStackCommit: properties.SizeOfStackCommit, sizeOfHeapReserve: properties.SizeOfHeapReserve, sizeOfHeapCommit: properties.SizeOfHeapCommit); // TODO: replace SHA1 with non-crypto alg: https://github.com/dotnet/roslyn/issues/24737 var peIdProvider = isDeterministic ? new Func <IEnumerable <Blob>, BlobContentId>(content => BlobContentId.FromHash(CryptographicHashProvider.ComputeHash(HashAlgorithmName.SHA1, content))) : null; // We need to calculate the PDB checksum, so we may as well use the calculated hash for PDB ID regardless of whether deterministic build is requested. var portablePdbContentHash = default(ImmutableArray <byte>); BlobBuilder portablePdbToEmbed = null; if (mdWriter.EmitPortableDebugMetadata) { mdWriter.AddRemainingEmbeddedDocuments(mdWriter.Module.DebugDocumentsBuilder.EmbeddedDocuments); // The algorithm must be specified for deterministic builds (checked earlier). Debug.Assert(!isDeterministic || context.Module.PdbChecksumAlgorithm.Name != null); var portablePdbIdProvider = (context.Module.PdbChecksumAlgorithm.Name != null) ? new Func <IEnumerable <Blob>, BlobContentId>(content => BlobContentId.FromHash(portablePdbContentHash = CryptographicHashProvider.ComputeHash(context.Module.PdbChecksumAlgorithm, content))) : null; var portablePdbBlob = new BlobBuilder(); var portablePdbBuilder = mdWriter.GetPortablePdbBuilder(metadataRootBuilder.Sizes.RowCounts, debugEntryPointHandle, portablePdbIdProvider); pdbContentId = portablePdbBuilder.Serialize(portablePdbBlob); portablePdbVersion = portablePdbBuilder.FormatVersion; if (getPortablePdbStreamOpt == null) { // embed to debug directory: portablePdbToEmbed = portablePdbBlob; } else { // write to Portable PDB stream: Stream portablePdbStream = getPortablePdbStreamOpt(); if (portablePdbStream != null) { try { portablePdbBlob.WriteContentTo(portablePdbStream); } catch (Exception e) when(!(e is OperationCanceledException)) { throw new SymUnmanagedWriterException(e.Message, e); } } } } DebugDirectoryBuilder debugDirectoryBuilder; if (pdbPathOpt != null || isDeterministic || portablePdbToEmbed != null) { debugDirectoryBuilder = new DebugDirectoryBuilder(); if (pdbPathOpt != null) { string paddedPath = isDeterministic ? pdbPathOpt : PadPdbPath(pdbPathOpt); debugDirectoryBuilder.AddCodeViewEntry(paddedPath, pdbContentId, portablePdbVersion); if (!portablePdbContentHash.IsDefault) { // Emit PDB Checksum entry for Portable and Embedded PDBs. The checksum is not as useful when the PDB is embedded, // however it allows the client to efficiently validate a standalone Portable PDB that // has been extracted from Embedded PDB and placed next to the PE file. debugDirectoryBuilder.AddPdbChecksumEntry(context.Module.PdbChecksumAlgorithm.Name, portablePdbContentHash); } } if (isDeterministic) { debugDirectoryBuilder.AddReproducibleEntry(); } if (portablePdbToEmbed != null) { debugDirectoryBuilder.AddEmbeddedPortablePdbEntry(portablePdbToEmbed, portablePdbVersion); } } else { debugDirectoryBuilder = null; } var strongNameProvider = context.Module.CommonCompilation.Options.StrongNameProvider; var corFlags = properties.CorFlags; var peBuilder = new ExtendedPEBuilder( peHeaderBuilder, metadataRootBuilder, ilBuilder, mappedFieldDataBuilder, managedResourceBuilder, CreateNativeResourceSectionSerializer(context.Module), debugDirectoryBuilder, CalculateStrongNameSignatureSize(context.Module, privateKeyOpt), entryPointHandle, corFlags, peIdProvider, metadataOnly && !context.IncludePrivateMembers); var peBlob = new BlobBuilder(); var peContentId = peBuilder.Serialize(peBlob, out Blob mvidSectionFixup); PatchModuleVersionIds(mvidFixup, mvidSectionFixup, mvidStringFixup, peContentId.Guid); if (privateKeyOpt != null && corFlags.HasFlag(CorFlags.StrongNameSigned)) { Debug.Assert(strongNameProvider.Capability == SigningCapability.SignsPeBuilder); strongNameProvider.SignPeBuilder(peBuilder, peBlob, privateKeyOpt.Value); } try { peBlob.WriteContentTo(peStream); } catch (Exception e) when(!(e is OperationCanceledException)) { throw new PeWritingException(e); } return(true); }
Cci.ITypeReference Cci.IParameterTypeInformation.GetType(EmitContext context) { return type; }
public abstract Cci.ITypeReference GetPlatformType(Cci.PlatformType platformType, EmitContext context);
public IEnumerable <Cci.INamespaceTypeDefinition> GetTopLevelTypeDefinitionsCore(EmitContext context) { foreach (var typeDef in GetAdditionalTopLevelTypeDefinitions(context)) { yield return(typeDef); } foreach (var typeDef in GetEmbeddedTypeDefinitions(context)) { yield return(typeDef); } foreach (var typeDef in GetTopLevelSourceTypeDefinitions(context)) { yield return(typeDef); } }
Cci.ITypeReference Cci.IParameterTypeInformation.GetType(EmitContext context) { return ((PEModuleBuilder)context.Module).Translate(UnderlyingParameter.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics); }
protected abstract Cci.IAssemblyReference GetCorLibraryReferenceToEmit(EmitContext context);