stdlib: let the construction of a small string literal compile down to 2 constant loads.

The main part of this is to rewrite the small string literal-constructor to work with values (= shifting bytes) instead of setting bytes in memory.
This allows the compiler to fold away everything and end up with the optimal code for small string literals.

Author: eeckstein

stdlib/public/core/SmallString.swift

@@ -127,25 +127,30 @@ extension _SmallUTF8String {
 #endif
   }
 
+  @inline(__always)
   @inlinable
+  @effects(readonly)
   public // @testable
   init?(_ codeUnits: UnsafeBufferPointer<UInt8>) {
 #if arch(i386) || arch(arm)
     return nil // Never form small strings on 32-bit
 #else
     let count = codeUnits.count
     guard count <= _SmallUTF8String.capacity else { return nil }
-    self.init()
-    self._withAllUnsafeMutableBytes { rawBufPtr in
-      let rawDst = rawBufPtr.baseAddress._unsafelyUnwrappedUnchecked
-      memcpy_(
-        dst: rawDst.assumingMemoryBound(to: UInt8.self),
-        src: codeUnits.baseAddress._unsafelyUnwrappedUnchecked,
-        count: count
-      )
+
+    let addr = codeUnits.baseAddress._unsafelyUnwrappedUnchecked
+    var high: UInt
+    let lowCount: Int
+    if count > 8 {
+      lowCount = 8
+      high = _bytesToUInt(addr + 8, count &- 8)
+    } else {
+      lowCount = count
+      high = 0
     }
-    _sanityCheck(self.count == 0, "overwrote count early?")
-    self.count = count
+    high |= (UInt(count) &<< (8*15))
+    let low = _bytesToUInt(addr, lowCount)
+    _storage = (low, high)
 
     // FIXME: support transcoding
     if !self.isASCII { return nil }
@@ -169,6 +174,18 @@ extension _SmallUTF8String {
   }
 }
 
+@inline(__always)
+@inlinable
+func _bytesToUInt(_ input: UnsafePointer<UInt8>, _ c: Int) -> UInt {
+  var r: UInt = 0
+  var shift: Int = 0
+  for idx in 0..<c {
+    r = r | (UInt(input[idx]) &<< shift)
+    shift = shift &+ 8
+  }
+  return r
+}
+
 //
 // Small string read interface
 //

stdlib/public/core/String.swift

@@ -734,6 +734,7 @@ extension String : _ExpressibleByBuiltinUTF16StringLiteral {
 }
 
 extension String : _ExpressibleByBuiltinStringLiteral {
+  @inline(__always)
   @inlinable
   @effects(readonly)
   @_semantics("string.makeUTF8")

test/SILOptimizer/string_literals.swift

@@ -0,0 +1,34 @@
+// RUN: %target-swift-frontend -parse-as-library -O -emit-ir  %s | %FileCheck %s
+// RUN: %target-swift-frontend -parse-as-library -Osize -emit-ir  %s | %FileCheck %s
+// REQUIRES: swift_stdlib_no_asserts,optimized_stdlib
+
+// This is an end-to-end test to ensure that the optimizer generates
+// optimal code for string literals
+
+// CHECK-LABEL: define {{.*}}test_create_verysmallstring
+// CHECK:      entry:
+// CHECK-NEXT:   ret {{.*}} inttoptr
+public func test_create_verysmallstring() -> String {
+  return "a"
+}
+
+// CHECK-LABEL: define {{.*}}test_create_smallstring
+// CHECK:      entry:
+// CHECK-NEXT:   ret {{.*}} inttoptr
+public func test_create_smallstring() -> String {
+  return "abcdefghijkl012"
+}
+
+// CHECK-LABEL: define {{.*}}test_create_largestring
+// CHECK:      entry:
+// CHECK-NEXT:   ret {{.*}} inttoptr
+public func test_create_largestring() -> String {
+  return "abcdefghijkl012qwerqwer"
+}
+
+// CHECK-LABEL: define {{.*}}test_create_unicode
+// CHECK:      entry:
+// CHECK-NEXT:   ret {{.*}} inttoptr
+public func test_create_unicode() -> String {
+  return "❄️gastroperiodyni"
+}