Merge pull request #71673 from nate-chandler/bitwise-copyable/opt-store-bytes

[BitwiseCopyable] Optimize storeBytes overload.

Author: nate-chandler

include/swift/AST/Builtins.def

@@ -261,6 +261,12 @@ BUILTIN_SIL_OPERATION(Assign, "assign", Special)
 /// Init has type (T, Builtin.RawPointer) -> ()
 BUILTIN_SIL_OPERATION(Init, "initialize", Special)
 
+/// StoreRaw has type (T, Builtin.RawPointer) -> ()
+/// Stores a T to raw memory.
+/// Its address does not adhere to strict aliasing.
+/// See also LoadRaw.
+BUILTIN_SIL_OPERATION(StoreRaw, "storeRaw", Special)
+
 /// CastToNativeObject has type (T) -> Builtin.NativeObject.
 ///
 /// This builtin asserts if the underlying type /could/ be objc.

lib/AST/Builtins.cpp

@@ -2776,6 +2776,7 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
 
   case BuiltinValueKind::Assign:
   case BuiltinValueKind::Init:
+  case BuiltinValueKind::StoreRaw:
     if (!Types.empty()) return nullptr;
     return getStoreOperation(Context, Id);
 

lib/SILGen/SILGenBuiltin.cpp

@@ -206,35 +206,48 @@ static ManagedValue emitBuiltinDestroy(SILGenFunction &SGF,
   return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
 }
 
-static ManagedValue emitBuiltinAssign(SILGenFunction &SGF,
-                                      SILLocation loc,
-                                      SubstitutionMap substitutions,
-                                      ArrayRef<ManagedValue> args,
-                                      SGFContext C) {
-  assert(args.size() >= 2 && "assign should have two arguments");
+static ManagedValue emitBuiltinStore(SILGenFunction &SGF, SILLocation loc,
+                                     SubstitutionMap substitutions,
+                                     ArrayRef<ManagedValue> args, SGFContext C,
+                                     bool isStrict, bool isInvariant,
+                                     llvm::MaybeAlign alignment) {
+  assert(args.size() >= 2 && "should have two arguments");
   assert(substitutions.getReplacementTypes().size() == 1 &&
-         "assign should have a single substitution");
+         "should have a single substitution");
 
   // The substitution determines the type of the thing we're destroying.
-  CanType assignFormalType =
-    substitutions.getReplacementTypes()[0]->getCanonicalType();
-  SILType assignType = SGF.getLoweredType(assignFormalType);
-  
+  CanType formalTy = substitutions.getReplacementTypes()[0]->getCanonicalType();
+  SILType loweredTy = SGF.getLoweredType(formalTy);
+
   // Convert the destination pointer argument to a SIL address.
-  SILValue addr = SGF.B.createPointerToAddress(loc,
-                                               args.back().getUnmanagedValue(),
-                                               assignType.getAddressType(),
-                                               /*isStrict*/ true,
-                                               /*isInvariant*/ false);
-  
-  // Build the value to be assigned, reconstructing tuples if needed.
-  auto src = RValue(SGF, args.slice(0, args.size() - 1), assignFormalType);
-  
+  SILValue addr = SGF.B.createPointerToAddress(
+      loc, args.back().getUnmanagedValue(), loweredTy.getAddressType(),
+      isStrict, isInvariant, alignment);
+
+  // Build the value to be stored, reconstructing tuples if needed.
+  auto src = RValue(SGF, args.slice(0, args.size() - 1), formalTy);
+
   std::move(src).ensurePlusOne(SGF, loc).assignInto(SGF, loc, addr);
 
   return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
 }
 
+static ManagedValue emitBuiltinAssign(SILGenFunction &SGF, SILLocation loc,
+                                      SubstitutionMap substitutions,
+                                      ArrayRef<ManagedValue> args,
+                                      SGFContext C) {
+  return emitBuiltinStore(SGF, loc, substitutions, args, C, /*isStrict=*/true,
+                          /*isInvariant=*/false, llvm::MaybeAlign());
+}
+
+static ManagedValue emitBuiltinStoreRaw(SILGenFunction &SGF, SILLocation loc,
+                                        SubstitutionMap substitutions,
+                                        ArrayRef<ManagedValue> args,
+                                        SGFContext C) {
+  return emitBuiltinStore(SGF, loc, substitutions, args, C, /*isStrict=*/false,
+                          /*isInvariant=*/false, llvm::MaybeAlign(1));
+}
+
 /// Emit Builtin.initialize by evaluating the operand directly into
 /// the address.
 static ManagedValue emitBuiltinInit(SILGenFunction &SGF,

stdlib/public/core/UnsafeRawPointer.swift

@@ -1316,12 +1316,7 @@ public struct UnsafeMutableRawPointer: _Pointer {
   public func storeBytes<T : _BitwiseCopyable>(
     of value: T, toByteOffset offset: Int = 0, as type: T.Type
   ) {
-    withUnsafePointer(to: value) { source in
-      _memcpy(
-        dest: (self + offset), 
-        src: source, 
-        size: UInt(MemoryLayout<T>.size))
-    }
+    Builtin.storeRaw(value, (self + offset)._rawValue)
   }
 #endif
   @inlinable

test/SILOptimizer/builtins.swift

@@ -0,0 +1,24 @@
+// RUN: %target-swift-frontend -enable-builtin-module -O -emit-sil %s | %FileCheck %s
+
+import Builtin
+
+// CHECK-LABEL: sil @storeBytes_BitwiseCopyable : {{.*}} {
+// CHECK:       bb0(
+// CHECK-SAME:      [[SELF:%[^,]+]] : $UnsafeMutableRawPointer, 
+// CHECK-SAME:      [[VALUE:%[^,]+]] : $*T, 
+// CHECK-SAME:      [[OFFSET:%[^,]+]] : $Int, 
+// CHECK-SAME:      {{%[^,]+}} : $@thick T.Type):
+// CHECK:         [[SELF_RAW_VALUE:%[^,]+]] = struct_extract [[SELF]] : {{.*}} #UnsafeMutableRawPointer._rawValue
+// CHECK:         [[OFFSET_VALUE:%[^,]+]] = struct_extract [[OFFSET]] : {{.*}} #Int._value
+// CHECK:         [[OFFSET_WORD:%[^,]+]] = builtin "truncOrBitCast_Int64_Word"([[OFFSET_VALUE]] : $Builtin.Int64)
+// CHECK:         [[DESTINATION_POINTER:%[^,]+]] = index_raw_pointer [[SELF_RAW_VALUE]] : $Builtin.RawPointer, [[OFFSET_WORD]]
+// CHECK:         [[DESTINATION:%[^,]+]] = pointer_to_address [[DESTINATION_POINTER]] : $Builtin.RawPointer to [align=1]
+// CHECK:         copy_addr [[VALUE]] to [[DESTINATION]]
+// CHECK-LABEL: } // end sil function 'storeBytes_BitwiseCopyable'
+@_silgen_name("storeBytes_BitwiseCopyable")
+public func storeBytes<T : _BitwiseCopyable>(
+  _ self: UnsafeMutableRawPointer,
+  of value: T, toByteOffset offset: Int = 0, as type: T.Type
+) {
+  Builtin.storeRaw(value, (self + offset)._rawValue)
+}