assume aligned reads

Author: lostmsu

src/runtime/Util.cs

@@ -1,14 +1,16 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
 
 namespace Python.Runtime
 {
     internal class Util
     {
+        // On Windows, a C long is always 32 bits.
+        static readonly bool clong32bit = Runtime.IsWindows || Runtime.Is32Bit;
+
         internal static Int64 ReadCLong(IntPtr tp, int offset)
         {
-            // On Windows, a C long is always 32 bits.
-            if (Runtime.IsWindows || Runtime.Is32Bit)
+            if (clong32bit)
             {
                 return Marshal.ReadInt32(tp, offset);
             }
@@ -20,7 +22,7 @@ internal static Int64 ReadCLong(IntPtr tp, int offset)
 
         internal static void WriteCLong(IntPtr type, int offset, Int64 flags)
         {
-            if (Runtime.IsWindows || Runtime.Is32Bit)
+            if (clong32bit)
             {
                 Marshal.WriteInt32(type, offset, (Int32)(flags & 0xffffffffL));
             }
@@ -29,5 +31,34 @@ internal static void WriteCLong(IntPtr type, int offset, Int64 flags)
                 Marshal.WriteInt64(type, offset, flags);
             }
         }
+
+        internal static unsafe Int32 ReadInt32Aligned(IntPtr ptr, int byteOffset)
+        {
+            byte* address = (byte*)ptr + byteOffset;
+            return *((int*)address);
+        }
+
+        internal static unsafe Int64 ReadInt64Aligned(IntPtr ptr, int byteOffset)
+        {
+            byte* address = (byte*)ptr + byteOffset;
+            return *((long*)address);
+        }
+
+        internal static unsafe Int64 ReadCLongAligned(IntPtr ptr, int byteOffset)
+        {
+            return clong32bit ? ReadInt32Aligned(ptr, byteOffset) : ReadInt64Aligned(ptr, byteOffset);
+        }
+
+        internal static unsafe IntPtr ReadIntPtrAligned(IntPtr ptr, int byteOffset)
+        {
+            byte* address = (byte*)ptr + byteOffset;
+            return *((IntPtr*)address);
+        }
+
+        internal static unsafe void WriteIntPtrAligned(IntPtr ptr, int byteOffset, IntPtr value)
+        {
+            byte* address = (byte*)ptr + byteOffset;
+            *((IntPtr*)address) = value;
+        }
     }
-}
+}

src/runtime/clrobject.cs

@@ -11,19 +11,20 @@ internal CLRObject(object ob, IntPtr tp)
         {
             IntPtr py = Runtime.PyType_GenericAlloc(tp, 0);
 
-            long flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
+            long flags = Util.ReadCLongAligned(tp, TypeOffset.tp_flags);
             if ((flags & TypeFlags.Subclass) != 0)
             {
-                IntPtr dict = Marshal.ReadIntPtr(py, ObjectOffset.TypeDictOffset(tp));
+                int dictOffset = ObjectOffset.TypeDictOffset(tp);
+                IntPtr dict = Util.ReadIntPtrAligned(py, dictOffset);
                 if (dict == IntPtr.Zero)
                 {
                     dict = Runtime.PyDict_New();
-                    Marshal.WriteIntPtr(py, ObjectOffset.TypeDictOffset(tp), dict);
+                    Util.WriteIntPtrAligned(py, dictOffset, dict);
                 }
             }
 
             GCHandle gc = GCHandle.Alloc(this);
-            Marshal.WriteIntPtr(py, ObjectOffset.magic(tp), (IntPtr)gc);
+            Util.WriteIntPtrAligned(py, ObjectOffset.magic(tp), (IntPtr)gc);
             tpHandle = tp;
             pyHandle = py;
             gcHandle = gc;

src/runtime/interop.cs

@@ -87,7 +87,7 @@ static ManagedDataOffsets()
         static int BaseOffset(IntPtr type)
         {
             Debug.Assert(type != IntPtr.Zero);
-            int typeSize = Marshal.ReadInt32(type, TypeOffset.tp_basicsize);
+            int typeSize = (int)Util.ReadIntPtrAligned(type, TypeOffset.tp_basicsize);
             Debug.Assert(typeSize > 0 && typeSize <= ExceptionOffset.Size());
             return typeSize;
         }

src/runtime/managedtype.cs

@@ -28,12 +28,12 @@ internal static ManagedType GetManagedObject(IntPtr ob)
                     tp = ob;
                 }
 
-                var flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
+                var flags = Util.ReadCLongAligned(tp, TypeOffset.tp_flags);
                 if ((flags & TypeFlags.Managed) != 0)
                 {
                     IntPtr op = tp == ob
-                        ? Marshal.ReadIntPtr(tp, TypeOffset.magic())
-                        : Marshal.ReadIntPtr(ob, ObjectOffset.magic(tp));
+                        ? Util.ReadIntPtrAligned(tp, TypeOffset.magic())
+                        : Util.ReadIntPtrAligned(ob, ObjectOffset.magic(tp));
                     if (op == IntPtr.Zero)
                     {
                         return null;

src/runtime/runtime.cs

@@ -191,10 +191,10 @@ public class Runtime
         internal static object IsFinalizingLock = new object();
         internal static bool IsFinalizing;
 
-        internal static bool Is32Bit = IntPtr.Size == 4;
+        internal static readonly bool Is32Bit = IntPtr.Size == 4;
 
         // .NET core: System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-        internal static bool IsWindows = Environment.OSVersion.Platform == PlatformID.Win32NT;
+        internal static readonly bool IsWindows = Environment.OSVersion.Platform == PlatformID.Win32NT;
 
         internal static bool IsPython2 = pyversionnumber < 30;
         internal static bool IsPython3 = pyversionnumber >= 30;