Swap to an unprotected load to get better codegen

Azoy · Azoy · commit aa6ef504fa65 · 2023-02-08T16:06:21.000-08:00
diff --git a/stdlib/public/Reflection/Sources/Reflection/GenericArguments.swift b/stdlib/public/Reflection/Sources/Reflection/GenericArguments.swift
@@ -51,7 +51,7 @@ extension GenericArguments: RandomAccessCollection {
     
     let start = argumentPointer.unsafelyUnwrapped
     let address = start + position * MemoryLayout<Type>.size
-    return address.loadUnaligned(as: Type.self)
+    return address.unprotectedLoad(as: Type.self)
   }
 }
 
diff --git a/stdlib/public/Reflection/Sources/Reflection/KeyPath.swift b/stdlib/public/Reflection/Sources/Reflection/KeyPath.swift
@@ -96,7 +96,7 @@ extension Case {
     var value = pair.buffer
     
     if isIndirect {
-      let owner = value.loadUnaligned(as: HeapObject.self)
+      let owner = value.unprotectedLoad(as: HeapObject.self)
       value = swift_projectBox(owner)
     }
     
diff --git a/stdlib/public/Reflection/Sources/_Runtime/ContextDescriptor/ClassDescriptor.swift b/stdlib/public/Reflection/Sources/_Runtime/ContextDescriptor/ClassDescriptor.swift
@@ -80,7 +80,7 @@ extension ClassDescriptor {
     // 'TargetStoredClassMetadataBounds', by the time we access this it will
     // have already been initialized way before for us. Thus, it is safe to
     // access this value non-atomically.
-    return storedBounds.load(as: Int.self)
+    return storedBounds.unprotectedLoad(as: Int.self)
   }
   
   @inlinable
diff --git a/stdlib/public/Reflection/Sources/_Runtime/ContextDescriptor/GenericSignature.swift b/stdlib/public/Reflection/Sources/_Runtime/ContextDescriptor/GenericSignature.swift
@@ -119,7 +119,7 @@ extension GenericSignature.RequirementDescriptor {
   @available(SwiftStdlib 5.9, *)
   @inlinable
   public var layoutKind: GenericSignature.LayoutKind {
-    address(for: \.requirement).loadUnaligned(
+    address(for: \.requirement).unprotectedLoad(
       as: GenericSignature.LayoutKind.self
     )
   }
@@ -140,7 +140,7 @@ extension GenericSignature.RequirementDescriptor {
   ) -> Any.Type? {
     _getTypeByMangledNameInContext(
       UnsafePointer(parameter.ptr._rawValue),
-      UInt(parameter.length),
+      UInt(truncatingIfNeeded: parameter.length),
       genericContext: context.ptr,
       genericArguments: argPtr
     )
@@ -269,7 +269,7 @@ extension GenericSignature.RequirementDescriptor {
 func getGenericSignature(at address: UnsafeRawPointer) -> GenericSignature {
   var address = address
 
-  let header = address.loadUnaligned(as: GenericSignature.Header.self)
+  let header = address.unprotectedLoad(as: GenericSignature.Header.self)
   address += MemoryLayout<GenericSignature.Header>.size
 
   let parameters = BufferView<GenericSignature.ParameterDescriptor>(
diff --git a/stdlib/public/Reflection/Sources/_Runtime/ExistentialContainer.swift b/stdlib/public/Reflection/Sources/_Runtime/ExistentialContainer.swift
@@ -67,15 +67,14 @@ extension AnyExistentialContainer {
       }
     }
     
-    let alignMask = UInt(metadata.vwt.flags.alignmentMask)
+    let alignMask = UInt(truncatingIfNeeded:metadata.vwt.flags.alignmentMask)
     let heapObjSize = UInt(MemoryLayout<Int>.size * 2)
     let byteOffset = (heapObjSize + alignMask) & ~alignMask
     
     return try withUnsafeMutablePointer(to: &self) {
-      let raw = UnsafeMutableRawPointer($0)
-      let heap = raw.loadUnaligned(as: UnsafeMutableRawPointer.self)
+      let heap = $0.raw.unprotectedLoad(as: UnsafeMutableRawPointer.self)
       
-      return try body(heap + Int(byteOffset))
+      return try body(heap + Int(truncatingIfNeeded: byteOffset))
     }
   }
 }
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Metadata/TupleMetadata.swift b/stdlib/public/Reflection/Sources/_Runtime/Metadata/TupleMetadata.swift
@@ -85,7 +85,7 @@ extension TupleMetadata.Elements.Element {
     // string
     address -= MemoryLayout<Int>.size
     
-    guard let cString = address.loadUnaligned(
+    guard let cString = address.unprotectedLoad(
       as: UnsafePointer<CChar>?.self
     ) else {
       return ""
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Metadata/TypeMetadata.swift b/stdlib/public/Reflection/Sources/_Runtime/Metadata/TypeMetadata.swift
@@ -29,7 +29,7 @@ extension TypeMetadata {
   @inlinable
   public var descriptor: TypeDescriptor {
     var address: UnsafeRawPointer
-    
+
     switch metadata.kind {
     case .struct:
       address = ptr + MemoryLayout<StructMetadata.Layout>.offset(of: \.descriptor)!
@@ -39,12 +39,12 @@ extension TypeMetadata {
     default:
       address = ptr + MemoryLayout<ClassMetadata.Layout>.offset(of: \.descriptor)!
     }
-    
-    address = address.loadUnaligned(as: UnsafeRawPointer.self)
-    
+
+    address = address.unprotectedLoad(as: UnsafeRawPointer.self)
+
     return TypeDescriptor(address)
   }
-  
+
   @inlinable
   public var genericArguments: UnsafeRawPointer {
     switch metadata.kind {
@@ -68,17 +68,17 @@ extension TypeMetadata {
   public var metadata: Metadata {
     Metadata(ptr)
   }
-  
+
   @inlinable
   public var `class`: ClassMetadata {
     ClassMetadata(ptr)
   }
-  
+
   @inlinable
   public var `enum`: EnumMetadata {
     EnumMetadata(ptr)
   }
-  
+
   @inlinable
   public var `struct`: StructMetadata {
     StructMetadata(ptr)
@@ -93,10 +93,10 @@ extension TypeMetadata {
     if let ss = typeRef.standardSubstitution {
       return ss
     }
-    
+
     return _resolve(typeRef)
   }
-  
+
   @usableFromInline
   func _resolve(_ typeRef: MangledTypeReference) -> Any.Type? {
     typeCache.getOrInsert(typeRef, from: self)
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/BufferView.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/BufferView.swift
@@ -54,7 +54,7 @@ extension BufferView: RandomAccessCollection {
   
   @inlinable
   public subscript(position: Int) -> Element {
-    start.loadUnaligned(
+    start.unprotectedLoad(
       fromByteOffset: position * MemoryLayout<Element>.size,
       as: Element.self
     )
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/Layouts.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/Layouts.swift
@@ -25,7 +25,7 @@ extension PublicLayout {
   @inline(__always)
   @inlinable
   public var layout: Layout {
-    ptr.loadUnaligned(as: Layout.self)
+    ptr.unprotectedLoad(as: Layout.self)
   }
   
   @inline(__always)
@@ -74,7 +74,7 @@ protocol PrivateLayout {
 @available(SwiftStdlib 5.9, *)
 extension PrivateLayout {
   var layout: Layout {
-    ptr.loadUnaligned(as: Layout.self)
+    ptr.unprotectedLoad(as: Layout.self)
   }
   
   var trailing: UnsafeRawPointer {
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/MangledTypeReference.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/MangledTypeReference.swift
@@ -34,19 +34,19 @@ extension MangledTypeReference {
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var standardSubstitution: Any.Type? {
-    let byte1 = ptr.loadUnaligned(fromByteOffset: 1, as: UInt8.self)
+    let byte1 = ptr.unprotectedLoad(fromByteOffset: 1, as: UInt8.self)
     
     guard byte1 != 0 else {
       return nil
     }
     
-    let byte2 = ptr.loadUnaligned(fromByteOffset: 2, as: UInt8.self)
+    let byte2 = ptr.unprotectedLoad(fromByteOffset: 2, as: UInt8.self)
     
     guard byte2 == 0 else {
       return nil
     }
     
-    let byte0 = ptr.loadUnaligned(as: UInt8.self)
+    let byte0 = ptr.unprotectedLoad(as: UInt8.self)
     
     switch (byte0, byte1) {
     // Stdlib types
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/PointerStuff.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/PointerStuff.swift
@@ -39,46 +39,51 @@ extension UnsafeBufferPointer {
 
 extension UnsafeRawPointer {
   @_alwaysEmitIntoClient
-  var bitPattern: UInt64 {
-    UInt64(truncatingIfNeeded: UInt(bitPattern: self))
+  var binaryString: String {
+    // FIXME: Use 'StaticString's description when it makes an immortal string.
+    String(cString: UnsafePointer<CChar>(_rawValue))
   }
-}
 
-extension UInt64 {
   @_alwaysEmitIntoClient
-  var rawPointer: UnsafeRawPointer {
-    let pointer = UnsafeRawPointer(bitPattern: UInt(truncatingIfNeeded: self))
-    
-    return pointer.unsafelyUnwrapped
+  var bitPattern: UInt64 {
+    UInt64(truncatingIfNeeded: UInt(bitPattern: self))
   }
-}
 
-extension UnsafeRawPointer {
   @_alwaysEmitIntoClient
   var mutable: UnsafeMutableRawPointer {
     UnsafeMutableRawPointer(mutating: self)
   }
+
+  @_alwaysEmitIntoClient
+  func offset(of count: Int) -> UnsafeRawPointer {
+    advanced(by: count * MemoryLayout<UnsafeRawPointer>.size)
+  }
+
+  @_alwaysEmitIntoClient
+  public func unprotectedLoad<T>(
+    fromByteOffset offset: Int = 0,
+    as type: T.Type
+  ) -> T {
+    UnsafePointer<T>((self + offset)._rawValue).pointee
+  }
 }
 
-extension UnsafeRawPointer {
+extension UnsafeMutableRawPointer {
   @_alwaysEmitIntoClient
-  var binaryString: String {
-//    let length = strlen(UnsafePointer(_rawValue))
-//
-//    // This is a hack to make an immortal string.
-//    return String(
-//      _builtinStringLiteral: _rawValue,
-//      utf8CodeUnitCount: length._builtinWordValue,
-//      isASCII: Builtin.trunc_Word_Int1(0._builtinWordValue)
-//    )
-    String(cString: UnsafePointer<CChar>(_rawValue))
+  public func unprotectedLoad<T>(
+    fromByteOffset offset: Int = 0,
+    as type: T.Type
+  ) -> T {
+    UnsafePointer<T>((self + offset)._rawValue).pointee
   }
 }
 
-extension UnsafeRawPointer {
+extension UInt64 {
   @_alwaysEmitIntoClient
-  func offset(of count: Int) -> UnsafeRawPointer {
-    advanced(by: count * MemoryLayout<UnsafeRawPointer>.size)
+  var rawPointer: UnsafeRawPointer {
+    let pointer = UnsafeRawPointer(bitPattern: UInt(truncatingIfNeeded: self))
+    
+    return pointer.unsafelyUnwrapped
   }
 }
 
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/PtrAuth.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/PtrAuth.swift
@@ -336,49 +336,49 @@ extension UnsafeRawPointer {
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var signedVWTInitializeBufferWithCopyOfBuffer: ValueWitnessTable.InitializeBufferWithCopyOfBuffer {
-    unsafeBitCast(loadUnaligned(as: UnsafeRawPointer.self))
+    unsafeBitCast(unprotectedLoad(as: UnsafeRawPointer.self))
   }
   
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var signedVWTDestroy: ValueWitnessTable.Destroy {
-    unsafeBitCast(loadUnaligned(as: UnsafeRawPointer.self))
+    unsafeBitCast(unprotectedLoad(as: UnsafeRawPointer.self))
   }
   
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var signedVWTInitializeWithCopy: ValueWitnessTable.InitializeWithCopy {
-    unsafeBitCast(loadUnaligned(as: UnsafeRawPointer.self))
+    unsafeBitCast(unprotectedLoad(as: UnsafeRawPointer.self))
   }
   
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var signedVWTAssignWithCopy: ValueWitnessTable.AssignWithCopy {
-    unsafeBitCast(loadUnaligned(as: UnsafeRawPointer.self))
+    unsafeBitCast(unprotectedLoad(as: UnsafeRawPointer.self))
   }
   
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var signedVWTInitializeWithTake: ValueWitnessTable.InitializeWithTake {
-    unsafeBitCast(loadUnaligned(as: UnsafeRawPointer.self))
+    unsafeBitCast(unprotectedLoad(as: UnsafeRawPointer.self))
   }
   
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var signedVWTAssignWithTake: ValueWitnessTable.AssignWithTake {
-    unsafeBitCast(loadUnaligned(as: UnsafeRawPointer.self))
+    unsafeBitCast(unprotectedLoad(as: UnsafeRawPointer.self))
   }
   
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var signedVWTGetEnumTagSinglePayload: ValueWitnessTable.GetEnumTagSinglePayload {
-    unsafeBitCast(loadUnaligned(as: UnsafeRawPointer.self))
+    unsafeBitCast(unprotectedLoad(as: UnsafeRawPointer.self))
   }
   
   @available(SwiftStdlib 5.9, *)
   @inlinable
   var signedVWTStoreEnumTagSinglePayload: ValueWitnessTable.StoreEnumTagSinglePayload {
-    unsafeBitCast(loadUnaligned(as: UnsafeRawPointer.self))
+    unsafeBitCast(unprotectedLoad(as: UnsafeRawPointer.self))
   }
 #endif
 }
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativeDirectPointer.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativeDirectPointer.swift
@@ -32,7 +32,7 @@ extension UnsafeRawPointer {
   @inlinable
   public func relativeDirectAddress<T>(as type: T.Type) -> UnsafeRawPointer {
     let relativePointer = RelativeDirectPointer<T>(
-      offset: loadUnaligned(as: Int32.self)
+      offset: unprotectedLoad(as: Int32.self)
     )
     
     return relativePointer.address(from: self)
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativeIndirectPointer.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativeIndirectPointer.swift
@@ -23,7 +23,7 @@ public struct RelativeIndirectPointer<Pointee>: RelativePointer {
   
   @inlinable
   public func address(from ptr: UnsafeRawPointer) -> UnsafeRawPointer {
-    (ptr + Int(offset)).loadUnaligned(as: UnsafeRawPointer.self)
+    (ptr + Int(offset)).unprotectedLoad(as: UnsafeRawPointer.self)
   }
 }
 
@@ -32,7 +32,7 @@ extension UnsafeRawPointer {
   @inlinable
   public func relativeIndirectAddress<T>(as type: T.Type) -> UnsafeRawPointer {
     let relativePointer = RelativeIndirectPointer<T>(
-      offset: loadUnaligned(as: Int32.self)
+      offset: unprotectedLoad(as: Int32.self)
     )
     
     return relativePointer.address(from: self)
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativeIndirectablePointer.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativeIndirectablePointer.swift
@@ -26,7 +26,7 @@ public struct RelativeIndirectablePointer<Pointee>: RelativePointer {
     let address = ptr + Int(truncatingIfNeeded: offset & ~1)
     
     if offset & 1 != 0 {
-      return address.loadUnaligned(as: UnsafeRawPointer.self)
+      return address.unprotectedLoad(as: UnsafeRawPointer.self)
     } else {
       return address
     }
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativeIndirectablePointerIntPair.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativeIndirectablePointerIntPair.swift
@@ -49,7 +49,7 @@ public struct RelativeIndirectablePointerIntPair<
     let address = ptr + (unresolved & ~1)
     
     if unresolved & 1 != 0 {
-      return address.loadUnaligned(as: UnsafeRawPointer.self)
+      return address.unprotectedLoad(as: UnsafeRawPointer.self)
     } else {
       return address
     }
@@ -64,7 +64,7 @@ extension UnsafeRawPointer {
     and type2: U.Type
   ) -> UnsafeRawPointer {
     let relativePointer = RelativeIndirectablePointerIntPair<T, U>(
-      offset: loadUnaligned(as: Int32.self)
+      offset: unprotectedLoad(as: Int32.self)
     )
     
     return relativePointer.address(from: self)
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativePointer.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/RelativePointer.swift
@@ -34,6 +34,6 @@ extension RelativePointer {
       return nil
     }
     
-    return address(from: ptr).loadUnaligned(as: Pointee.self)
+    return address(from: ptr).unprotectedLoad(as: Pointee.self)
   }
 }
diff --git a/stdlib/public/Reflection/Sources/_Runtime/Utils/TypeCache.swift b/stdlib/public/Reflection/Sources/_Runtime/Utils/TypeCache.swift

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ extension GenericArguments: RandomAccessCollection {`
`51`	`51`
`52`	`52`	`let start = argumentPointer.unsafelyUnwrapped`
`53`	`53`	`let address = start + position * MemoryLayout<Type>.size`
`54`		`- return address.loadUnaligned(as: Type.self)`
	`54`	`+ return address.unprotectedLoad(as: Type.self)`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ extension Case {`
`96`	`96`	`var value = pair.buffer`
`97`	`97`
`98`	`98`	`if isIndirect {`
`99`		`- let owner = value.loadUnaligned(as: HeapObject.self)`
	`99`	`+ let owner = value.unprotectedLoad(as: HeapObject.self)`
`100`	`100`	`value = swift_projectBox(owner)`
`101`	`101`	`}`
`102`	`102`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ extension ClassDescriptor {`
`80`	`80`	`// 'TargetStoredClassMetadataBounds', by the time we access this it will`
`81`	`81`	`// have already been initialized way before for us. Thus, it is safe to`
`82`	`82`	`// access this value non-atomically.`
`83`		`- return storedBounds.load(as: Int.self)`
	`83`	`+ return storedBounds.unprotectedLoad(as: Int.self)`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`@inlinable`
Original file line number	Diff line number	Diff line change
`@@ -67,15 +67,14 @@ extension AnyExistentialContainer {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`- let alignMask = UInt(metadata.vwt.flags.alignmentMask)`
	`70`	`+ let alignMask = UInt(truncatingIfNeeded:metadata.vwt.flags.alignmentMask)`
`71`	`71`	`let heapObjSize = UInt(MemoryLayout<Int>.size * 2)`
`72`	`72`	`let byteOffset = (heapObjSize + alignMask) & ~alignMask`
`73`	`73`
`74`	`74`	`return try withUnsafeMutablePointer(to: &self) {`
`75`		`- let raw = UnsafeMutableRawPointer($0)`
`76`		`- let heap = raw.loadUnaligned(as: UnsafeMutableRawPointer.self)`
	`75`	`+ let heap = $0.raw.unprotectedLoad(as: UnsafeMutableRawPointer.self)`
`77`	`76`
`78`		`- return try body(heap + Int(byteOffset))`
	`77`	`+ return try body(heap + Int(truncatingIfNeeded: byteOffset))`
`79`	`78`	`}`
`80`	`79`	`}`
`81`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ extension BufferView: RandomAccessCollection {`
`54`	`54`
`55`	`55`	`@inlinable`
`56`	`56`	`public subscript(position: Int) -> Element {`
`57`		`- start.loadUnaligned(`
	`57`	`+ start.unprotectedLoad(`
`58`	`58`	`fromByteOffset: position * MemoryLayout<Element>.size,`
`59`	`59`	`as: Element.self`
`60`	`60`	`)`