IRGen: Let the stride of a type be at least one, even for zero-sized types like the empty tuple.

This affects the computed stride for fixed-sized types in IRGen as well as the stored stride in value witness tables.
The reason is to let comparisons and difference operations work for pointers to zero-sized types.
(Currently this is achieved by using Builtin.strideof_nonzero in MemoryLayout.stride, but this requires a std::max(1, stride) operation after loading the stride)

Author: eeckstein

lib/IRGen/FixedTypeInfo.h

@@ -120,8 +120,13 @@ class FixedTypeInfo : public TypeInfo {
   /// object.  The stride is the storage size rounded up to the
   /// alignment; its practical use is that, in an array, it is the
   /// offset from the size of one element to the offset of the next.
+  /// The stride is at least one, even for zero-sized types, like the empty
+  /// tuple.
   Size getFixedStride() const {
-    return StorageSize.roundUpToAlignment(getFixedAlignment());
+    Size s = StorageSize.roundUpToAlignment(getFixedAlignment());
+    if (s.isZero())
+      s = Size(1);
+    return s;
   }
 
   /// Returns the fixed number of "extra inhabitants" (that is, bit

lib/IRGen/ValueWitness.h

@@ -228,7 +228,8 @@ enum class ValueWitness : unsigned {
 
   ///   size_t stride;
   ///
-  /// The required size per element of an array of this type.
+  /// The required size per element of an array of this type. It is at least
+  /// one, even for zero-sized types, like the empty tuple.
   Stride,
 
   Last_RequiredValueWitness = Stride,

stdlib/public/Reflection/TypeLowering.cpp

@@ -421,6 +421,8 @@ const RecordTypeInfo *RecordTypeInfoBuilder::build() {
 
   // Calculate the stride
   unsigned Stride = ((Size + Alignment - 1) & ~(Alignment - 1));
+  if (Stride == 0)
+    Stride = 1;
 
   return TC.makeTypeInfo<RecordTypeInfo>(
       Size, Alignment, Stride,
@@ -528,7 +530,7 @@ const TypeInfo *TypeConverter::getEmptyTypeInfo() {
   if (EmptyTI != nullptr)
     return EmptyTI;
 
-  EmptyTI = makeTypeInfo<TypeInfo>(TypeInfoKind::Builtin, 0, 1, 0, 0);
+  EmptyTI = makeTypeInfo<TypeInfo>(TypeInfoKind::Builtin, 0, 1, 1, 0);
   return EmptyTI;
 }
 
@@ -962,6 +964,8 @@ class EnumTypeInfoBuilder {
 
     // Calculate the stride
     unsigned Stride = ((Size + Alignment - 1) & ~(Alignment - 1));
+    if (Stride == 0)
+      Stride = 1;
 
     return TC.makeTypeInfo<RecordTypeInfo>(
         Size, Alignment, Stride,

stdlib/public/runtime/Enum.cpp

@@ -102,7 +102,8 @@ swift::swift_initEnumValueWitnessTableSinglePayload(ValueWitnessTable *vwtable,
     .withExtraInhabitants(unusedExtraInhabitants > 0)
     .withEnumWitnesses(true)
     .withInlineStorage(ValueWitnessTable::isValueInline(size, align));
-  vwtable->stride = llvm::alignTo(size, align);
+  auto rawStride = llvm::alignTo(size, align);
+  vwtable->stride = rawStride == 0 ? 1 : rawStride;
 
   // Substitute in better common value witnesses if we have them.
   // If the payload type is a single-refcounted pointer, and the enum has
@@ -310,7 +311,8 @@ swift::swift_initEnumMetadataMultiPayload(ValueWitnessTable *vwtable,
     .withEnumWitnesses(true)
     .withInlineStorage(ValueWitnessTable::isValueInline(totalSize, alignMask+1))
     ;
-  vwtable->stride = (totalSize + alignMask) & ~alignMask;
+  auto rawStride = (totalSize + alignMask) & ~alignMask;
+  vwtable->stride = rawStride == 0 ? 1 : rawStride;
 
   installCommonValueWitnesses(vwtable);
 }

stdlib/public/runtime/ExistentialMetadataImpl.h

@@ -214,8 +214,9 @@ struct LLVM_LIBRARY_VISIBILITY NonFixedOpaqueExistentialBox
       return std::max(alignof(void*), alignof(ValueBuffer));
     }
     static size_t getSize(unsigned numWitnessTables) {
-      return sizeof(OpaqueExistentialContainer)
-           + numWitnessTables * sizeof(void*);
+      constexpr size_t base = sizeof(OpaqueExistentialContainer);
+      static_assert(base > 0, "stride needs base size > 0");
+      return base + numWitnessTables * sizeof(void*);
     }
     static size_t getStride(unsigned numWitnessTables) {
       return getSize(numWitnessTables);
@@ -348,8 +349,9 @@ struct LLVM_LIBRARY_VISIBILITY NonFixedClassExistentialBox
       return alignof(void*);
     }
     static size_t getSize(unsigned numWitnessTables) {
-      return sizeof(ClassExistentialContainer)
-             + numWitnessTables * sizeof(void*);
+      constexpr size_t base = sizeof(ClassExistentialContainer);
+      static_assert(base > 0, "stride needs base size > 0");
+      return base + numWitnessTables * sizeof(void*);
     }
     static size_t getStride(unsigned numWitnessTables) {
       return getSize(numWitnessTables);
@@ -469,8 +471,9 @@ struct LLVM_LIBRARY_VISIBILITY NonFixedExistentialMetatypeBox
       return alignof(void*);
     }
     static size_t getSize(unsigned numWitnessTables) {
-      return sizeof(ExistentialMetatypeContainer)
-             + numWitnessTables * sizeof(void*);
+      constexpr size_t base = sizeof(ExistentialMetatypeContainer);
+      static_assert(base > 0, "stride needs base size > 0");
+      return base + numWitnessTables * sizeof(void*);
     }
     static size_t getStride(unsigned numWitnessTables) {
       return getSize(numWitnessTables);

stdlib/public/runtime/Metadata.cpp

@@ -982,7 +982,7 @@ void performBasicLayout(BasicLayout &layout,
                                     .withPOD(isPOD)
                                     .withBitwiseTakable(isBitwiseTakable)
                                     .withInlineStorage(isInline);
-  layout.stride = roundUpToAlignMask(size, alignMask);
+  layout.stride = std::max(size_t(1), roundUpToAlignMask(size, alignMask));
 }
 } // end anonymous namespace
 

stdlib/public/runtime/MetadataImpl.h

@@ -643,7 +643,9 @@ struct AggregateBox {
   using Helper = AggregateBoxHelper<0, EltBoxes...>;
   static constexpr size_t size = Helper::endOffset;
   static constexpr size_t alignment = Helper::alignment;
-  static constexpr size_t stride = roundUpToAlignment(size, alignment);
+  static constexpr size_t rawStride = roundUpToAlignment(size, alignment);
+  static constexpr size_t stride = rawStride == 0 ? 1 : rawStride;
+
   static constexpr bool isPOD = Helper::isPOD;
   static constexpr bool isBitwiseTakable = Helper::isBitwiseTakable;
 

test/IRGen/indexing.sil

@@ -31,6 +31,16 @@ entry(%p : $*DifferentSizeStride, %i: $Builtin.Word):
   return undef : $()
 }
 
+// CHECK:      define{{( protected)?}} void @zero_size(%swift.opaque* noalias nocapture, i64) {{.*}} {
+// CHECK:        %2 = bitcast %swift.opaque* %0 to i8*
+// CHECK-NEXT:   %3 = mul nsw i64 %1, 1
+// CHECK-NEXT:   %4 = getelementptr inbounds i8, i8* %2, i64 %3
+sil @zero_size : $@convention(thin) (@in (), Builtin.Word) -> () {
+entry(%p : $*(), %i: $Builtin.Word):
+  %q = index_addr %p : $*(), %i : $Builtin.Word
+  return undef : $()
+}
+
 // CHECK:      define{{( protected)?}} void @dynamic_size(%swift.opaque* noalias nocapture, i64, %swift.type* %T) {{.*}} {
 // CHECK:        %3 = bitcast %swift.type* %T to i8***
 // CHECK-NEXT:   %4 = getelementptr inbounds i8**, i8*** %3, i64 -1

test/IRGen/zero_size_types.swift

@@ -0,0 +1,69 @@
+// RUN: rm -rf %t && mkdir -p %t
+// RUN: %target-build-swift -Xllvm -sil-disable-pass="Generic Specializer" %s -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+// REQUIRES: executable_test
+
+public struct EmptyStruct {
+}
+
+public enum SingleCaseEnum {
+  case A
+}
+
+public struct GenStruct<T> {
+  var t: T
+}
+
+@inline(never)
+func fail() {
+  fatalError("size/stride mismatch")
+}
+
+@inline(never)
+public func testit<T>(_ t: T) {
+  if MemoryLayout<T>.size != 0 {
+    fail()
+  }
+  if MemoryLayout<T>.stride != 1 {
+    fail()
+  }
+  if MemoryLayout<GenStruct<T>>.size != 0 {
+    fail()
+  }
+  if MemoryLayout<GenStruct<T>>.stride != 1 {
+    fail()
+  }
+}
+
+// Test size and stride which are loaded from the value witness tables.
+
+testit(EmptyStruct())
+testit(())
+testit(SingleCaseEnum.A)
+
+// Test size and stride which are computed as constants in IRGen.
+
+if MemoryLayout<()>.size != 0 {
+  fail()
+}
+if MemoryLayout<()>.stride != 1 {
+  fail()
+}
+
+if MemoryLayout<EmptyStruct>.size != 0 {
+  fail()
+}
+if MemoryLayout<EmptyStruct>.stride != 1 {
+  fail()
+}
+
+if MemoryLayout<SingleCaseEnum>.size != 0 {
+  fail()
+}
+if MemoryLayout<SingleCaseEnum>.stride != 1 {
+  fail()
+}
+
+// CHECK: success
+print("success")
+

test/Reflection/typeref_lowering.swift

@@ -594,7 +594,7 @@ V12TypeLowering14MetatypeStruct
 // CHECK-64-NEXT:           (field name=wtable offset=16
 // CHECK-64-NEXT:             (builtin size=8 alignment=8 stride=8 num_extra_inhabitants=1))))))
 // CHECK-64-NEXT:   (field name=structMetatype offset=112
-// CHECK-64-NEXT:     (builtin size=0 alignment=1 stride=0 num_extra_inhabitants=0))
+// CHECK-64-NEXT:     (builtin size=0 alignment=1 stride=1 num_extra_inhabitants=0))
 // CHECK-64-NEXT:   (field name=optionalStructMetatype offset=112
 // CHECK-64-NEXT:     (single_payload_enum size=8 alignment=8 stride=8 num_extra_inhabitants=[[PTR_XI_SUB_1]]
 // CHECK-64-NEXT:       (field name=some offset=0
@@ -667,7 +667,7 @@ V12TypeLowering14MetatypeStruct
 // CHECK-32-NEXT:           (field name=wtable offset=8
 // CHECK-32-NEXT:             (builtin size=4 alignment=4 stride=4 num_extra_inhabitants=1))))))
 // CHECK-32-NEXT:   (field name=structMetatype offset=56
-// CHECK-32-NEXT:     (builtin size=0 alignment=1 stride=0 num_extra_inhabitants=0))
+// CHECK-32-NEXT:     (builtin size=0 alignment=1 stride=1 num_extra_inhabitants=0))
 // CHECK-32-NEXT:   (field name=optionalStructMetatype offset=56
 // CHECK-32-NEXT:     (single_payload_enum size=4 alignment=4 stride=4 num_extra_inhabitants=4095
 // CHECK-32-NEXT:       (field name=some offset=0
@@ -689,11 +689,11 @@ V12TypeLowering10EnumStruct
 // CHECK-64: (struct TypeLowering.EnumStruct)
 // CHECK-64-NEXT: (struct size=81 alignment=8 stride=88 num_extra_inhabitants=0
 // CHECK-64-NEXT:   (field name=empty offset=0
-// CHECK-64-NEXT:     (no_payload_enum size=0 alignment=0 stride=0 num_extra_inhabitants=0))
+// CHECK-64-NEXT:     (no_payload_enum size=0 alignment=0 stride=1 num_extra_inhabitants=0))
 // CHECK-64-NEXT:   (field name=noPayload offset=0
-// CHECK-64-NEXT:     (no_payload_enum size=1 alignment=0 stride=0 num_extra_inhabitants=0))
+// CHECK-64-NEXT:     (no_payload_enum size=1 alignment=0 stride=1 num_extra_inhabitants=0))
 // CHECK-64-NEXT:   (field name=sillyNoPayload offset=0
-// CHECK-64-NEXT:     (no_payload_enum size=1 alignment=0 stride=0 num_extra_inhabitants=0))
+// CHECK-64-NEXT:     (no_payload_enum size=1 alignment=0 stride=1 num_extra_inhabitants=0))
 // CHECK-64-NEXT:   (field name=singleton offset=8
 // CHECK-64-NEXT:     (reference kind=strong refcounting=native))
 // CHECK-64-NEXT:   (field name=singlePayload offset=16