[stdlib] add unaligned loads to UnsafeRawPointer

Author: glessard

stdlib/public/core/UnsafeRawPointer.swift

@@ -424,7 +424,6 @@ public struct UnsafeRawPointer: _Pointer {
     let rawPointer = (self + offset)._rawValue
 
 #if compiler(>=5.5) && $BuiltinAssumeAlignment
-    // TODO: to support misaligned raw loads, simply remove this assumption.
     let alignedPointer =
       Builtin.assumeAlignment(rawPointer,
                               MemoryLayout<T>.alignment._builtinWordValue)
@@ -434,6 +433,35 @@ public struct UnsafeRawPointer: _Pointer {
 #endif
   }
 
+  /// Returns a new instance of the given type, constructed from the raw memory
+  /// at the specified offset.
+  ///
+  /// This function only supports loading trivial types.
+  /// A trivial type does not contain any reference-counted property
+  /// within its in-memory representation.
+  /// The memory at this pointer plus `offset` must be laid out
+  /// identically to the in-memory representation of `T`.
+  ///
+  /// - Note: A trivial type can be copied with just a bit-for-bit copy without
+  ///   any indirection or reference-counting operations. Generally, native
+  ///   Swift types that do not contain strong or weak references or other
+  ///   forms of indirection are trivial, as are imported C structs and enums.
+  ///
+  /// - Parameters:
+  ///   - offset: The offset from this pointer, in bytes. `offset` must be
+  ///     nonnegative. The default is zero.
+  ///   - type: The type of the instance to create.
+  /// - Returns: A new instance of type `T`, read from the raw bytes at
+  ///   `offset`. The returned instance isn't associated
+  ///   with the value in the range of memory referenced by this pointer.
+  @_alwaysEmitIntoClient
+  public func loadUnaligned<T>(
+    fromByteOffset offset: Int = 0,
+    as type: T.Type
+  ) -> T {
+    _debugPrecondition(_isPOD(T.self))
+    return Builtin.loadRaw((self + offset)._rawValue)
+  }
 }
 
 extension UnsafeRawPointer: Strideable {
@@ -1120,7 +1148,6 @@ public struct UnsafeMutableRawPointer: _Pointer {
     let rawPointer = (self + offset)._rawValue
 
 #if compiler(>=5.5) && $BuiltinAssumeAlignment
-    // TODO: to support misaligned raw loads, simply remove this assumption.
     let alignedPointer =
       Builtin.assumeAlignment(rawPointer,
                               MemoryLayout<T>.alignment._builtinWordValue)
@@ -1130,6 +1157,36 @@ public struct UnsafeMutableRawPointer: _Pointer {
 #endif
   }
 
+  /// Returns a new instance of the given type, constructed from the raw memory
+  /// at the specified offset.
+  ///
+  /// This function only supports loading trivial types.
+  /// A trivial type does not contain any reference-counted property
+  /// within its in-memory representation.
+  /// The memory at this pointer plus `offset` must be laid out
+  /// identically to the in-memory representation of `T`.
+  ///
+  /// - Note: A trivial type can be copied with just a bit-for-bit copy without
+  ///   any indirection or reference-counting operations. Generally, native
+  ///   Swift types that do not contain strong or weak references or other
+  ///   forms of indirection are trivial, as are imported C structs and enums.
+  ///
+  /// - Parameters:
+  ///   - offset: The offset from this pointer, in bytes. `offset` must be
+  ///     nonnegative. The default is zero.
+  ///   - type: The type of the instance to create.
+  /// - Returns: A new instance of type `T`, read from the raw bytes at
+  ///   `offset`. The returned instance isn't associated
+  ///   with the value in the range of memory referenced by this pointer.
+  @_alwaysEmitIntoClient
+  public func loadUnaligned<T>(
+    fromByteOffset offset: Int = 0,
+    as type: T.Type
+  ) -> T {
+    _debugPrecondition(_isPOD(T.self))
+    return Builtin.loadRaw((self + offset)._rawValue)
+  }
+
   /// Stores the given value's bytes into raw memory at the specified offset.
   ///
   /// The type `T` to be stored must be a trivial type. The memory at this