SwiftCC: Perform physical layout when computing coercion types

[aschwaighofer]

Summary

We need to take type alignment padding into account whe computing physical
layouts.

The layout must be compatible with the input layout, offsets are defined in
terms of offsets within a packed struct which are computed in terms of the alloc
size of a type.

Using the store size we would insert padding for the following type for example:

struct {

int3 v;
long long l;

} __attribute((packed))

On x86-64 int3 is padded to int4 alignment. The swiftcc type would be
<{ <3 x float>, [4 x i8], i64 }> which is not compatible with <{ <3 x float>,
i64 }>.

The latter has i64 at offset 16 and the former at offset 20.

rdar://32618125

[aschwaighofer]

Based on email conversation with John. He pointed out we purposely don't want to use the allocation size for the algorithm and that we can just use LLVM's layout when we compute the coercion types.

[aschwaighofer]

Same patch bug with added diff context.

[rjmccall]

Looks great, thanks!

lib/CodeGen/SwiftCallingConv.cpp

static llvm::Type *getCommonType(llvm::Type *first, llvm::Type *second) {
 
   return nullptr;
 }
 
 static CharUnits getTypeStoreSize(CodeGenModule &CGM, llvm::Type *type) {
   return CharUnits::fromQuantity(CGM.getDataLayout().getTypeStoreSize(type));
 }
 
+static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type) {
+  return CharUnits::fromQuantity(CGM.getDataLayout().getTypeAllocSize(type));
+}
+
 void SwiftAggLowering::addTypedData(QualType type, CharUnits begin) {
   // Deal with various aggregate types as special cases:
 
   // Record types.
   if (auto recType = type->getAs<RecordType>()) {
     addTypedData(recType->getDecl(), begin);
 
   // Array types.
for (auto &entry : Entries) {
     }
 
     if (!packed && !entry.Begin.isMultipleOf(
           CharUnits::fromQuantity(
             CGM.getDataLayout().getABITypeAlignment(entry.Type))))
       packed = true;
 
     elts.push_back(entry.Type);
-    lastEnd = entry.End;
+
+    lastEnd = entry.Begin + getTypeAllocSize(CGM, entry.Type);
+    assert(entry.End <= lastEnd);
   }
 
   // We don't need to adjust 'packed' to deal with possible tail padding
   // because we never do that kind of access through the coercion type.
   auto coercionType = llvm::StructType::get(ctx, elts, packed);
 
   llvm::Type *unpaddedType = coercionType;
   if (hasPadding) {

test/CodeGen/64bit-swiftcall.c

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -target-cpu core2 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -target-cpu core2 -emit-llvm -o - %s | FileCheck %s --check-prefix=X86-64
 // RUN: %clang_cc1 -triple arm64-apple-ios9 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple arm64-apple-ios9 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s --check-prefix=ARM64
 
 // REQUIRES: aarch64-registered-target,x86-registered-target
 
 #define SWIFTCALL __attribute__((swiftcall))
 #define OUT __attribute__((swift_indirect_result))
 #define ERROR __attribute__((swift_error_result))

 // CHECK: define swiftcc void @take_union_het_vecint([[UNION]]*
 
 typedef struct {
   float3 f3;
 } struct_v1f3;
 TEST(struct_v1f3)
 // ARM64-LABEL: define swiftcc { <2 x float>, float } @return_struct_v1f3()
 // ARM64-LABEL: define swiftcc void @take_struct_v1f3(<2 x float>, float)
+
+typedef struct {
+  int3 vect;
+  unsigned long long val;
+} __attribute__((packed)) padded_alloc_size_vector;
+TEST(padded_alloc_size_vector)
+// X86-64-LABEL: take_padded_alloc_size_vector(<3 x i32>, i64)
+// X86-64-NOT: [4 x i8]
+// x86-64: ret void
+
+typedef union {
+  float f1;
+  float3 fv2;
+} union_hom_fp_partial2;
+TEST(union_hom_fp_partial2)
+// X86-64-LABEL: take_union_hom_fp_partial2(i64, float)
+// ARM64-LABEL: take_union_hom_fp_partial2(i64, float)