Partial revert of d16fba3 to fix ldc-developers#4719 and fix ldc-deve…

…lopers#4734

ir/irtypeaggr.cpp

@@ -40,11 +40,7 @@ AggrTypeBuilder::AggrTypeBuilder(unsigned offset) : m_offset(offset) {
 void AggrTypeBuilder::addType(llvm::Type *type, unsigned size) {
   const unsigned fieldAlignment = getABITypeAlign(type);
   assert(fieldAlignment);
-  // If the field offset does not have natural alignment, mark the aggregate as
-  // packed for IR.
-  if ((m_offset & (fieldAlignment - 1)) != 0) {
-    m_packed = true;
-  }
+  assert((m_offset & (fieldAlignment - 1)) == 0 && "Field is misaligned");
   m_defaultTypes.push_back(type);
   m_offset += size;
   m_fieldIndex++;
@@ -279,6 +275,41 @@ IrTypeAggr::IrTypeAggr(AggregateDeclaration *ad)
              LLStructType::create(gIR->context(), ad->toPrettyChars())),
       aggr(ad) {}
 
+bool IrTypeAggr::isPacked(AggregateDeclaration *ad) {
+  // If the aggregate's size is unknown, any field with type alignment > 1 will
+  // make it packed.
+  unsigned aggregateSize = ~0u;
+  unsigned aggregateAlignment = 1;
+  if (ad->sizeok == Sizeok::done) {
+    aggregateSize = ad->structsize;
+    aggregateAlignment = ad->alignsize;
+
+    if (auto sd = ad->isStructDeclaration()) {
+      if (!sd->alignment.isDefault() && !sd->alignment.isPack())
+        aggregateAlignment = sd->alignment.get();
+    }
+  }
+
+  // Classes apparently aren't padded; their size may not match the alignment.
+  assert((ad->isClassDeclaration() ||
+          (aggregateSize & (aggregateAlignment - 1)) == 0) &&
+         "Size not a multiple of alignment?");
+
+  // For unions, only a subset of the fields are actually used for the IR type -
+  // don't care (about a few potentially needlessly packed IR structs).
+  for (const auto field : ad->fields) {
+    // The aggregate size, aggregate alignment and the field offset need to be
+    // multiples of the field type's alignment, otherwise the aggregate type is
+    // unnaturally aligned, and LLVM would insert padding.
+    const unsigned fieldTypeAlignment = DtoAlignment(field->type);
+    const auto mask = fieldTypeAlignment - 1;
+    if ((aggregateSize | aggregateAlignment | field->offset) & mask)
+      return true;
+  }
+
+  return false;
+}
+
 unsigned IrTypeAggr::getMemberLocation(VarDeclaration *var, bool& isFieldIdx) const {
   // Note: The interface is a bit more general than what we actually return.
   // Specifically, the frontend offset information we use for overlapping

ir/irtypeaggr.h

@@ -78,6 +78,10 @@ class IrTypeAggr : public IrType {
   ///
   explicit IrTypeAggr(AggregateDeclaration *ad);
 
+  /// Returns true, if the LLVM struct type for the aggregate must be declared
+  /// as packed.
+  static bool isPacked(AggregateDeclaration *ad);
+
   /// AggregateDeclaration this type represents.
   AggregateDeclaration *aggr = nullptr;
 

ir/irtypestruct.cpp

@@ -89,7 +89,8 @@ IrTypeStruct *IrTypeStruct::get(StructDeclaration *sd) {
     AggrTypeBuilder builder;
     builder.addAggregate(sd);
     builder.addTailPadding(sd->structsize);
-    isaStruct(t->type)->setBody(builder.defaultTypes(), builder.isPacked());
+    bool packed = builder.isPacked() || IrTypeAggr::isPacked(sd);
+    isaStruct(t->type)->setBody(builder.defaultTypes(), packed);
     t->varGEPIndices = builder.varGEPIndices();
   }
 

tests/codegen/gh4719.d

@@ -0,0 +1,32 @@
+// RUN: %ldc -c -output-ll -of=%t.ll %s
+
+struct TraceBuf {
+    align(1) uint args;
+}
+
+// Test correct compilation (no error) of the context pointer type for the delegate of `foo`.
+void foo() {
+    byte[2] fixDescs;
+    TraceBuf fixLog;
+
+    auto dlg = delegate() {
+        fixDescs[0] = 1;
+        fixLog.args = 1;
+    };
+}
+
+class TraceClass {
+    align(1)
+    uint args;
+}
+
+// Test correct compilation (no error) of the context pointer type for the delegate of `foo2`.
+void foo2() {
+    byte[2] fixDescs;
+    scope TraceClass fixLog;
+
+    auto dlg = delegate() {
+        fixDescs[0] = 1;
+        fixLog.args = 1;
+    };
+}

tests/compilable/gh4734.d

@@ -0,0 +1,20 @@
+// RUN: %ldc -c %s
+
+align(1) struct Item {
+    KV v;
+    uint i;
+}
+
+struct KV {
+    align(1) S* s;
+    uint k;
+}
+
+struct S {
+    Table table;
+}
+
+struct Table {
+    char a;
+    Item v;
+}