[SILGen] Add Builtin.storeRaw.

The new builtin performs a store to unaligned memory.

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

@@ -2778,6 +2778,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

@@ -240,6 +240,14 @@ static ManagedValue emitBuiltinAssign(SILGenFunction &SGF, SILLocation loc,
                           /*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,

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)
+}