[clang] 24a37c2 - [CIR] Add unadjusted align to the CIR record layout (#238913)

via cfe-commits cfe-commits at lists.llvm.org
Thu Nov 5 15:52:54 PST 2026


Author: Andy Kaylor
Date: 2026-11-05T15:52:50-08:00
New Revision: 24a37c25603c79f7221b22ff8f98eefc23d7ce95

URL: https://github.com/llvm/llvm-project/commit/24a37c25603c79f7221b22ff8f98eefc23d7ce95
DIFF: https://github.com/llvm/llvm-project/commit/24a37c25603c79f7221b22ff8f98eefc23d7ce95.diff

LOG: [CIR] Add unadjusted align to the CIR record layout (#238913)

The unadjusted align of a record (the alignment calculated by the AST
before adjustments such as attributes are applied) is needed to perform
ABI classification for AArch64 targets. This change adds this field to
the CIR RecordLayoutAttr but does not yet enable the AArch64 calling
convention lowering. That will be done in a future change.

Assisted-by: Cursor / various models

Added: 
    clang/test/CIR/IR/record-layout.cir

Modified: 
    clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
    clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp
    clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
    clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp
    clang/test/CIR/CodeGen/record-type-metadata.cpp
    clang/test/CIR/IR/invalid-record-layout.cir
    clang/unittests/CIR/RecordTypeMetadataTest.cpp

Removed: 
    


################################################################################
diff  --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
index 4be903d337675f..38af2fbfae4b42 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
@@ -171,11 +171,14 @@ def CIR_ArgPassingKind : CIR_I32Enum<
 ]>;
 
 def CIR_RecordLayoutAttr : CIR_Attr<"RecordLayout", "record_layout", [
-    // record_align is consumed as an llvm::Align, whose constructor asserts a
-    // non-zero power of two.
+    // Both alignments are consumed as llvm::Align, whose constructor asserts
+    // a non-zero power of two.
     PredAttrTrait<"record_align must be a non-zero power of two",
                   CPred<"$record_align != 0 && "
-                        "::llvm::isPowerOf2_64($record_align)">>
+                        "::llvm::isPowerOf2_64($record_align)">>,
+    PredAttrTrait<"unadjusted_align must be a non-zero power of two",
+                  CPred<"$unadjusted_align != 0 && "
+                        "::llvm::isPowerOf2_64($unadjusted_align)">>
   ]> {
   let summary = "ABI layout metadata for a record type";
   let description = [{
@@ -190,6 +193,10 @@ def CIR_RecordLayoutAttr : CIR_Attr<"RecordLayout", "record_layout", [
     - `record_align_in_bytes`: from `ASTRecordLayout::getAlignment()`.
       Needed because CIR's DataLayout cannot account for
       `__attribute__((aligned(N)))`.
+    - `unadjusted_align`: the alignment the members give the record before an
+      alignment attribute on the record raises it.  AAPCS64 sizes argument slots
+      using this alignment.  This field is not printed when it is equal to
+      `record_align`.
     - `transparent_union`: whether the record is a union with
       `__attribute__((transparent_union))`, which is passed as its first
       member.  False, the default, is omitted from the printed form.
@@ -215,6 +222,7 @@ def CIR_RecordLayoutAttr : CIR_Attr<"RecordLayout", "record_layout", [
     EnumParameter<CIR_ArgPassingKind>:$arg_passing_kind,
     "bool":$has_trivial_dtor,
     "uint64_t":$record_align,
+    "uint64_t":$unadjusted_align,
     DefaultValuedParameter<"bool", "false">:$transparent_union
   );
 
@@ -223,18 +231,13 @@ def CIR_RecordLayoutAttr : CIR_Attr<"RecordLayout", "record_layout", [
                      "bool":$has_trivial_dtor,
                      "uint64_t":$record_align), [{
       return $_get($_ctxt, arg_passing_kind, has_trivial_dtor, record_align,
+                   /*unadjusted_align=*/record_align,
                    /*transparent_union=*/false);
     }]>
   ];
 
-  let assemblyFormat = [{
-    `<`
-      `arg_passing_kind` `=` $arg_passing_kind `,`
-      `has_trivial_dtor` `=` $has_trivial_dtor `,`
-      `record_align` `=` $record_align
-      (`,` `transparent_union` `=` $transparent_union^)?
-    `>`
-  }];
+  // Printing and parsing available in CIRAttrs.cpp.
+  let hasCustomAssemblyFormat = 1;
 
   let canHaveIllegalCXXABIType = 0;
 }

diff  --git a/clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp b/clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp
index 1f0607f71676b8..2ed7d34320390d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenRecordLayoutBuilder.cpp
@@ -964,12 +964,15 @@ CIRGenTypes::computeRecordLayout(const RecordDecl *rd, cir::RecordType *ty) {
       hasTrivialDestructor = cxxRD->hasTrivialDestructor();
     const auto &astLayout = astContext.getASTRecordLayout(rd);
     uint64_t recordAlignInBytes = astLayout.getAlignment().getQuantity();
+    uint64_t unadjustedAlignInBytes =
+        astLayout.getUnadjustedAlignment().getQuantity();
     bool isTransparentUnion = rd->hasAttr<TransparentUnionAttr>();
 
     cgm.addRecordLayout(
         ty->getName(),
         cir::RecordLayoutAttr::get(mlirCtx, apk, hasTrivialDestructor,
-                                   recordAlignInBytes, isTransparentUnion));
+                                   recordAlignInBytes, unadjustedAlignInBytes,
+                                   isTransparentUnion));
   }
 
   auto rl = std::make_unique<CIRGenRecordLayout>(

diff  --git a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
index 5d2f9f6def5446..c6930935ab6323 100644
--- a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
@@ -1041,6 +1041,89 @@ LogicalResult EhFilterAttr::verify(function_ref<InFlightDiagnostic()> emitError,
   return success();
 }
 
+//===----------------------------------------------------------------------===//
+// RecordLayoutAttr
+//===----------------------------------------------------------------------===//
+
+Attribute RecordLayoutAttr::parse(AsmParser &parser, Type odsType) {
+  (void)odsType;
+  SMLoc loc = parser.getCurrentLocation();
+  if (parser.parseLess() || parser.parseKeyword("arg_passing_kind") ||
+      parser.parseEqual())
+    return {};
+
+  FailureOr<ArgPassingKind> kind = FieldParser<ArgPassingKind>::parse(parser);
+  if (failed(kind))
+    return {};
+
+  if (parser.parseComma() || parser.parseKeyword("has_trivial_dtor") ||
+      parser.parseEqual())
+    return {};
+  FailureOr<bool> hasTrivialDtor = FieldParser<bool>::parse(parser);
+  if (failed(hasTrivialDtor))
+    return {};
+
+  if (parser.parseComma() || parser.parseKeyword("record_align") ||
+      parser.parseEqual())
+    return {};
+  FailureOr<uint64_t> recordAlign = FieldParser<uint64_t>::parse(parser);
+  if (failed(recordAlign))
+    return {};
+
+  // An omitted unadjusted_align stores the record alignment. Either optional
+  // field may follow record_align, in either order.
+  uint64_t unadjustedAlign = *recordAlign;
+  bool transparentUnion = false;
+  while (succeeded(parser.parseOptionalComma())) {
+    if (succeeded(parser.parseOptionalKeyword("unadjusted_align"))) {
+      if (parser.parseEqual())
+        return {};
+      FailureOr<uint64_t> parsed = FieldParser<uint64_t>::parse(parser);
+      if (failed(parsed))
+        return {};
+      unadjustedAlign = *parsed;
+      continue;
+    }
+    if (succeeded(parser.parseOptionalKeyword("transparent_union"))) {
+      if (parser.parseEqual())
+        return {};
+      FailureOr<bool> parsed = FieldParser<bool>::parse(parser);
+      if (failed(parsed))
+        return {};
+      transparentUnion = *parsed;
+      continue;
+    }
+    parser.emitError(parser.getCurrentLocation(),
+                     "expected unadjusted_align or transparent_union");
+    return {};
+  }
+
+  if (parser.parseGreater())
+    return {};
+  return parser.getChecked<RecordLayoutAttr>(loc, parser.getContext(), *kind,
+                                             *hasTrivialDtor, *recordAlign,
+                                             unadjustedAlign, transparentUnion);
+}
+
+void RecordLayoutAttr::print(AsmPrinter &printer) const {
+  printer << "<arg_passing_kind = ";
+  printer.printStrippedAttrOrType(getArgPassingKind());
+  printer << ", has_trivial_dtor = ";
+  printer.printStrippedAttrOrType(getHasTrivialDtor());
+  printer << ", record_align = ";
+  printer.printStrippedAttrOrType(getRecordAlign());
+  // Print unadjusted_align only when it 
diff ers from record_align.
+  if (getUnadjustedAlign() != getRecordAlign()) {
+    printer << ", unadjusted_align = ";
+    printer.printStrippedAttrOrType(getUnadjustedAlign());
+  }
+  if (getTransparentUnion()) {
+    printer << ", transparent_union = ";
+    printer.printStrippedAttrOrType(getTransparentUnion());
+  }
+  printer << '>';
+}
+
 //===----------------------------------------------------------------------===//
 // RecordLayout lookup
 //===----------------------------------------------------------------------===//

diff  --git a/clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp b/clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp
index 0af64bf105db64..a95672a5081219 100644
--- a/clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/CIRABIClassifier.cpp
@@ -113,6 +113,18 @@ static llvm::Align recordDeclaredAlign(ModuleOp modOp, cir::RecordType recTy,
   return llvm::Align(layout.getRecordAlign());
 }
 
+/// A record's unadjusted alignment, the alignment its members give it before
+/// an alignment attribute on the record raises it.  Like the declared
+/// alignment, it comes from the module's record-layout metadata, and the
+/// computed fallback only serves hand-written CIR.
+static llvm::Align recordUnadjustedAlign(ModuleOp modOp, cir::RecordType recTy,
+                                         const DataLayout &dl) {
+  auto layout = cir::tryGetRecordLayout(modOp, recTy.getName());
+  if (!layout)
+    return llvm::Align(dl.getTypeABIAlignment(recTy));
+  return llvm::Align(layout.getUnadjustedAlign());
+}
+
 /// The CIR types the bridge handles.  Scalars: an integer up to 128
 /// bits (including `__int128`), a `_BitInt` of any width, pointer, vtable
 /// pointer, bool, void, or any floating-point type.  Aggregates: a complete
@@ -384,15 +396,14 @@ static const llvm::abi::Type *mapCIRType(mlir::Type type,
         llvm::TypeSize sizeBits = llvm::TypeSize::getFixed(
             dl.getTypeSizeInBits(type).getFixedValue());
         llvm::Align align = recordDeclaredAlign(modOp, recTy, dl);
+        llvm::Align unadjustedAlign = recordUnadjustedAlign(modOp, recTy, dl);
 
         // Mapped with no fields, an empty record reaches Ignore on its own.
         // The size still matters, since a target may pass a large empty
         // record in memory whatever its content.
-        // TODO: AArch64 needs the unadjusted alignment. We'll need to add that
-        // to RecordLayoutAttr.
         if (recTy.isEmptyForABI())
           return tb.getRecordType(
-              /*Fields=*/{}, sizeBits, align, /*UnadjustedAlign=*/align,
+              /*Fields=*/{}, sizeBits, align, unadjustedAlign,
               llvm::abi::StructPacking::Default,
               /*BaseClasses=*/{}, /*VirtualBaseClasses=*/{}, flags);
 
@@ -469,8 +480,7 @@ static const llvm::abi::Type *mapCIRType(mlir::Type type,
             fields.push_back(llvm::abi::FieldInfo(
                 mapCIRType(variantTy, typeMapper, dl, modOp)));
           }
-          return tb.getUnionType(fields, sizeBits, align,
-                                 /*UnadjustedAlign=*/align,
+          return tb.getUnionType(fields, sizeBits, align, unadjustedAlign,
                                  llvm::abi::StructPacking::Default, flags);
         }
 
@@ -504,10 +514,10 @@ static const llvm::abi::Type *mapCIRType(mlir::Type type,
               /*IsUnnamedBitField=*/isUnnamed));
         }
 
-        return tb.getRecordType(
-            fields, sizeBits, align, /*UnadjustedAlign=*/align,
-            llvm::abi::StructPacking::Default,
-            /*BaseClasses=*/{}, /*VirtualBaseClasses=*/{}, flags);
+        return tb.getRecordType(fields, sizeBits, align, unadjustedAlign,
+                                llvm::abi::StructPacking::Default,
+                                /*BaseClasses=*/{}, /*VirtualBaseClasses=*/{},
+                                flags);
       })
       .Default([](mlir::Type) -> const llvm::abi::Type * {
         llvm_unreachable(

diff  --git a/clang/test/CIR/CodeGen/record-type-metadata.cpp b/clang/test/CIR/CodeGen/record-type-metadata.cpp
index fc7b849a643074..da3656c4b42816 100644
--- a/clang/test/CIR/CodeGen/record-type-metadata.cpp
+++ b/clang/test/CIR/CodeGen/record-type-metadata.cpp
@@ -25,5 +25,5 @@ void takesNTD(NonTrivialDtor n) {}
 // ABI metadata lives in module-level cir.record_layouts attribute.
 // CIR-DAG: Trivial = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 4>
 // CIR-DAG: Empty = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 1>
-// CIR-DAG: Aligned = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 16>
+// CIR-DAG: Aligned = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 16, unadjusted_align = 4>
 // CIR-DAG: NonTrivialDtor = #cir.record_layout<arg_passing_kind = cannot_pass_in_regs, has_trivial_dtor = false, record_align = 4>

diff  --git a/clang/test/CIR/IR/invalid-record-layout.cir b/clang/test/CIR/IR/invalid-record-layout.cir
index 61ebc9b37528c2..5edffa6327f3ce 100644
--- a/clang/test/CIR/IR/invalid-record-layout.cir
+++ b/clang/test/CIR/IR/invalid-record-layout.cir
@@ -17,3 +17,14 @@ module attributes {
                            has_trivial_dtor = true, record_align = 3>}
 } {
 }
+
+// -----
+
+module attributes {
+  cir.record_layouts = {
+    // expected-error @below {{failed to verify that unadjusted_align must be a non-zero power of two}}
+    S = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                           has_trivial_dtor = true, record_align = 4,
+                           unadjusted_align = 3>}
+} {
+}

diff  --git a/clang/test/CIR/IR/record-layout.cir b/clang/test/CIR/IR/record-layout.cir
new file mode 100644
index 00000000000000..321d55bd6cf7f1
--- /dev/null
+++ b/clang/test/CIR/IR/record-layout.cir
@@ -0,0 +1,21 @@
+// RUN: cir-opt %s | FileCheck %s
+
+module attributes {
+  cir.record_layouts = {
+    Same = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                              has_trivial_dtor = true, record_align = 4,
+                              unadjusted_align = 4>,
+    Raised = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                                has_trivial_dtor = true, record_align = 16,
+                                unadjusted_align = 4>,
+    TU = #cir.record_layout<arg_passing_kind = can_pass_in_regs,
+                            has_trivial_dtor = true, record_align = 4,
+                            transparent_union = true>
+  }
+} {}
+
+// An unadjusted alignment equal to record_align is omitted, including when
+// the input spelled it out. A transparent union can omit it too.
+// CHECK-DAG: Raised = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 16, unadjusted_align = 4>
+// CHECK-DAG: Same = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 4>
+// CHECK-DAG: TU = #cir.record_layout<arg_passing_kind = can_pass_in_regs, has_trivial_dtor = true, record_align = 4, transparent_union = true>

diff  --git a/clang/unittests/CIR/RecordTypeMetadataTest.cpp b/clang/unittests/CIR/RecordTypeMetadataTest.cpp
index 3e7b0d9054970f..3c5feb52a8e32b 100644
--- a/clang/unittests/CIR/RecordTypeMetadataTest.cpp
+++ b/clang/unittests/CIR/RecordTypeMetadataTest.cpp
@@ -60,6 +60,21 @@ TEST_F(RecordLayoutAttrTest, HighAlignment) {
   EXPECT_EQ(attr.getRecordAlign(), 32u);
 }
 
+TEST_F(RecordLayoutAttrTest, UnadjustedAlignDefaultsToRecordAlign) {
+  auto attr =
+      RecordLayoutAttr::get(&context, ArgPassingKind::CanPassInRegs, true, 16);
+  EXPECT_EQ(attr.getRecordAlign(), 16u);
+  EXPECT_EQ(attr.getUnadjustedAlign(), 16u);
+}
+
+TEST_F(RecordLayoutAttrTest, UnadjustedAlignDistinct) {
+  auto attr = RecordLayoutAttr::get(&context, ArgPassingKind::CanPassInRegs,
+                                    true, 16, /*unadjusted_align=*/4,
+                                    /*transparent_union=*/false);
+  EXPECT_EQ(attr.getRecordAlign(), 16u);
+  EXPECT_EQ(attr.getUnadjustedAlign(), 4u);
+}
+
 TEST_F(RecordLayoutAttrTest, RecordTypeUnchanged) {
   IntType i32 = IntType::get(&context, 32, true);
   auto ty = StructType::get(&context, getName("Foo"), /*is_class=*/false);


        


More information about the cfe-commits mailing list