Fix build breaks

Commit migrated from https://github.com/dotnet/coreclr/commit/712cd0668801e2db3e78a49bbf9c5cb53011bc5f

diff --git a/src/coreclr/src/mscorlib/src/System/Globalization/CalendarData.Windows.cs b/src/coreclr/src/mscorlib/src/System/Globalization/CalendarData.Windows.cs
index 51a2727..bf2c73d 100644 (file)
--- a/src/coreclr/src/mscorlib/src/System/Globalization/CalendarData.Windows.cs
+++ b/src/coreclr/src/mscorlib/src/System/Globalization/CalendarData.Windows.cs
@@ -157,20 +157,9 @@ namespace System.Globalization
                 }
             }
 
-            GCHandle contextHandle = GCHandle.Alloc(data);
-            try
-            {
-                // Now call the enumeration API. Work is done by our callback function
-#if CORECLR
-                Interop.Kernel32.EnumCalendarInfoExEx(EnumCalendarsCallback, localeName, ENUM_ALL_CALENDARS, null, CAL_ICALINTVALUE, (IntPtr)contextHandle);
-#else
-                IntPtr callback = AddrofIntrinsics.AddrOf<Func<IntPtr, uint, IntPtr, IntPtr, Interop.BOOL>>(EnumCalendarsCallback);
-                Interop.Kernel32.EnumCalendarInfoExEx(callback, localeName, ENUM_ALL_CALENDARS, null, CAL_ICALINTVALUE, (IntPtr)contextHandle);
-#endif
-            }
-            finally
+            unsafe
             {
-                contextHandle.Free();
+                Interop.Kernel32.EnumCalendarInfoExEx(EnumCalendarsCallback, localeName, ENUM_ALL_CALENDARS, null, CAL_ICALINTVALUE, Unsafe.AsPointer(ref data));
             }
 
             // Copy to the output array
@@ -300,15 +289,13 @@ namespace System.Globalization
         }
 
         // EnumCalendarInfoExEx callback itself.
-#if !CORECLR
-        [NativeCallable(CallingConvention = CallingConvention.StdCall)]
-#endif
-        private static unsafe Interop.BOOL EnumCalendarInfoCallback(IntPtr lpCalendarInfoString, uint calendar, IntPtr pReserved, IntPtr lParam)
+        // [NativeCallable(CallingConvention = CallingConvention.StdCall)]
+        private static unsafe Interop.BOOL EnumCalendarInfoCallback(char* lpCalendarInfoString, uint calendar, IntPtr pReserved, void* lParam)
         {
-            EnumData context = (EnumData)((GCHandle)lParam).Target;
+            ref EnumData context = ref Unsafe.As<byte, EnumData>(ref *(byte*)lParam);
             try
             {
-                string calendarInfo = new string((char*)lpCalendarInfoString);
+                string calendarInfo = new string(lpCalendarInfoString);
 
                 // If we had a user override, check to make sure this differs
                 if (context.userOverride != calendarInfo)
@@ -354,20 +341,10 @@ namespace System.Globalization
                 }
             }
 
-            GCHandle contextHandle = GCHandle.Alloc(context);
-            try
+            unsafe
             {
-#if CORECLR
-                Interop.Kernel32.EnumCalendarInfoExEx(EnumCalendarInfoCallback, localeName, (uint)calendar, null, calType, (IntPtr)contextHandle);
-#else
                 // Now call the enumeration API. Work is done by our callback function
-                IntPtr callback = AddrofIntrinsics.AddrOf<Func<IntPtr, uint, IntPtr, IntPtr, Interop.BOOL>>(EnumCalendarInfoCallback);
-                Interop.Kernel32.EnumCalendarInfoExEx(callback, localeName, (uint)calendar, null, calType, (IntPtr)contextHandle);
-#endif // CORECLR
-            }
-            finally
-            {
-                contextHandle.Free();
+                Interop.Kernel32.EnumCalendarInfoExEx(EnumCalendarInfoCallback, localeName, (uint)calendar, null, calType, Unsafe.AsPointer(ref context));
             }
 
             // Now we have a list of data, fail if we didn't find anything.
@@ -464,12 +441,10 @@ namespace System.Globalization
             public IntList calendars;      // list of calendars found so far
         }
 
-#if !CORECLR
-        [NativeCallable(CallingConvention = CallingConvention.StdCall)]
-#endif
-        private static Interop.BOOL EnumCalendarsCallback(IntPtr lpCalendarInfoString, uint calendar, IntPtr reserved, IntPtr lParam)
+        // [NativeCallable(CallingConvention = CallingConvention.StdCall)]
+        private static unsafe Interop.BOOL EnumCalendarsCallback(char* lpCalendarInfoString, uint calendar, IntPtr reserved, void* lParam)
         {
-            EnumCalendarsData context = (EnumCalendarsData)((GCHandle)lParam).Target;
+            ref EnumCalendarsData context = ref Unsafe.As<byte, EnumCalendarsData>(ref *(byte*)lParam);
             try
             {
                 // If we had a user override, check to make sure this differs

diff --git a/src/coreclr/src/mscorlib/src/System/Globalization/CultureData.Windows.cs b/src/coreclr/src/mscorlib/src/System/Globalization/CultureData.Windows.cs
index 6d2678b..67d5201 100644 (file)
--- a/src/coreclr/src/mscorlib/src/System/Globalization/CultureData.Windows.cs
+++ b/src/coreclr/src/mscorlib/src/System/Globalization/CultureData.Windows.cs
@@ -4,6 +4,7 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 
@@ -195,7 +196,7 @@ namespace System.Globalization
         {
             Debug.Assert(!GlobalizationMode.Invariant);
 
-            return Interop.Kernel32.GetLocaleInfoEx(lpLocaleName, lcType, (IntPtr)lpLCData, cchData);
+            return Interop.Kernel32.GetLocaleInfoEx(lpLocaleName, lcType, lpLCData, cchData);
         }
 
         private string GetLocaleInfo(LocaleStringData type)
@@ -284,19 +285,9 @@ namespace System.Globalization
             context.cultureName = null;
             context.regionName = regionName;
 
-            GCHandle contextHandle = GCHandle.Alloc(context);
-            try
-            {
-#if CORECLR
-                Interop.Kernel32.EnumSystemLocalesEx(EnumSystemLocalesProc, LOCALE_SPECIFICDATA | LOCALE_SUPPLEMENTAL, (IntPtr)contextHandle, IntPtr.Zero);
-#else
-                IntPtr callback = AddrofIntrinsics.AddrOf<Func<IntPtr, uint, IntPtr, Interop.BOOL>>(EnumSystemLocalesProc);
-                Interop.Kernel32.EnumSystemLocalesEx(callback, LOCALE_SPECIFICDATA | LOCALE_SUPPLEMENTAL, (IntPtr)contextHandle, IntPtr.Zero);
-#endif
-            }
-            finally
+            unsafe
             {
-                contextHandle.Free();
+                Interop.Kernel32.EnumSystemLocalesEx(EnumSystemLocalesProc, LOCALE_SPECIFICDATA | LOCALE_SUPPLEMENTAL, Unsafe.AsPointer(ref context), IntPtr.Zero);
             }
 
             if (context.cultureName != null)
@@ -543,15 +534,13 @@ namespace System.Globalization
         }
 
         // EnumSystemLocaleEx callback.
-#if !CORECLR
-        [NativeCallable(CallingConvention = CallingConvention.StdCall)]
-#endif
-        private static unsafe Interop.BOOL EnumSystemLocalesProc(IntPtr lpLocaleString, uint flags, IntPtr contextHandle)
+        // [NativeCallable(CallingConvention = CallingConvention.StdCall)]
+        private static unsafe Interop.BOOL EnumSystemLocalesProc(char* lpLocaleString, uint flags, void* contextHandle)
         {
-            EnumLocaleData context = (EnumLocaleData)((GCHandle)contextHandle).Target;
+            ref EnumLocaleData context = ref Unsafe.As<byte, EnumLocaleData>(ref *(byte*)contextHandle);
             try
             {
-                string cultureName = new string((char*)lpLocaleString);
+                string cultureName = new string(lpLocaleString);
                 string regionName = GetLocaleInfoEx(cultureName, LOCALE_SISO3166CTRYNAME);
                 if (regionName != null && regionName.Equals(context.regionName, StringComparison.OrdinalIgnoreCase))
                 {
@@ -568,15 +557,13 @@ namespace System.Globalization
         }
 
         // EnumSystemLocaleEx callback.
-#if !CORECLR
-        [NativeCallable(CallingConvention = CallingConvention.StdCall)]
-#endif
-        private static unsafe Interop.BOOL EnumAllSystemLocalesProc(IntPtr lpLocaleString, uint flags, IntPtr contextHandle)
+        // [NativeCallable(CallingConvention = CallingConvention.StdCall)]
+        private static unsafe Interop.BOOL EnumAllSystemLocalesProc(char* lpLocaleString, uint flags, void* contextHandle)
         {
-            EnumData context = (EnumData)((GCHandle)contextHandle).Target;
+            ref EnumData context = ref Unsafe.As<byte, EnumData>(ref *(byte*)contextHandle);
             try
             {
-                context.strings.Add(new string((char*)lpLocaleString));
+                context.strings.Add(new string(lpLocaleString));
                 return Interop.BOOL.TRUE;
             }
             catch (Exception)
@@ -592,16 +579,13 @@ namespace System.Globalization
         }
 
         // EnumTimeFormatsEx callback itself.
-#if !CORECLR
-        [NativeCallable(CallingConvention = CallingConvention.StdCall)]
-#endif
-        private static unsafe Interop.BOOL EnumTimeCallback(IntPtr lpTimeFormatString, IntPtr lParam)
+        // [NativeCallable(CallingConvention = CallingConvention.StdCall)]
+        private static unsafe Interop.BOOL EnumTimeCallback(char* lpTimeFormatString, void* lParam)
         {
-            EnumData context = (EnumData)((GCHandle)lParam).Target;
-
+            ref EnumData context = ref Unsafe.As<byte, EnumData>(ref *(byte*)lParam);
             try
             {
-                context.strings.Add(new string((char*)lpTimeFormatString));
+                context.strings.Add(new string(lpTimeFormatString));
                 return Interop.BOOL.TRUE;
             }
             catch (Exception)
@@ -617,21 +601,9 @@ namespace System.Globalization
 
             EnumData data = new EnumData();
             data.strings = new StringList();
-            GCHandle dataHandle = GCHandle.Alloc(data);
-            try
-            {
-#if CORECLR
-                Interop.Kernel32.EnumTimeFormatsEx(EnumTimeCallback, localeName, (uint)dwFlags, (IntPtr)dataHandle);
-#else
-                // Now call the enumeration API. Work is done by our callback function
-                IntPtr callback = AddrofIntrinsics.AddrOf<Func<IntPtr, IntPtr, Interop.BOOL>>(EnumTimeCallback);
-                Interop.Kernel32.EnumTimeFormatsEx(callback, localeName, (uint)dwFlags, (IntPtr)dataHandle);
-#endif
-            }
-            finally
-            {
-                dataHandle.Free();
-            }
+
+            // Now call the enumeration API. Work is done by our callback function
+            Interop.Kernel32.EnumTimeFormatsEx(EnumTimeCallback, localeName, (uint)dwFlags, Unsafe.AsPointer(ref data));
 
             if (data.strings.Count > 0)
             {
@@ -757,19 +729,10 @@ namespace System.Globalization
 
             EnumData context = new EnumData();
             context.strings = new StringList();
-            GCHandle contextHandle = GCHandle.Alloc(context);
-            try
-            {
-#if CORECLR
-                Interop.Kernel32.EnumSystemLocalesEx(EnumAllSystemLocalesProc, flags, (IntPtr)contextHandle, IntPtr.Zero);
-#else
-                IntPtr callback = AddrofIntrinsics.AddrOf<Func<IntPtr, uint, IntPtr, Interop.BOOL>>(EnumAllSystemLocalesProc);
-                Interop.Kernel32.EnumSystemLocalesEx(callback, flags, (IntPtr)contextHandle, IntPtr.Zero);
-#endif
-            }
-            finally
+
+            unsafe
             {
-                contextHandle.Free();
+                Interop.Kernel32.EnumSystemLocalesEx(EnumAllSystemLocalesProc, flags, Unsafe.AsPointer(ref context), IntPtr.Zero);
             }
 
             CultureInfo [] cultures = new CultureInfo[context.strings.Count];
@@ -802,19 +765,10 @@ namespace System.Globalization
             {
                 EnumData context = new EnumData();
                 context.strings = new StringList();
-                GCHandle contextHandle = GCHandle.Alloc(context);
-                try
-                {
-#if CORECLR
-                    Interop.Kernel32.EnumSystemLocalesEx(EnumAllSystemLocalesProc, Interop.Kernel32.LOCALE_REPLACEMENT, (IntPtr)contextHandle, IntPtr.Zero);
-#else
-                    IntPtr callback = AddrofIntrinsics.AddrOf<Func<IntPtr, uint, IntPtr, Interop.BOOL>>(EnumAllSystemLocalesProc);
-                    Interop.Kernel32.EnumSystemLocalesEx(callback, Interop.Kernel32.LOCALE_REPLACEMENT, (IntPtr)contextHandle, IntPtr.Zero);
-#endif
-                }
-                finally
+
+                unsafe
                 {
-                    contextHandle.Free();
+                    Interop.Kernel32.EnumSystemLocalesEx(EnumAllSystemLocalesProc, Interop.Kernel32.LOCALE_REPLACEMENT, Unsafe.AsPointer(ref context), IntPtr.Zero);
                 }
 
                 for (int i=0; i<context.strings.Count; i++)