Project a non-fixed-size initial element using a bitcast instead

of a GEP.

LLVM does not permit GEPs over unsized types, even if the index
is a constant zero.

This makes simple code involving generic tuples work.

Swift SVN r4969

Author: rjmccall

Diff for: lib/IRGen/StructLayout.cpp

@@ -137,6 +137,11 @@ Address ElementLayout::project(IRGenFunction &IGF, Address baseAddr,
     return IGF.emitByteOffsetGEP(baseAddr.getAddress(), offset, getType(),
                                  baseAddr.getAddress()->getName() + suffix);
   }
+
+  case Kind::InitialNonFixedSize:
+    return IGF.Builder.CreateBitCast(baseAddr,
+                                 getType().getStorageType()->getPointerTo(),
+                                 baseAddr.getAddress()->getName() + suffix);
   }
   llvm_unreachable("bad element layout kind");
 }
@@ -239,7 +244,7 @@ void StructLayoutBuilder::addNonFixedSizeElement(ElementLayout &elt) {
   // structure, we can assign it a fixed offset (namely zero) despite
   // it not having a fixed size/alignment.
   if (isFixedLayout() && CurSize.isZero()) {
-    addElementAtFixedOffset(elt);
+    addNonFixedSizeElementAtOffsetZero(elt);
     IsFixedLayout = false;
     return;
   }
@@ -277,6 +282,19 @@ void StructLayoutBuilder::addElementAtNonFixedOffset(ElementLayout &elt) {
                        NextNonFixedOffsetIndex);
 }
 
+/// Add a non-fixed-size element to the aggregate at offset zero.
+void StructLayoutBuilder::addNonFixedSizeElementAtOffsetZero(ElementLayout &elt) {
+  assert(isFixedLayout());
+  assert(!isa<FixedTypeInfo>(elt.getType()));
+  assert(CurSize.isZero());
+  elt.completeInitialNonFixedSize(elt.getType().isPOD(ResilienceScope::Local));
+
+  // Add the storage type to make the type unsized.  We can't GEP to
+  // this element, though, because LLVM forbids even 'gep 0' on an
+  // unsized type.
+  StructFields.push_back(elt.getType().getStorageType());
+}
+
 /// Produce the current fields as an anonymous structure.
 llvm::StructType *StructLayoutBuilder::getAsAnonStruct() const {
   return llvm::StructType::get(IGM.getLLVMContext(), StructFields);

Diff for: lib/IRGen/StructLayout.h

@@ -89,11 +89,16 @@ class ElementLayout {
 
     /// The element cannot be positioned at a fixed offset within the
     /// aggregate.
-    NonFixed
+    NonFixed,
+
+    /// The element is an object lacking a fixed size but located at
+    /// offset zero.  This is necessary because LLVM forbids even a
+    /// 'gep 0' on an unsized type.
+    InitialNonFixedSize
   };
 
 private:
-  enum : unsigned { IncompleteKind  = 3 };
+  enum : unsigned { IncompleteKind  = 4 };
 
   /// The swift type information for this element.
   const TypeInfo *Type;
@@ -103,14 +108,14 @@ class ElementLayout {
 
   /// The index of this element, either in the LLVM struct (if fixed)
   /// or in the non-fixed elements array (if non-fixed).
-  unsigned Index : 29;
+  unsigned Index : 28;
 
   /// Whether this element is known to be POD in the local resilience
   /// domain.
   unsigned IsPOD : 1;
 
   /// The kind of layout performed for this element.
-  unsigned TheKind : 2;
+  unsigned TheKind : 3;
 
   explicit ElementLayout(const TypeInfo &type)
     : Type(&type), TheKind(IncompleteKind) {}
@@ -138,6 +143,12 @@ class ElementLayout {
     Index = 0; // make a complete write of the bitfield
   }
 
+  void completeInitialNonFixedSize(IsPOD_t isPOD) {
+    TheKind = unsigned(Kind::InitialNonFixedSize);
+    IsPOD = unsigned(isPOD);
+    Index = 0; // make a complete write of the bitfield
+  }
+
   void completeFixed(IsPOD_t isPOD, Size byteOffset, unsigned structIndex) {
     TheKind = unsigned(Kind::Fixed);
     IsPOD = unsigned(isPOD);
@@ -257,6 +268,7 @@ class StructLayoutBuilder {
 
   void addElementAtFixedOffset(ElementLayout &elt);
   void addElementAtNonFixedOffset(ElementLayout &elt);
+  void addNonFixedSizeElementAtOffsetZero(ElementLayout &elt);
 };
 
 /// A struct layout is the result of laying out a complete structure.

Diff for: test/IRGen/generic_tuples.swift

@@ -0,0 +1,46 @@
+// RUN: %swift -triple x86_64-apple-darwin10 -emit-llvm %s | FileCheck %s
+
+// CHECK: [[OPAQUE:%swift.opaque]] = type opaque
+// CHECK: [[TYPE:%swift.type]] = type {
+// CHECK: [[TUPLE_TYPE:%swift.tuple_type]] = type { [[TYPE]], i64, i8*, [0 x %swift.tuple_element_type] }
+// CHECK: %swift.tuple_element_type = type { [[TYPE]]*, i64 }
+
+func dup<T>(x : T) -> (T, T) { return (x,x) }
+// CHECK:    define void @_T14generic_tuples3dupU__FT1xQ__TQ_Q__({ [[OPAQUE]] }* noalias sret
+// CHECK:      [[ELTS:%.*]] = alloca [2 x [[TYPE]]*], align 8
+//   Get value witnesses for T.
+// CHECK-NEXT: [[T0:%.*]] = bitcast [[TYPE]]* %T to i8***
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8*** [[T0]], i64 -1
+// CHECK-NEXT: %T.value = load i8*** [[T1]], align 8
+//   Project to first element of tuple.
+// CHECK-NEXT: [[FST:%.*]] = bitcast { [[OPAQUE]] }* [[RET:%.*]] to [[OPAQUE]]*
+//   Get the tuple metadata.
+//   FIXME: maybe this should get passed in?
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x [[TYPE]]*]* [[ELTS]], i32 0, i32 0
+// CHECK-NEXT: store [[TYPE]]* %T, [[TYPE]]** [[T0]], align 8
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [2 x [[TYPE]]*]* [[ELTS]], i32 0, i32 1
+// CHECK-NEXT: store [[TYPE]]* %T, [[TYPE]]** [[T1]], align 8
+// CHECK-NEXT: [[TT_PAIR:%.*]] = call [[TYPE]]* @swift_getTupleTypeMetadata(i64 2, [[TYPE]]** [[T0]], i8* null, i8** null)
+//   Pull out the offset of the second element and GEP to that.
+// CHECK-NEXT: [[T0:%.*]] = bitcast [[TYPE]]* [[TT_PAIR]] to [[TUPLE_TYPE]]*
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[TUPLE_TYPE]]* [[T0]], i64 0, i32 3, i64 1, i32 1
+// CHECK-NEXT: [[T2:%.*]] = load i64* [[T1]], align 8
+// CHECK-NEXT: [[T3:%.*]] = bitcast { [[OPAQUE]] }* [[RET]] to i8*
+// CHECK-NEXT: [[T4:%.*]] = getelementptr inbounds i8* [[T3]], i64 [[T2]]
+// CHECK-NEXT: [[SND:%.*]] = bitcast i8* [[T4]] to [[OPAQUE]]*
+//   Copy 'x' into the first element.
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds i8** %T.value, i32 6
+// CHECK-NEXT: [[T1:%.*]] = load i8** [[T0]], align 8
+// CHECK-NEXT: [[COPY_FN:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]* ([[OPAQUE]]*, [[OPAQUE]]*, [[TYPE]]*)*
+// CHECK-NEXT: call [[OPAQUE]]* [[COPY_FN]]([[OPAQUE]]* [[FST]], [[OPAQUE]]* [[X:%.*]], [[TYPE]]* %T)
+//   Copy 'x' into the second element.
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds i8** %T.value, i32 6
+// CHECK-NEXT: [[T1:%.*]] = load i8** [[T0]], align 8
+// CHECK-NEXT: [[COPY_FN:%.*]] = bitcast i8* [[T1]] to [[OPAQUE]]* ([[OPAQUE]]*, [[OPAQUE]]*, [[TYPE]]*)*
+// CHECK-NEXT: call [[OPAQUE]]* [[COPY_FN]]([[OPAQUE]]* [[SND]], [[OPAQUE]]* [[X]], [[TYPE]]* %T)
+//   Destroy 'x'.
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds i8** %T.value, i32 4
+// CHECK-NEXT: [[T1:%.*]] = load i8** [[T0]], align 8
+// CHECK-NEXT: [[DESTROY_FN:%.*]] = bitcast i8* [[T1]] to void ([[OPAQUE]]*, [[TYPE]]*)*
+// CHECK-NEXT: call void [[DESTROY_FN]]([[OPAQUE]]* [[X]], [[TYPE]]* %T)
+// CHECK-NEXT: ret void