[mono] ILStrip write directly to the output filestream

src/tasks/MonoTargetsTasks/ILStrip/ILStrip.cs

@@ -305,32 +305,28 @@ private Dictionary<int, int> ComputeMethodBodyUsage(MetadataReader mr, StreamRea
     private void CreateTrimmedAssembly(PEReader peReader, string trimmedAssemblyFilePath, FileStream fs, Dictionary<int, int> methodBodyUses)
     {
         using FileStream os = File.Open(trimmedAssemblyFilePath, FileMode.Create);
-        {
-            fs.Position = 0;
-            MemoryStream memStream = new MemoryStream((int)fs.Length);
-            fs.CopyTo(memStream);
 
-            foreach (var kvp in methodBodyUses)
+        fs.Position = 0;
+        fs.CopyTo(os);
+        fs.Flush();
+
+        foreach (var kvp in methodBodyUses)
+        {
+            int rva = kvp.Key;
+            int count = kvp.Value;
+            if (count == 0)
             {
-                int rva = kvp.Key;
-                int count = kvp.Value;
-                if (count == 0)
-                {
-                    int methodSize = ComputeMethodSize(peReader, rva);
-                    int actualLoc = ComputeMethodHash(peReader, rva);
-                    int headerSize = ComputeMethodHeaderSize(memStream, actualLoc);
-                    if (headerSize == 1) //Set code size to zero for TinyFormat
-                        SetCodeSizeToZeroForTiny(ref memStream, actualLoc);
-                    ZeroOutMethodBody(ref memStream, methodSize, actualLoc, headerSize);
-                }
-                else if (count < 0)
-                {
-                    Log.LogError($"Method usage count is less than zero for rva: {rva}.");
-                }
+                int methodSize = ComputeMethodSize(peReader, rva);
+                int actualLoc = ComputeMethodHash(peReader, rva);
+                int headerSize = ComputeMethodHeaderSize(fs, actualLoc);
+                if (headerSize == 1) //Set code size to zero for TinyFormat
+                    SetCodeSizeToZeroForTiny(os, actualLoc);
+                ZeroOutMethodBody(os, methodSize, actualLoc, headerSize);
+            }
+            else if (count < 0)
+            {
+                Log.LogError($"Method usage count is less than zero for rva: {rva}.");
             }
-
-            memStream.Position = 0;
-            memStream.CopyTo(os);
         }
     }
 
@@ -343,29 +339,29 @@ private static int ComputeMethodHash(PEReader peReader, int rva)
         return (peReader.PEHeaders.SectionHeaders[sectionIndex].PointerToRawData + relativeOffset);
     }
 
-    private static int ComputeMethodHeaderSize(MemoryStream memStream, int actualLoc)
+    private static int ComputeMethodHeaderSize(Stream stream, int actualLoc)
     {
-        memStream.Position = actualLoc;
-        int firstbyte = memStream.ReadByte();
+        stream.Position = actualLoc;
+        int firstbyte = stream.ReadByte();
         int headerFlag = firstbyte & 0b11;
         return (headerFlag == 2 ? 1 : 4);
     }
 
-    private static void SetCodeSizeToZeroForTiny(ref MemoryStream memStream, int actualLoc)
+    private static void SetCodeSizeToZeroForTiny(Stream stream, int actualLoc)
     {
-        memStream.Position = actualLoc;
-        byte[] header = {0b10};
-        memStream.Write(header, 0, 1);
+        stream.Position = actualLoc;
+        stream.WriteByte(0b10);
+        stream.Flush();
     }
 
-    private static void ZeroOutMethodBody(ref MemoryStream memStream, int methodSize, int actualLoc, int headerSize)
+    private static void ZeroOutMethodBody(Stream stream, int methodSize, int actualLoc, int headerSize)
     {
-        memStream.Position = actualLoc + headerSize;
-
+        stream.Position = actualLoc + headerSize;
         byte[] zeroBuffer;
-        zeroBuffer = ArrayPool<byte>.Shared.Rent(methodSize);
+        zeroBuffer = ArrayPool<byte>.Shared.Rent(methodSize - headerSize);
         Array.Clear(zeroBuffer, 0, zeroBuffer.Length);
-        memStream.Write(zeroBuffer, 0, methodSize - headerSize);
+        stream.Write(zeroBuffer, 0, zeroBuffer.Length);
+        stream.Flush();
         ArrayPool<byte>.Shared.Return(zeroBuffer);
     }