Emit call to old initialization function for older OSes

Add test

Update raw_layout.swift

Update raw_layout.swift

Author: Azoy

include/swift/AST/ASTContext.h

@@ -937,6 +937,10 @@ class ASTContext final {
   /// descriptors.
   AvailabilityContext getSignedDescriptorAvailability();
 
+  /// Get the runtime availability of the swift_initRawStructMetadata entrypoint
+  /// that fixes up the value witness table of @_rawLayout dependent types.
+  AvailabilityContext getInitRawStructMetadataAvailability();
+
   /// Get the runtime availability of features introduced in the Swift 5.2
   /// compiler for the target platform.
   AvailabilityContext getSwift52Availability();

lib/AST/Availability.cpp

@@ -540,6 +540,11 @@ ASTContext::getSignedDescriptorAvailability() {
   return getSwift59Availability();
 }
 
+AvailabilityContext
+ASTContext::getInitRawStructMetadataAvailability() {
+  return getSwiftFutureAvailability();
+}
+
 AvailabilityContext ASTContext::getSwift52Availability() {
   auto target = LangOpts.Target;
 

lib/IRGen/GenMeta.cpp

@@ -2983,10 +2983,106 @@ static void emitInitializeFieldOffsetVectorWithLayoutString(
                                 IGM.getPointerSize() * numFields);
 }
 
+static void emitInitializeRawLayoutOld(IRGenFunction &IGF, SILType likeType,
+                                       Size count, SILType T,
+                                       llvm::Value *metadata,
+                                       MetadataDependencyCollector *collector) {
+  auto &IGM = IGF.IGM;
+
+  // This is the list of field type layouts that we're going to pass to the init
+  // function. This will only ever hold 1 field which is the temporary one we're
+  // going to build up from our like type's layout.
+  auto fieldLayouts = IGF.createAlloca(
+                          llvm::ArrayType::get(IGM.TypeLayoutTy->getPointerTo(), 1),
+                          IGM.getPointerAlignment(), "fieldLayouts");
+  IGF.Builder.CreateLifetimeStart(fieldLayouts, IGM.getPointerSize());
+
+  // We're going to pretend that this is our field offset vector for the init to
+  // write to. We don't actually have fields, so we don't want to write a field
+  // offset in our metadata.
+  auto fieldOffsets = IGF.createAlloca(IGM.Int32Ty, Alignment(4), "fieldOffsets");
+  IGF.Builder.CreateLifetimeStart(fieldOffsets, Size(4));
+
+  // We need to make a temporary type layout with most of the same information
+  // from the type we're like.
+  auto ourTypeLayout = IGF.createAlloca(IGM.TypeLayoutTy, 
+                                        IGM.getPointerAlignment(),
+                                        "ourTypeLayout");
+  IGF.Builder.CreateLifetimeStart(ourTypeLayout, IGM.getPointerSize());
+
+  // Put our temporary type layout in the list of layouts we're using to
+  // initialize.
+  IGF.Builder.CreateStore(ourTypeLayout.getAddress(), fieldLayouts);
+
+  // Get the like type's type layout.
+  auto likeTypeLayout = emitTypeLayoutRef(IGF, likeType, collector);
+
+  // Grab the size, stride, and alignmentMask out of the layout.
+  auto loadedTyLayout = IGF.Builder.CreateLoad(
+      Address(likeTypeLayout, IGM.TypeLayoutTy, IGM.getPointerAlignment()),
+      "typeLayout");
+  auto size = IGF.Builder.CreateExtractValue(loadedTyLayout, 0, "size");
+  auto stride = IGF.Builder.CreateExtractValue(loadedTyLayout, 1, "stride");
+  auto flags = IGF.Builder.CreateExtractValue(loadedTyLayout, 2, "flags");
+  auto xi = IGF.Builder.CreateExtractValue(loadedTyLayout, 3, "xi");
+
+  // This will zero out the other bits.
+  auto alignMask = IGF.Builder.CreateAnd(flags,
+                                         ValueWitnessFlags::AlignmentMask,
+                                         "alignMask");
+
+  // Set the isNonPOD bit. This is important because older runtimes will attempt
+  // to replace various vwt functions with more optimized ones. In this case, we
+  // want to preserve the fact that noncopyable types have unreachable copy vwt
+  // functions.
+  auto vwtFlags = IGF.Builder.CreateOr(alignMask,
+                                       ValueWitnessFlags::IsNonPOD,
+                                       "vwtFlags");
+
+  // Count is only ever -1 if we're not an array like layout.
+  if (count != Size(-1)) {
+    stride = IGF.Builder.CreateMul(stride, IGM.getSize(count));
+    size = stride;
+  }
+
+  llvm::Value *resultAgg = llvm::UndefValue::get(IGM.TypeLayoutTy);
+  resultAgg = IGF.Builder.CreateInsertValue(resultAgg, size, 0);
+  resultAgg = IGF.Builder.CreateInsertValue(resultAgg, stride, 1);
+  resultAgg = IGF.Builder.CreateInsertValue(resultAgg, vwtFlags, 2);
+  resultAgg = IGF.Builder.CreateInsertValue(resultAgg, xi, 3);
+
+  IGF.Builder.CreateStore(resultAgg, ourTypeLayout);
+
+  StructLayoutFlags fnFlags = StructLayoutFlags::Swift5Algorithm;
+
+  // Call swift_initStructMetadata().
+  IGF.Builder.CreateCall(IGM.getInitStructMetadataFunctionPointer(),
+                         {metadata, IGM.getSize(Size(uintptr_t(fnFlags))),
+                          IGM.getSize(Size(1)), fieldLayouts.getAddress(),
+                          fieldOffsets.getAddress()});
+
+  IGF.Builder.CreateLifetimeEnd(ourTypeLayout, IGM.getPointerSize());
+  IGF.Builder.CreateLifetimeEnd(fieldOffsets, Size(4));
+  IGF.Builder.CreateLifetimeEnd(fieldLayouts, IGM.getPointerSize());
+}
+
 static void emitInitializeRawLayout(IRGenFunction &IGF, SILType likeType,
                                     Size count, SILType T,
                                     llvm::Value *metadata,
                                     MetadataDependencyCollector *collector) {
+  // If our deployment target doesn't contain the new swift_initRawStructMetadata,
+  // emit a call to the swift_initStructMetadata tricking it into thinking
+  // we have a single field.
+  auto deploymentAvailability =
+      AvailabilityContext::forDeploymentTarget(IGF.IGM.Context);
+  auto initRawAvail = IGF.IGM.Context.getInitRawStructMetadataAvailability();
+
+  if (!IGF.IGM.Context.LangOpts.DisableAvailabilityChecking &&
+      !deploymentAvailability.isContainedIn(initRawAvail)) {
+    emitInitializeRawLayoutOld(IGF, likeType, count, T, metadata, collector);
+    return;
+  }
+
   auto &IGM = IGF.IGM;
   auto likeTypeLayout = emitTypeLayoutRef(IGF, likeType, collector);
   StructLayoutFlags flags = StructLayoutFlags::Swift5Algorithm;

test/IRGen/raw_layout.swift

@@ -1,6 +1,6 @@
 // RUN: %empty-directory(%t)
 // RUN: %{python} %utils/chex.py < %s > %t/raw_layout.sil
-// RUN: %target-swift-frontend -enable-experimental-feature RawLayout -emit-ir %t/raw_layout.sil | %FileCheck %t/raw_layout.sil --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
+// RUN: %target-swift-frontend -enable-experimental-feature RawLayout -emit-ir -disable-availability-checking %t/raw_layout.sil | %FileCheck %t/raw_layout.sil --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
 
 import Swift
 

test/IRGen/raw_layout_old.swift

@@ -0,0 +1,62 @@
+// RUN: %target-swift-frontend -target %target-cpu-apple-macosx13.0 -enable-experimental-feature RawLayout -emit-ir %s | %FileCheck %s
+
+// REQUIRES: OS=macosx
+
+// Test that when targeting older OSes 
+
+@_rawLayout(like: T)
+struct Cell<T>: ~Copyable {}
+
+@_rawLayout(likeArrayOf: T, count: 1)
+struct PaddedCell<T>: ~Copyable {}
+
+@_rawLayout(likeArrayOf: T, count: 8)
+struct SmallVectorBuf<T>: ~Copyable {}
+
+// Dependent layout metadata initialization:
+
+// Cell<T>
+
+// CHECK-LABEL: define {{.*}} swiftcc %swift.metadata_response @"$s{{[A-Za-z0-9_]*}}4CellVMr"(ptr %"Cell<T>", ptr {{.*}}, ptr {{.*}})
+// CHECK: [[FIELD_LAYOUTS:%.*]] = alloca [1 x ptr]
+// CHECK-NEXT: [[FIELD_OFFSETS:%.*]] = alloca i32, align 4
+// CHECK-NEXT: [[OUR_LAYOUT:%.*]] = alloca %swift.type_layout
+// CHECK: store ptr [[OUR_LAYOUT]], ptr [[FIELD_LAYOUTS]]
+// CHECK-NEXT: [[T_ADDR:%.*]] = getelementptr inbounds ptr, ptr %"Cell<T>", {{i64|i32}} 2
+// CHECK-NEXT: [[T:%.*]] = load ptr, ptr [[T_ADDR]]
+// CHECK-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @swift_checkMetadataState({{i64|i32}} 319, ptr [[T]])
+// CHECK-NEXT: [[T:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0
+// CHECK: [[T_VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[T]], {{i64|i32}} -1
+// CHECK-NEXT: [[T_VWT:%.*]] = load ptr, ptr [[T_VWT_ADDR]]
+// CHECK-NEXT: [[T_LAYOUT:%.*]] = getelementptr inbounds ptr, ptr [[T_VWT]], i32 8
+// CHECK-NEXT: [[T_LAYOUT_LOADED:%.*]] = load %swift.type_layout, ptr [[T_LAYOUT]]
+// CHECK-NEXT: [[T_SIZE:%.*]] = extractvalue %swift.type_layout [[T_LAYOUT_LOADED]], 0
+// CHECK-NEXT: [[T_STRIDE:%.*]] = extractvalue %swift.type_layout [[T_LAYOUT_LOADED]], 1
+// CHECK-NEXT: [[T_FLAGS:%.*]] = extractvalue %swift.type_layout [[T_LAYOUT_LOADED]], 2
+// CHECK-NEXT: [[T_XI:%.*]] = extractvalue %swift.type_layout [[T_LAYOUT_LOADED]], 3
+// CHECK-NEXT: [[T_ALIGNMASK:%.*]] = and i32 [[T_FLAGS]], 255
+// CHECK-NEXT: [[OUR_FLAGS:%.*]] = or i32 [[T_ALIGNMASK]], 65536
+// CHECK-NEXT: [[OUR_LAYOUT_0:%.*]] = insertvalue %swift.type_layout undef, {{i64|i32}} [[T_SIZE]], 0
+// CHECK-NEXT: [[OUR_LAYOUT_1:%.*]] = insertvalue %swift.type_layout [[OUR_LAYOUT_0]], {{i64|i32}} [[T_STRIDE]], 1
+// CHECK-NEXT: [[OUR_LAYOUT_2:%.*]] = insertvalue %swift.type_layout [[OUR_LAYOUT_1]], i32 [[OUR_FLAGS]], 2
+// CHECK-NEXT: [[OUR_LAYOUT_3:%.*]] = insertvalue %swift.type_layout [[OUR_LAYOUT_2]], i32 [[T_XI]], 3
+// CHECK-NEXT: store %swift.type_layout [[OUR_LAYOUT_3]], ptr [[OUR_LAYOUT]]
+// CHECK-NEXT: call void @swift_initStructMetadata(ptr %"Cell<T>", {{i64|i32}} 0, {{i64|i32}} 1, ptr [[FIELD_LAYOUTS]], ptr [[FIELD_OFFSETS]])
+
+// PaddedCell<T>
+
+// CHECK-LABEL: define {{.*}} swiftcc %swift.metadata_response @"$s{{[A-Za-z0-9_]*}}10PaddedCellVMr"(ptr %"PaddedCell<T>", ptr {{.*}}, ptr {{.*}})
+// CHECK: [[T_STRIDE:%.*]] = extractvalue %swift.type_layout {{%.*}}, 1
+// CHECK: [[OUR_STRIDE:%.*]] = mul {{i64|i32}} [[T_STRIDE]], 1
+// CHECK-NEXT: {{%.*}} = insertvalue %swift.type_layout undef, {{i64|i32}} [[OUR_STRIDE]], 0
+// CHECK-NEXT: {{%.*}} = insertvalue %swift.type_layout {{%.*}}, {{i64|i32}} [[OUR_STRIDE]], 1
+// CHECK: call void @swift_initStructMetadata(ptr %"PaddedCell<T>", {{i64|i32}} 0, {{i64|i32}} 1, ptr {{%.*}}, ptr {{%.*}})
+
+// SmallVectorBuf<T>
+
+// CHECK-LABEL: define {{.*}} swiftcc %swift.metadata_response @"$s{{[A-Za-z0-9_]*}}14SmallVectorBufVMr"(ptr %"SmallVectorBuf<T>", ptr {{.*}}, ptr {{.*}})
+// CHECK: [[T_STRIDE:%.*]] = extractvalue %swift.type_layout {{%.*}}, 1
+// CHECK: [[OUR_STRIDE:%.*]] = mul {{i64|i32}} [[T_STRIDE]], 8
+// CHECK-NEXT: {{%.*}} = insertvalue %swift.type_layout undef, {{i64|i32}} [[OUR_STRIDE]], 0
+// CHECK-NEXT: {{%.*}} = insertvalue %swift.type_layout {{%.*}}, {{i64|i32}} [[OUR_STRIDE]], 1
+// CHECK: call void @swift_initStructMetadata(ptr %"SmallVectorBuf<T>", {{i64|i32}} 0, {{i64|i32}} 1, ptr {{%.*}}, ptr {{%.*}})

test/Interpreter/raw_layout.swift

@@ -14,7 +14,8 @@ struct Cell<T>: ~Copyable {
   }
 
   deinit {
-    address.deinitialize(count: 1)
+    // FIXME: discard self should work with rawLayout types
+    //address.deinitialize(count: 1)
 
     // Note: We don't need to deallocate the address here because the memory it
     // points to is being destroyed within this deinit.
@@ -58,14 +59,11 @@ do {
 
   let specialInt0Again = cell0.replace(with: SpecialInt(316))
 
-  // CHECK: Deinitializing 128!
-  _ = consume specialInt0Again
-
   // CHECK: Deinitializing 316!
   cell0.set(SpecialInt(592))
 
   let specialInt1 = cell0.get()
 
   // CHECK: Deinitializing 592!
-  _ = consume specialInt1
+  // CHECK: Deinitializing 128!
 }