SILGen Builtin.loadRaw with alignment=1

This adds compiler support for misaligned raw pointer access. A Swift
Evolution proposal is required before users can take advantage of
this.

Author: atrick

lib/SILGen/SILGenBuiltin.cpp

@@ -101,7 +101,8 @@ static ManagedValue emitBuiltinLoadOrTake(SILGenFunction &SGF,
                                           SGFContext C,
                                           IsTake_t isTake,
                                           bool isStrict,
-                                          bool isInvariant) {
+                                          bool isInvariant,
+                                          llvm::MaybeAlign align) {
   assert(substitutions.getReplacementTypes().size() == 1 &&
          "load should have single substitution");
   assert(args.size() == 1 && "load should have a single argument");
@@ -113,9 +114,12 @@ static ManagedValue emitBuiltinLoadOrTake(SILGenFunction &SGF,
   SILType loadedType = rvalueTL.getLoweredType();
 
   // Convert the pointer argument to a SIL address.
+  //
+  // Default to an unaligned pointer. This can be optimized in the presence of
+  // Builtin.assumeAlignment.
   SILValue addr = SGF.B.createPointerToAddress(loc, args[0].getUnmanagedValue(),
                                                loadedType.getAddressType(),
-                                               isStrict, isInvariant);
+                                               isStrict, isInvariant, align);
   // Perform the load.
   return SGF.emitLoad(loc, addr, rvalueTL, C, isTake);
 }
@@ -125,39 +129,47 @@ static ManagedValue emitBuiltinLoad(SILGenFunction &SGF,
                                     SubstitutionMap substitutions,
                                     ArrayRef<ManagedValue> args,
                                     SGFContext C) {
+  // Regular loads assume natural alignment.
   return emitBuiltinLoadOrTake(SGF, loc, substitutions, args,
                                C, IsNotTake,
-                               /*isStrict*/ true, /*isInvariant*/ false);
+                               /*isStrict*/ true, /*isInvariant*/ false,
+                               llvm::MaybeAlign());
 }
 
 static ManagedValue emitBuiltinLoadRaw(SILGenFunction &SGF,
                                        SILLocation loc,
                                        SubstitutionMap substitutions,
                                        ArrayRef<ManagedValue> args,
                                        SGFContext C) {
+  // Raw loads cannot assume alignment.
   return emitBuiltinLoadOrTake(SGF, loc, substitutions, args,
                                C, IsNotTake,
-                               /*isStrict*/ false, /*isInvariant*/ false);
+                               /*isStrict*/ false, /*isInvariant*/ false,
+                               llvm::MaybeAlign(1));
 }
 
 static ManagedValue emitBuiltinLoadInvariant(SILGenFunction &SGF,
                                              SILLocation loc,
                                              SubstitutionMap substitutions,
                                              ArrayRef<ManagedValue> args,
                                              SGFContext C) {
+  // Regular loads assume natural alignment.
   return emitBuiltinLoadOrTake(SGF, loc, substitutions, args,
                                C, IsNotTake,
-                               /*isStrict*/ false, /*isInvariant*/ true);
+                               /*isStrict*/ false, /*isInvariant*/ true,
+                               llvm::MaybeAlign());
 }
 
 static ManagedValue emitBuiltinTake(SILGenFunction &SGF,
                                     SILLocation loc,
                                     SubstitutionMap substitutions,
                                     ArrayRef<ManagedValue> args,
                                     SGFContext C) {
+  // Regular loads assume natural alignment.
   return emitBuiltinLoadOrTake(SGF, loc, substitutions, args,
                                C, IsTake,
-                               /*isStrict*/ true, /*isInvariant*/ false);
+                               /*isStrict*/ true, /*isInvariant*/ false,
+                               llvm::MaybeAlign());
 }
 
 /// Specialized emitter for Builtin.destroy.

test/IRGen/builtins.swift

@@ -97,7 +97,7 @@ func load_test(_ ptr: Builtin.RawPointer) -> Builtin.Int64 {
 // CHECK: define hidden {{.*}}i64 @"$s8builtins13load_raw_test{{[_0-9a-zA-Z]*}}F"
 func load_raw_test(_ ptr: Builtin.RawPointer) -> Builtin.Int64 {
   // CHECK: [[CASTPTR:%.*]] = bitcast i8* [[PTR:%.*]] to i64*
-  // CHECK-NEXT: load i64, i64* [[CASTPTR]]
+  // CHECK-NEXT: load i64, i64* [[CASTPTR]], align 1
   // CHECK: ret
   return Builtin.loadRaw(ptr)
 }
@@ -118,7 +118,7 @@ func load_object_test(_ ptr: Builtin.RawPointer) -> Builtin.NativeObject {
 
 // CHECK: define hidden {{.*}}%swift.refcounted* @"$s8builtins20load_raw_object_test{{[_0-9a-zA-Z]*}}F"
 func load_raw_object_test(_ ptr: Builtin.RawPointer) -> Builtin.NativeObject {
-  // CHECK: [[T0:%.*]] = load [[REFCOUNT]]*, [[REFCOUNT]]**
+  // CHECK: [[T0:%.*]] = load [[REFCOUNT]]*, [[REFCOUNT]]** %{{.*}}, align 1
   // CHECK: call [[REFCOUNT]]* @swift_retain([[REFCOUNT]]* returned [[T0]])
   // CHECK: ret [[REFCOUNT]]* [[T0]]
   return Builtin.loadRaw(ptr)

test/SILGen/builtins.swift

@@ -33,15 +33,15 @@ func load_obj(_ x: Builtin.RawPointer) -> Builtin.NativeObject {
 
 // CHECK-LABEL: sil hidden [ossa] @$s8builtins12load_raw_pod{{[_0-9a-zA-Z]*}}F
 func load_raw_pod(_ x: Builtin.RawPointer) -> Builtin.Int64 {
-  // CHECK: [[ADDR:%.*]] = pointer_to_address {{%.*}} to $*Builtin.Int64
+  // CHECK: [[ADDR:%.*]] = pointer_to_address {{%.*}} to [align=1] $*Builtin.Int64
   // CHECK: [[VAL:%.*]] = load [trivial] [[ADDR]]
   // CHECK: return [[VAL]]
   return Builtin.loadRaw(x)
 }
 
 // CHECK-LABEL: sil hidden [ossa] @$s8builtins12load_raw_obj{{[_0-9a-zA-Z]*}}F
 func load_raw_obj(_ x: Builtin.RawPointer) -> Builtin.NativeObject {
-  // CHECK: [[ADDR:%.*]] = pointer_to_address {{%.*}} to $*Builtin.NativeObject
+  // CHECK: [[ADDR:%.*]] = pointer_to_address {{%.*}} to [align=1] $*Builtin.NativeObject
   // CHECK: [[VAL:%.*]] = load [copy] [[ADDR]]
   // CHECK: return [[VAL]]
   return Builtin.loadRaw(x)