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/Net/NetworkInformation/HostInformationPal.Windows.cs

@@ -26,7 +26,7 @@ public static string GetDomainName()
             return FixedInfo.domainName;
         }
 
-        private static Interop.IpHlpApi.FIXED_INFO GetFixedInfo()
+        private static unsafe Interop.IpHlpApi.FIXED_INFO GetFixedInfo()
         {
             uint size = 0;
             Interop.IpHlpApi.FIXED_INFO fixedInfo = default;
@@ -36,7 +36,7 @@ private static Interop.IpHlpApi.FIXED_INFO GetFixedInfo()
 
             while (result == Interop.IpHlpApi.ERROR_BUFFER_OVERFLOW)
             {
-                IntPtr buffer = Marshal.AllocHGlobal((int)size);
+                IntPtr buffer = (nint)NativeMemory.Alloc(size);
                 try
                 {
                     result = Interop.IpHlpApi.GetNetworkParams(buffer, ref size);
@@ -47,7 +47,7 @@ private static Interop.IpHlpApi.FIXED_INFO GetFixedInfo()
                 }
                 finally
                 {
-                    Marshal.FreeHGlobal(buffer);
+                    NativeMemory.Free((void*)(nint)buffer);
                 }
             }
 

src/libraries/Common/src/System/Security/Cryptography/ECCng.ImportExport.cs

@@ -453,7 +453,7 @@ private static ECCurve.ECCurveType ConvertToCurveTypeEnum(Interop.BCrypt.ECC_CUR
             return curveType;
         }
 
-        internal static SafeNCryptKeyHandle ImportKeyBlob(
+        internal static unsafe SafeNCryptKeyHandle ImportKeyBlob(
             string blobType,
             ReadOnlySpan<byte> keyBlob,
             string curveName,
@@ -471,8 +471,8 @@ internal static SafeNCryptKeyHandle ImportKeyBlob(
                 IntPtr buffPtr = IntPtr.Zero;
                 try
                 {
-                    descPtr = Marshal.AllocHGlobal(Marshal.SizeOf(desc));
-                    buffPtr = Marshal.AllocHGlobal(Marshal.SizeOf(buff));
+                    descPtr = (nint)NativeMemory.Alloc((uint)Marshal.SizeOf(desc));
+                    buffPtr = (nint)NativeMemory.Alloc((uint)Marshal.SizeOf(buff));
                     buff.cbBuffer = (curveName.Length + 1) * 2; // Add 1 for null terminator
                     buff.BufferType = Interop.BCrypt.CngBufferDescriptors.NCRYPTBUFFER_ECC_CURVE_NAME;
                     buff.pvBuffer = safeCurveName.DangerousGetHandle();
@@ -495,8 +495,8 @@ ref MemoryMarshal.GetReference(keyBlob),
                 }
                 finally
                 {
-                    Marshal.FreeHGlobal(descPtr);
-                    Marshal.FreeHGlobal(buffPtr);
+                    NativeMemory.Free((void*)(nint)descPtr);
+                    NativeMemory.Free((void*)(nint)buffPtr);
                 }
             }
 

src/libraries/Common/src/System/Security/Cryptography/RSACng.EncryptDecrypt.cs

@@ -104,7 +104,7 @@ private unsafe byte[] EncryptOrDecrypt(byte[] data, RSAEncryptionPadding padding
                         return EncryptOrDecrypt(keyHandle, data, AsymmetricPaddingMode.NCRYPT_PAD_PKCS1_FLAG, null, encrypt);
 
                     case RSAEncryptionPaddingMode.Oaep:
-                        IntPtr namePtr = Marshal.StringToHGlobalUni(padding.OaepHashAlgorithm.Name);
+                        IntPtr namePtr = NativeMemoryHelper.AllocStringUnicode(padding.OaepHashAlgorithm.Name);
                         try
                         {
                             var paddingInfo = new BCRYPT_OAEP_PADDING_INFO()
@@ -119,7 +119,7 @@ private unsafe byte[] EncryptOrDecrypt(byte[] data, RSAEncryptionPadding padding
                         }
                         finally
                         {
-                            Marshal.FreeHGlobal(namePtr);
+                            NativeMemoryHelper.Free(namePtr);
                         }
 
                     default:
@@ -192,7 +192,7 @@ private unsafe bool TryEncryptOrDecrypt(ReadOnlySpan<byte> data, Span<byte> dest
                         return TryEncryptOrDecrypt(keyHandle, data, destination, AsymmetricPaddingMode.NCRYPT_PAD_PKCS1_FLAG, null, encrypt, out bytesWritten);
 
                     case RSAEncryptionPaddingMode.Oaep:
-                        IntPtr namePtr = Marshal.StringToHGlobalUni(padding.OaepHashAlgorithm.Name);
+                        IntPtr namePtr = NativeMemoryHelper.AllocStringUnicode(padding.OaepHashAlgorithm.Name);
                         try
                         {
                             var paddingInfo = new BCRYPT_OAEP_PADDING_INFO()
@@ -205,7 +205,7 @@ private unsafe bool TryEncryptOrDecrypt(ReadOnlySpan<byte> data, Span<byte> dest
                         }
                         finally
                         {
-                            Marshal.FreeHGlobal(namePtr);
+                            NativeMemoryHelper.Free(namePtr);
                         }
 
                     default: