Add .mvid section to PE and remove dependency on MetadataReader

src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj

@@ -55,6 +55,9 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'" />
   <ItemGroup>
+    <Compile Include="..\..\..\Core\MSBuildTask\MvidReader.cs">
+      <Link>Emit\MvidReader.cs</Link>
+    </Compile>
     <Compile Include="Attributes\AttributeTests.cs" />
     <Compile Include="Attributes\AttributeTests_Assembly.cs" />
     <Compile Include="Attributes\AttributeTests_CallerInfoAttributes.cs" />

src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs

@@ -262,9 +262,11 @@ internal static void Main()
 
                 VerifyEntryPoint(output, expectZero: false);
                 VerifyMethods(output, new[] { "void C.Main()", "C..ctor()" });
+                VerifyMVID(output, hasMvidSection: false);
 
                 VerifyEntryPoint(metadataOutput, expectZero: true);
                 VerifyMethods(metadataOutput, new[] { "C..ctor()" });
+                VerifyMVID(metadataOutput, hasMvidSection: true);
             }
 
             void VerifyEntryPoint(MemoryStream stream, bool expectZero)
@@ -275,6 +277,34 @@ void VerifyEntryPoint(MemoryStream stream, bool expectZero)
             }
         }
 
+        /// <summary>
+        /// Extract the MVID using two different methods (PEReader and MvidReader) and compare them. 
+        /// We only expect an .mvid section in ref assemblies.
+        /// </summary>
+        void VerifyMVID(MemoryStream stream, bool hasMvidSection)
+        {
+            Guid mvidFromModuleDefinition;
+            stream.Position = 0;
+            using (var reader = new PEReader(stream))
+            {
+                var metadataReader = reader.GetMetadataReader();
+                mvidFromModuleDefinition = metadataReader.GetGuid(metadataReader.GetModuleDefinition().Mvid);
+
+                stream.Position = 0;
+                var mvidFromMvidReader = BuildTasks.MvidReader.ReadAssemblyMvid(stream);
+
+                if (hasMvidSection)
+                {
+                    Assert.Equal(mvidFromModuleDefinition, mvidFromMvidReader);
+                }
+                else
+                {
+                    Assert.NotEqual(Guid.Empty, mvidFromModuleDefinition);
+                    Assert.Equal(Guid.Empty, mvidFromMvidReader);
+                }
+            }
+        }
+
         [Fact]
         public void EmitRefAssembly_PrivatePropertySetter()
         {
@@ -296,6 +326,8 @@ public class C
                 VerifyMethods(output, new[] { "System.Int32 C.<PrivateSetter>k__BackingField", "System.Int32 C.PrivateSetter.get", "void C.PrivateSetter.set",
                     "C..ctor()", "System.Int32 C.PrivateSetter { get; private set; }" });
                 VerifyMethods(metadataOutput, new[] { "System.Int32 C.PrivateSetter.get", "C..ctor()", "System.Int32 C.PrivateSetter { get; }" });
+                VerifyMVID(output, hasMvidSection: false);
+                VerifyMVID(metadataOutput, hasMvidSection: true);
             }
         }
 

src/Compilers/Core/MSBuildTask/CopyRefAssembly.cs

@@ -2,8 +2,6 @@
 
 using System;
 using System.IO;
-using System.Reflection.Metadata;
-using System.Reflection.PortableExecutable;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
 
@@ -85,10 +83,8 @@ private bool Copy()
         private Guid ExtractMvid(string path)
         {
             using (FileStream source = File.OpenRead(path))
-            using (var reader = new PEReader(source))
             {
-                var metadataReader = reader.GetMetadataReader();
-                return metadataReader.GetGuid(metadataReader.GetModuleDefinition().Mvid);
+                return MvidReader.ReadAssemblyMvid(source);
             }
         }
     }

src/Compilers/Core/MSBuildTask/MSBuildTask.csproj

@@ -55,6 +55,7 @@
     </Compile>
     <Compile Include="AssemblyResolution.cs" />
     <Compile Include="CanonicalError.cs" />
+    <Compile Include="MvidReader.cs" />
     <Compile Include="CopyRefAssembly.cs" />
     <Compile Include="ValidateBootstrap.cs" />
     <Compile Include="CommandLineBuilderExtension.cs" />

src/Compilers/Core/MSBuildTask/MvidReader.cs

@@ -0,0 +1,143 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace Microsoft.CodeAnalysis.BuildTasks
+{
+    public sealed class MvidReader : BinaryReader
+    {
+        public MvidReader(Stream stream) : base(stream)
+        {
+        }
+
+        public static Guid ReadAssemblyMvid(Stream stream)
+        {
+            try
+            {
+                var mvidReader = new MvidReader(stream);
+                return mvidReader.FindMvid();
+            }
+            catch (EndOfStreamException)
+            {
+            }
+
+            return Guid.Empty;
+        }
+
+        public Guid FindMvid()
+        {
+            Guid empty = Guid.Empty;
+
+            // DOS Header (64), DOS Stub (64), PE Signature (4), COFF Header (20), PE Header (224)
+            if (BaseStream.Length < 64 + 64 + 4 + 20 + 224)
+            {
+                return empty;
+            }
+
+            // DOS Header: PE (2)
+            if (ReadUInt16() != 0x5a4d)
+            {
+                return empty;
+            }
+
+            // DOS Header: Start (58)
+            Skip(58);
+
+            // DOS Header: Address of PE Signature
+            MoveTo(ReadUInt32());
+
+            // PE Signature ('P' 'E' null null)
+            if (ReadUInt32() != 0x00004550)
+            {
+                return empty;
+            }
+
+            // COFF Header: Machine (2)
+            Skip(2);
+
+            // COFF Header: NumberOfSections (2)
+            ushort sections = ReadUInt16();
+
+            // COFF Header: TimeDateStamp (4), PointerToSymbolTable (4), NumberOfSymbols (4)
+            Skip(12);
+
+            // COFF Header: OptionalHeaderSize (2)
+            ushort optionalHeaderSize = ReadUInt16();
+
+            // COFF Header: Characteristics (2)
+            Skip(2);
+
+            // Optional header
+            Skip(optionalHeaderSize);
+
+            // Section headers
+            return FindMvidInSections(sections);
+        }
+
+        string ReadSectionName()
+        {
+            int length = 8;
+            int read = 0;
+            var buffer = new char[length];
+            var bytes = ReadBytes(length);
+            while (read < length)
+            {
+                var current = bytes[read];
+                if (current == 0)
+                    break;
+
+                buffer[read++] = (char)current;
+            }
+
+            return new string(buffer, 0, read);
+        }
+
+        Guid FindMvidInSections(ushort count)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                // Section: Name (8)
+                string name = ReadSectionName();
+
+                // Section: VirtualSize (4)
+                uint virtualSize = ReadUInt32();
+
+                // Section: VirtualAddress (4), SizeOfRawData (4)
+                Skip(8);
+
+                // Section: PointerToRawData (4)
+                uint pointerToRawData = ReadUInt32();
+
+                // Section: PointerToRelocations (4), PointerToLineNumbers (4), NumberOfRelocations (2),
+                // NumberOfLineNumbers (2), Characteristics (4)
+                Skip(16);
+
+                if (name.Equals(".mvid", StringComparison.Ordinal))
+                {
+                    // The .mvid section only stores a Guid
+                    Debug.Assert(virtualSize == 16);
+
+                    BaseStream.Position = pointerToRawData;
+                    byte[] guidBytes = new byte[16];
+                    BaseStream.Read(guidBytes, 0, 16);
+
+                    return new Guid(guidBytes);
+                }
+            }
+
+            return Guid.Empty;
+        }
+
+        public void Skip(int bytes)
+        {
+            BaseStream.Seek(bytes, SeekOrigin.Current);
+        }
+
+        public void MoveTo(uint position)
+        {
+            BaseStream.Seek(position, SeekOrigin.Begin);
+        }
+    }
+}

src/Compilers/Core/MSBuildTask/project.json

@@ -15,7 +15,6 @@
     "System.IO.Pipes": "4.3.0",
     "System.Linq": "4.3.0",
     "System.Reflection": "4.3.0",
-    "System.Reflection.Metadata": "1.4.2",
     "System.Security.AccessControl": "4.3.0",
     "System.Security.Cryptography.Algorithms": "4.3.0",
     "System.Security.Principal.Windows": "4.3.0",

src/Compilers/Core/Portable/PEWriter/PeWriter.cs

@@ -69,7 +69,7 @@ internal static bool WritePeToStream(
             MethodDefinitionHandle entryPointHandle;
             MethodDefinitionHandle debugEntryPointHandle;
             mdWriter.GetEntryPoints(out entryPointHandle, out debugEntryPointHandle);
-            
+
             if (!debugEntryPointHandle.IsNil)
             {
                 nativePdbWriterOpt?.SetEntryPoint((uint)MetadataTokens.GetToken(debugEntryPointHandle));
@@ -186,7 +186,7 @@ internal static bool WritePeToStream(
                 debugDirectoryBuilder = null;
             }
 
-            var peBuilder = new ManagedPEBuilder(
+            var peBuilder = new ExtendedPEBuilder(
                 peHeaderBuilder,
                 metadataRootBuilder,
                 ilBuilder,
@@ -197,12 +197,13 @@ internal static bool WritePeToStream(
                 CalculateStrongNameSignatureSize(context.Module),
                 entryPointHandle,
                 properties.CorFlags,
-                deterministicIdProvider);
+                deterministicIdProvider,
+                metadataOnly && !context.IncludePrivateMembers);
 
             var peBlob = new BlobBuilder();
-            var peContentId = peBuilder.Serialize(peBlob);
+            var peContentId = peBuilder.Serialize(peBlob, out Blob mvidSectionFixup);
 
-            PatchModuleVersionIds(mvidFixup, mvidStringFixup, peContentId.Guid);
+            PatchModuleVersionIds(mvidFixup, mvidSectionFixup, mvidStringFixup, peContentId.Guid);
 
             try
             {
@@ -216,7 +217,7 @@ internal static bool WritePeToStream(
             return true;
         }
 
-        private static void PatchModuleVersionIds(Blob guidFixup, Blob stringFixup, Guid mvid)
+        private static void PatchModuleVersionIds(Blob guidFixup, Blob guidSectionFixup, Blob stringFixup, Guid mvid)
         {
             if (!guidFixup.IsDefault)
             {
@@ -225,6 +226,13 @@ private static void PatchModuleVersionIds(Blob guidFixup, Blob stringFixup, Guid
                 Debug.Assert(writer.RemainingBytes == 0);
             }
 
+            if (!guidSectionFixup.IsDefault)
+            {
+                var writer = new BlobWriter(guidSectionFixup);
+                writer.WriteGuid(mvid);
+                Debug.Assert(writer.RemainingBytes == 0);
+            }
+
             if (!stringFixup.IsDefault)
             {
                 var writer = new BlobWriter(stringFixup);
@@ -322,5 +330,91 @@ private static int CalculateStrongNameSignatureSize(CommonPEModuleBuilder module
 
             return (keySize < 128 + 32) ? 128 : keySize - 32;
         }
+
+        /// <summary>
+        /// This PEBuilder adds an .mvid section.
+        /// </summary>
+        private class ExtendedPEBuilder : ManagedPEBuilder
+        {
+            private const string MvidSectionName = ".mvid";
+            public const int SizeOfGuid = 16;
+
+            // When the section is built with a placeholder, the placeholder blob is saved for later fixing up.
+            private Blob _mvidSectionFixup = default(Blob);
+
+            // Only include the .mvid section in ref assemblies
+            private bool _withMvidSection;
+
+            public ExtendedPEBuilder(
+                PEHeaderBuilder header,
+                MetadataRootBuilder metadataRootBuilder,
+                BlobBuilder ilStream,
+                BlobBuilder mappedFieldData,
+                BlobBuilder managedResources,
+                ResourceSectionBuilder nativeResources,
+                DebugDirectoryBuilder debugDirectoryBuilder,
+                int strongNameSignatureSize,
+                MethodDefinitionHandle entryPoint,
+                CorFlags flags,
+                Func<IEnumerable<Blob>, BlobContentId> deterministicIdProvider,
+                bool withMvidSection)
+                : base(header, metadataRootBuilder, ilStream, mappedFieldData, managedResources, nativeResources,
+                      debugDirectoryBuilder, strongNameSignatureSize, entryPoint, flags, deterministicIdProvider)
+            {
+                _withMvidSection = withMvidSection;
+            }
+
+            protected override ImmutableArray<Section> CreateSections()
+            {
+                var baseSections = base.CreateSections();
+
+                if (_withMvidSection)
+                {
+                    var builder = ArrayBuilder<Section>.GetInstance(baseSections.Length + 1);
+
+                    builder.Add(new Section(MvidSectionName, SectionCharacteristics.MemRead |
+                        SectionCharacteristics.ContainsInitializedData |
+                        SectionCharacteristics.MemDiscardable));
+
+                    builder.AddRange(baseSections);
+                    return builder.ToImmutableAndFree();
+                }
+                else
+                {
+                    return baseSections;
+                }
+            }
+
+            protected override BlobBuilder SerializeSection(string name, SectionLocation location)
+            {
+                if (name.Equals(MvidSectionName, StringComparison.Ordinal))
+                {
+                    Debug.Assert(_withMvidSection);
+                    return SerializeMvidSection(location);
+                }
+
+                return base.SerializeSection(name, location);
+            }
+
+            internal BlobContentId Serialize(BlobBuilder peBlob, out Blob mvidSectionFixup)
+            {
+                var result = base.Serialize(peBlob);
+                mvidSectionFixup = _mvidSectionFixup;
+                return result;
+            }
+
+            private BlobBuilder SerializeMvidSection(SectionLocation location)
+            {
+                var sectionBuilder = new BlobBuilder();
+
+                // The guid will be filled in later:
+                _mvidSectionFixup = sectionBuilder.ReserveBytes(SizeOfGuid);
+                var mvidWriter = new BlobWriter(_mvidSectionFixup);
+                mvidWriter.WriteBytes(0, _mvidSectionFixup.Length);
+                Debug.Assert(mvidWriter.RemainingBytes == 0);
+
+                return sectionBuilder;
+            }
+        }
     }
 }