Merge pull request swiftlang#22338 from atrick/speedup-ubp-subscript

Remove useless optional unwrap from Unsafe[Raw]BufferPointer subscript.

Author: atrick

stdlib/public/core/UnsafeBufferPointer.swift.gyb

@@ -270,18 +270,19 @@ extension Unsafe${Mutable}BufferPointer: ${Mutable}Collection, RandomAccessColle
     get {
       _debugPrecondition(i >= 0)
       _debugPrecondition(i < endIndex)
-      return _position![i]
+      return _position._unsafelyUnwrappedUnchecked[i]
     }
 %if Mutable:
     nonmutating _modify {
       _debugPrecondition(i >= 0)
       _debugPrecondition(i < endIndex)
-      yield &_position![i]
+      yield &_position._unsafelyUnwrappedUnchecked[i]
     }
 %end
   }
 
   // Skip all debug and runtime checks
+
   @inlinable // unsafe-performance
   internal subscript(_unchecked i: Int) -> Element {
     get {

stdlib/public/core/UnsafeRawBufferPointer.swift.gyb

@@ -185,13 +185,13 @@ extension Unsafe${Mutable}RawBufferPointer: ${Mutable}Collection {
     get {
       _debugPrecondition(i >= 0)
       _debugPrecondition(i < endIndex)
-      return _position!.load(fromByteOffset: i, as: UInt8.self)
+      return _position._unsafelyUnwrappedUnchecked.load(fromByteOffset: i, as: UInt8.self)
     }
 %  if mutable:
     nonmutating set {
       _debugPrecondition(i >= 0)
       _debugPrecondition(i < endIndex)
-      _position!.storeBytes(of: newValue, toByteOffset: i, as: UInt8.self)
+      _position._unsafelyUnwrappedUnchecked.storeBytes(of: newValue, toByteOffset: i, as: UInt8.self)
     }
 %  end # mutable
   }

test/SILOptimizer/unsafebufferpointer.swift

@@ -45,3 +45,52 @@ public func testCount(_ x: UnsafeBufferPointer<UInt>) -> Int {
   return x.count
 }
 
+// Within the loop, there should be no extra checks.
+// CHECK-LABEL: define {{.*}} float {{.*}}testSubscript
+// The only unconditional branch is into the loop.
+// CHECK: br label %[[LOOP:[0-9]+]]
+//
+// For some reason, LLVM lays out the exit before the loop.
+// CHECK: .loopexit: ; preds = %[[LOOP]]
+// CHECK: ret float
+//
+// CHECK: ; <label>:[[LOOP]]:
+// CHECK: phi float [ 0.000000e+00
+// CHECK: add nuw i64 %{{.*}}, 1
+// CHECK: load float, float*
+// CHECK: fadd float
+// CHECK: [[CMP:%[0-9]+]] = icmp eq i64 %{{.*}}, %{{.*}}
+// CHECK: br i1 [[CMP]], label %.loopexit, label %[[LOOP]]
+public func testSubscript(_ ubp: UnsafeBufferPointer<Float>) -> Float {
+  var sum: Float = 0
+  for i in 0 ..< ubp.count {
+    sum += ubp[i]
+  }
+  return sum
+}
+
+// Within the loop, there should be no extra checks.
+// CHECK-LABEL: define {{.*}} i64 {{.*}}testSubscript
+// The only unconditional branch is into the loop.
+// CHECK: br label %[[LOOP:[0-9]+]]
+//
+// For some reason, LLVM lays out the exit before the loop.
+// CHECK: [[RET:.*]]: ; preds = %[[LOOP]], %entry
+// CHECK: ret i64
+//
+// CHECK: ; <label>:[[LOOP]]:
+// CHECK: phi i64 [ 0
+// CHECK: phi i64 [ 0
+// CHECK: add nuw i64 %{{.*}}, 1
+// CHECK: load i8, i8*
+// CHECK: zext i8 %{{.*}} to i64
+// CHECK: add i64
+// CHECK: [[CMP:%[0-9]+]] = icmp eq i64 %{{.*}}, %{{.*}}
+// CHECK: br i1 [[CMP]], label %[[RET]], label %[[LOOP]]
+public func testSubscript(_ ubp: UnsafeRawBufferPointer) -> Int {
+  var sum: Int = 0
+  for i in 0 ..< ubp.count {
+    sum &+= Int(ubp[i])
+  }
+  return sum
+}