Replace usages of Marshal.AllocHGlobal with malloc in libraries

src/libraries/Common/src/Interop/BSD/System.Native/Interop.Sysctl.cs

@@ -33,7 +33,7 @@ internal static unsafe void Sysctl(Span<int> name, ref byte* value, ref int len)
 
         private static unsafe void Sysctl(int* name, int name_len, ref byte* value, ref int len)
         {
-            IntPtr bytesLength = (IntPtr)len;
+            IntPtr bytesLength = (nint)len;
             int ret = -1;
             bool autoSize = (value == null && len == 0);
 
@@ -45,7 +45,7 @@ private static unsafe void Sysctl(int* name, int name_len, ref byte* value, ref
                 {
                     throw new InvalidOperationException(SR.Format(SR.InvalidSysctl, *name, Marshal.GetLastWin32Error()));
                 }
-                value = (byte*)Marshal.AllocHGlobal((int)bytesLength);
+                value = (byte*)NativeMemory.Alloc((nuint)(nint)bytesLength);
             }
 
             ret = Sysctl(name, name_len, value, &bytesLength);
@@ -54,27 +54,27 @@ private static unsafe void Sysctl(int* name, int name_len, ref byte* value, ref
                 // Do not use ReAllocHGlobal() here: we don't care about
                 // previous contents, and proper checking of value returned
                 // will make code more complex.
-                Marshal.FreeHGlobal((IntPtr)value);
+                NativeMemory.Free(value);
                 if ((int)bytesLength == int.MaxValue)
                 {
                     throw new OutOfMemoryException();
                 }
                 if ((int)bytesLength >= int.MaxValue / 2)
                 {
-                    bytesLength = (IntPtr)int.MaxValue;
+                    bytesLength = (nint)int.MaxValue;
                 }
                 else
                 {
-                    bytesLength = (IntPtr)((int)bytesLength * 2);
+                    bytesLength = (nint)((int)bytesLength * 2);
                 }
-                value = (byte*)Marshal.AllocHGlobal(bytesLength);
+                value = (byte*)NativeMemory.Alloc((nuint)(nint)bytesLength);
                 ret = Sysctl(name, name_len, value, &bytesLength);
             }
             if (ret != 0)
             {
                 if (autoSize)
                 {
-                    Marshal.FreeHGlobal((IntPtr)value);
+                    NativeMemory.Alloc((nuint)value);
                 }
                 throw new InvalidOperationException(SR.Format(SR.InvalidSysctl, *name, Marshal.GetLastWin32Error()));
             }

src/libraries/Common/src/Interop/Interop.Ldap.cs

@@ -172,12 +172,12 @@ internal sealed class LdapMod
         {
             if (attribute != IntPtr.Zero)
             {
-                Marshal.FreeHGlobal(attribute);
+                NativeMemoryHelper.Free(attribute);
             }
 
             if (values != IntPtr.Zero)
             {
-                Marshal.FreeHGlobal(values);
+                NativeMemoryHelper.Free(values);
             }
         }
     }

src/libraries/Common/src/Interop/Linux/OpenLdap/Interop.Ber.cs

@@ -87,7 +87,7 @@ public static int ber_printf_int(SafeBerHandle berElement, string format, int va
         [DllImport(Libraries.OpenLdap, EntryPoint = "ber_put_boolean", CharSet = CharSet.Ansi)]
         public static extern int ber_put_boolean(SafeBerHandle berElement, int value, nuint tag);
 
-        public static int ber_printf_bytearray(SafeBerHandle berElement, string format, HGlobalMemHandle value, nuint length, nuint tag)
+        public static int ber_printf_bytearray(SafeBerHandle berElement, string format, NativeMemoryHandle value, nuint length, nuint tag)
         {
             if (format == "o")
             {
@@ -105,13 +105,13 @@ public static int ber_printf_bytearray(SafeBerHandle berElement, string format,
         }
 
         [DllImport(Libraries.OpenLdap, EntryPoint = "ber_put_ostring", CharSet = CharSet.Ansi)]
-        private static extern int ber_put_ostring(SafeBerHandle berElement, HGlobalMemHandle value, nuint length, nuint tag);
+        private static extern int ber_put_ostring(SafeBerHandle berElement, NativeMemoryHandle value, nuint length, nuint tag);
 
         [DllImport(Libraries.OpenLdap, EntryPoint = "ber_put_string", CharSet = CharSet.Ansi)]
-        private static extern int ber_put_string(SafeBerHandle berElement, HGlobalMemHandle value, nuint tag);
+        private static extern int ber_put_string(SafeBerHandle berElement, NativeMemoryHandle value, nuint tag);
 
         [DllImport(Libraries.OpenLdap, EntryPoint = "ber_put_bitstring", CharSet = CharSet.Ansi)]
-        private static extern int ber_put_bitstring(SafeBerHandle berElement, HGlobalMemHandle value, nuint length, nuint tag);
+        private static extern int ber_put_bitstring(SafeBerHandle berElement, NativeMemoryHandle value, nuint length, nuint tag);
 
         [DllImport(Libraries.OpenLdap, EntryPoint = "ber_flatten", CharSet = CharSet.Ansi)]
         public static extern int ber_flatten(SafeBerHandle berElement, ref IntPtr value);

src/libraries/Common/src/Interop/Unix/System.Native/Interop.ForkAndExecProcess.cs

@@ -53,7 +53,7 @@ private static unsafe void AllocNullTerminatedArray(string[] arr, ref byte** arr
 
             // Allocate the unmanaged array to hold each string pointer.
             // It needs to have an extra element to null terminate the array.
-            arrPtr = (byte**)Marshal.AllocHGlobal(sizeof(IntPtr) * arrLength);
+            arrPtr = (byte**)NativeMemory.Alloc((uint)(sizeof(IntPtr) * arrLength));
             Debug.Assert(arrPtr != null);
 
             // Zero the memory so that if any of the individual string allocations fails,
@@ -70,10 +70,10 @@ private static unsafe void AllocNullTerminatedArray(string[] arr, ref byte** arr
             {
                 byte[] byteArr = Encoding.UTF8.GetBytes(arr[i]);
 
-                arrPtr[i] = (byte*)Marshal.AllocHGlobal(byteArr.Length + 1); //+1 for null termination
+                arrPtr[i] = (byte*)NativeMemory.Alloc((uint)(byteArr.Length + 1u)); //+1 for null termination
                 Debug.Assert(arrPtr[i] != null);
 
-                Marshal.Copy(byteArr, 0, (IntPtr)arrPtr[i], byteArr.Length); // copy over the data from the managed byte array
+                Marshal.Copy(byteArr, 0, (nint)arrPtr[i], byteArr.Length); // copy over the data from the managed byte array
                 arrPtr[i][byteArr.Length] = (byte)'\0'; // null terminate
             }
         }
@@ -87,13 +87,13 @@ private static unsafe void FreeArray(byte** arr, int length)
                 {
                     if (arr[i] != null)
                     {
-                        Marshal.FreeHGlobal((IntPtr)arr[i]);
+                        NativeMemory.Free(arr[i]);
                         arr[i] = null;
                     }
                 }
 
                 // And then the array itself
-                Marshal.FreeHGlobal((IntPtr)arr);
+                NativeMemory.Free(arr);
             }
         }
     }

src/libraries/Common/src/Interop/Windows/Advapi32/Interop.ConvertStringSecurityDescriptorToSecurityDescriptor.cs

@@ -13,7 +13,7 @@ internal static partial class Advapi32
         internal static extern bool ConvertStringSecurityDescriptorToSecurityDescriptor(
                 string StringSecurityDescriptor,
                 int StringSDRevision,
-                out SafeLocalAllocHandle pSecurityDescriptor,
+                out SafeNativeMemoryHandle pSecurityDescriptor,
                 IntPtr SecurityDescriptorSize);
     }
 }

src/libraries/Common/src/Interop/Windows/Advapi32/Interop.GetTokenInformation.cs

@@ -13,15 +13,15 @@ internal static partial class Advapi32
         internal static extern bool GetTokenInformation(
             SafeAccessTokenHandle TokenHandle,
             uint TokenInformationClass,
-            SafeLocalAllocHandle TokenInformation,
+            SafeNativeMemoryHandle TokenInformation,
             uint TokenInformationLength,
             out uint ReturnLength);
 
         [DllImport(Interop.Libraries.Advapi32, SetLastError = true)]
         internal static extern bool GetTokenInformation(
             IntPtr TokenHandle,
             uint TokenInformationClass,
-            SafeLocalAllocHandle TokenInformation,
+            SafeNativeMemoryHandle TokenInformation,
             uint TokenInformationLength,
             out uint ReturnLength);
 

src/libraries/Common/src/Interop/Windows/Crypt32/Interop.FindOidInfo.cs

@@ -59,11 +59,11 @@ internal static CRYPT_OID_INFO FindOidInfo(CryptOidInfoKeyType keyType, string k
             {
                 if (keyType == CryptOidInfoKeyType.CRYPT_OID_INFO_OID_KEY)
                 {
-                    rawKey = Marshal.StringToCoTaskMemAnsi(key);
+                    rawKey = NativeMemoryHelper.AllocStringAnsi(key);
                 }
                 else if (keyType == CryptOidInfoKeyType.CRYPT_OID_INFO_NAME_KEY)
                 {
-                    rawKey = Marshal.StringToCoTaskMemUni(key);
+                    rawKey = NativeMemoryHelper.AllocStringUnicode(key);
                 }
                 else
                 {
@@ -105,9 +105,9 @@ internal static CRYPT_OID_INFO FindOidInfo(CryptOidInfoKeyType keyType, string k
             }
             finally
             {
-                if (rawKey != IntPtr.Zero)
+                if ((nint)rawKey != 0)
                 {
-                    Marshal.FreeCoTaskMem(rawKey);
+                    NativeMemoryHelper.Free(rawKey);
                 }
             }
         }

src/libraries/Common/src/Interop/Windows/HttpApi/Interop.HttpApi.cs

@@ -515,17 +515,17 @@ public override int Size
                 get { return _size; }
             }
 
-            public static SafeLocalFreeChannelBinding LocalAlloc(int cb)
+            public static unsafe SafeLocalFreeChannelBinding LocalAlloc(int cb)
             {
                 SafeLocalFreeChannelBinding result = new SafeLocalFreeChannelBinding();
-                result.SetHandle(Marshal.AllocHGlobal(cb));
+                result.SetHandle(NativeMemory.Alloc((uint)cb));
                 result._size = cb;
                 return result;
             }
 
-            protected override bool ReleaseHandle()
+            protected override unsafe bool ReleaseHandle()
             {
-                Marshal.FreeHGlobal(handle);
+                NativeMemory.Free((void*)(nint)handle);
                 return true;
             }
         }

src/libraries/Common/src/Microsoft/Win32/SafeHandles/SafeLocalAllocHandle.cs

@@ -6,7 +6,8 @@
 
 namespace Microsoft.Win32.SafeHandles
 {
-    internal sealed class SafeLocalAllocHandle : SafeBuffer
+    internal sealed class SafeLocalAllocHandle
+        : SafeBuffer
     {
         public SafeLocalAllocHandle() : base(true) { }
 
@@ -15,13 +16,13 @@ public SafeLocalAllocHandle() : base(true) { }
         internal static SafeLocalAllocHandle LocalAlloc(int cb)
         {
             var h = new SafeLocalAllocHandle();
-            h.SetHandle(Marshal.AllocHGlobal(cb));
+            h.SetHandle(NativeMemoryHelper.Alloc(cb));
             h.Initialize((ulong)cb);
             return h;
         }
 
         // 0 is an Invalid Handle
-        internal SafeLocalAllocHandle(IntPtr handle) : base(true)
+        private SafeLocalAllocHandle(IntPtr handle) : base(true)
         {
             SetHandle(handle);
         }
@@ -36,7 +37,7 @@ internal static SafeLocalAllocHandle InvalidHandle
 
         protected override bool ReleaseHandle()
         {
-            Marshal.FreeHGlobal(handle);
+            NativeMemoryHelper.Free(handle);
             return true;
         }
     }

src/libraries/Common/src/Microsoft/Win32/SafeHandles/SafeUnicodeStringHandle.cs

@@ -17,7 +17,7 @@ internal sealed class SafeUnicodeStringHandle : SafeHandle
         public SafeUnicodeStringHandle(string s)
             : base(IntPtr.Zero, ownsHandle: true)
         {
-            handle = Marshal.StringToHGlobalUni(s);
+            handle = NativeMemoryHelper.AllocStringUnicode(s);
         }
 
         public unsafe SafeUnicodeStringHandle(ReadOnlySpan<char> s)
@@ -32,7 +32,7 @@ public unsafe SafeUnicodeStringHandle(ReadOnlySpan<char> s)
             {
                 int cch = checked(s.Length + 1);
                 int cb = checked(cch * sizeof(char));
-                handle = Marshal.AllocHGlobal(cb);
+                handle = NativeMemoryHelper.Alloc(cb);
 
                 Span<char> dest = new Span<char>(handle.ToPointer(), cch);
                 s.CopyTo(dest);
@@ -44,13 +44,13 @@ public sealed override bool IsInvalid
         {
             get
             {
-                return handle == IntPtr.Zero;
+                return (nint)handle == 0;
             }
         }
 
         protected sealed override bool ReleaseHandle()
         {
-            Marshal.FreeHGlobal(handle);
+            NativeMemoryHelper.Free(handle);
             return true;
         }
     }

src/libraries/Common/src/System/NativeMemoryHelper.cs

@@ -0,0 +1,115 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace System
+{
+    internal static unsafe class NativeMemoryHelper
+    {
+        public static IntPtr Alloc(int byteCount)
+        {
+#if NET6_0_OR_GREATER
+            return (nint)NativeMemory.Alloc((uint)byteCount);
+#else
+            return Marshal.AllocHGlobal(byteCount);
+#endif
+        }
+
+        public static IntPtr Realloc(IntPtr pointer, int byteCount)
+        {
+#if NET6_0_OR_GREATER
+            return (nint)NativeMemory.Realloc((void*)(nint)pointer, (uint)byteCount);
+#else
+            return Marshal.ReAllocHGlobal(pointer, (nint)byteCount);
+#endif
+        }
+
+        public static IntPtr AllocStringUnicode(string? s)
+        {
+            if (s is null)
+            {
+                return IntPtr.Zero;
+            }
+
+            var byteCount = (s.Length + 1) * 2;
+
+            // Overflow checking
+            if (byteCount < s.Length)
+            {
+                ThrowArgumentOutOfRangeException(nameof(s));
+            }
+
+#if NET6_0_OR_GREATER
+            char* memory = (char*)NativeMemory.Alloc((uint)byteCount);
+            s.CopyTo(new Span<char>(memory, s.Length));
+#else
+            char* memory = (char*)(nint)Marshal.AllocHGlobal(byteCount);
+            // Avoid pulling in System.Memory for netstandard2.0 targets.
+            fixed (char* str = s)
+            {
+                Buffer.MemoryCopy(str, memory, byteCount, s.Length * 2);
+            }
+#endif
+
+            memory[s.Length] = '\0';
+            return (nint)memory;
+        }
+
+        public static IntPtr AllocStringAnsi(string? s)
+        {
+            if (s is null)
+            {
+                return IntPtr.Zero;
+            }
+
+            long longByteCount = (s.Length + 1) * (long)Marshal.SystemMaxDBCSCharSize;
+            int byteCount = (int)longByteCount;
+
+            // Overflow checking
+            if (byteCount != longByteCount)
+            {
+                ThrowArgumentOutOfRangeException(nameof(s));
+            }
+
+#if NET6_0_OR_GREATER
+            byte* memory = (byte*)NativeMemory.Alloc((uint)byteCount);
+#else
+            byte* memory = (byte*)(nint)Marshal.AllocHGlobal(byteCount);
+#endif
+
+            fixed (char* str = s)
+            {
+                int convertedBytes = Encoding.UTF8.GetBytes(str, s.Length, memory, byteCount);
+                memory[convertedBytes] = 0;
+            }
+
+            return (nint)memory;
+        }
+
+
+        public static void Free(IntPtr pointer)
+        {
+#if NET6_0_OR_GREATER
+            NativeMemory.Free((void*)(nint)pointer);
+#else
+            Marshal.FreeHGlobal(pointer);
+#endif
+        }
+
+
+#if NET6_0_OR_GREATER
+        [StackTraceHidden]
+#endif
+        [DoesNotReturn]
+        private static void ThrowArgumentOutOfRangeException(string argument)
+        {
+            throw new ArgumentOutOfRangeException(argument);
+        }
+    }
+}