[CIR][CIRGen] Support mutable and recursive named records

This allows a named StructType to be mutated after it has been created,
if it is identified and incomplete.

The motivation for this is to improve the codegen of CIR in certain
scenarios where an incomplete type is used and later completed. These
usually leave the IR in an inconsistent state, where there are two
records types with the same identifier but different definitions (one
complete the other incomplete).

For example:

```c++
struct Node {
  Node *next;
};
void test(struct Node n) {}
```

Generates:

```mlir
!temp_struct = !cir.struct<struct "Node" incomplete>
!full_struct = !cir.struct<struct "Node" {!cir.ptr<!temp_struct>}>
```

To generate the `Node` struct type, its members must be created first.
However, the `next` member is a recursive reference, so it can only be
completed after its parent. This generates a temporary incomplete
definition of the `Node` type that remains in the code even after the
type to which it refers is completed. As a consequence, accessing the
`next` member of a `Node` value fetches the old incomplete version of
the type which affects CIR's type-checking capabilities.

This patch ensures that, once the parent is fully visited, the `next`
member can be completed in place, automatically updating any references
to it at a low cost. To represent recursive types, the StructType now
is equipped with self-references. These are represented by a
`cir.struct` type with just the name of the parent struct that it
refers to. The same snippet of code will not generate the following
CIR IR:

```mlir
!full_struct = !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node">>}>
```

Summary of the changes made:
 - Named records are now uniquely identified by their name. An attempt
   to create a new record with the same will fail.
 - Anonymous records are uniquely identified by members and other
   relevant attributes.
 - StructType has a new `mutate` method that allows it to be mutated
   after it has been created. Each type can only be mutated if it is
   identified and incomplete, rendering further changes impossible.
 - When building a new name StructType, the builder will try to first
   create, then complete the type, ensuring that:

    - Inexistent types are created
    - Existing incomplete types are completed
    - Existing complete types with matching attributes are reused
    - Existing complete types with different attributes raise errors

 - StructType now uses the CyclicParser/Printer guard to avoid infinite
   recursion and identify when it should print/parse a self-reference.

ghstack-source-id: a6d4f65
Pull Request resolved: #303

Author: sitio-couto

clang/include/clang/CIR/Dialect/IR/CIRTypes.h

@@ -41,9 +41,43 @@ struct StructTypeStorage;
 
 /// Each unique clang::RecordDecl is mapped to a `cir.struct` and any object in
 /// C/C++ that has a struct type will have a `cir.struct` in CIR.
+///
+/// There are three possible formats for this type:
+///
+///  - Identified and complete structs: unique name and a known body.
+///  - Identified and incomplete structs: unique name and unkonwn body.
+///  - Anonymous structs: no name and a known body.
+///
+/// Identified structs are uniqued by their name, and anonymous structs are
+/// uniqued by their body. This means that two anonymous structs with the same
+/// body will be the same type, and two identified structs with the same name
+/// will be the same type. Attempting to build a struct with a existing name,
+/// but a different body will result in an error.
+///
+/// A few examples:
+///
+/// ```mlir
+///     !complete = !cir.struct<struct "complete" {!cir.int<u, 8>}>
+///     !incomplete = !cir.struct<struct "incomplete" incomplete>
+///     !anonymous = !cir.struct<struct {!cir.int<u, 8>}>
+/// ```
+///
+/// Incomplete structs are mutable, meaning the can be later completed with a
+/// body automatically updating in place every type in the code that uses the
+/// incomplete struct. Mutability allows for recursive types to be represented,
+/// meaning the struct can have members that refer to itself. This is useful for
+/// representing recursive records and is implemented through a special syntax.
+/// In the example below, the `Node` struct has a member that is a pointer to a
+/// `Node` struct:
+///
+/// ```mlir
+///     !struct = !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct
+///     "Node">>}>
+/// ```
 class StructType
     : public Type::TypeBase<StructType, Type, detail::StructTypeStorage,
-                            DataLayoutTypeInterface::Trait> {
+                            DataLayoutTypeInterface::Trait,
+                            TypeTrait::IsMutable> {
   // FIXME(cir): migrate this type to Tablegen once mutable types are supported.
 public:
   using Base::Base;
@@ -123,6 +157,10 @@ class StructType
     return getKindAsStr() + "." + getName().getValue().str();
   }
 
+  /// Complete the struct type by mutating its members and attributes.
+  void complete(ArrayRef<Type> members, bool packed,
+                ASTRecordDeclInterface ast = {});
+
   /// DataLayoutTypeInterface methods.
   llvm::TypeSize getTypeSizeInBits(const DataLayout &dataLayout,
                                    DataLayoutEntryListRef params) const;

clang/include/clang/CIR/Dialect/IR/CIRTypesDetails.h

@@ -14,7 +14,9 @@
 #define CIR_DIALECT_IR_CIRTYPESDETAILS_H
 
 #include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/Support/LogicalResult.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include "llvm/ADT/Hashing.h"
 
 namespace mlir {
 namespace cir {
@@ -58,14 +60,18 @@ struct StructTypeStorage : public TypeStorage {
   }
 
   bool operator==(const KeyTy &key) const {
+    if (name)
+      return (name == key.name) && (kind == key.kind);
     return (members == key.members) && (name == key.name) &&
            (incomplete == key.incomplete) && (packed == key.packed) &&
            (kind == key.kind) && (ast == key.ast);
   }
 
   static llvm::hash_code hashKey(const KeyTy &key) {
-    return hash_combine(key.members, key.name, key.incomplete, key.packed,
-                        key.kind, key.ast);
+    if (key.name)
+      return llvm::hash_combine(key.name, key.kind);
+    return llvm::hash_combine(key.members, key.incomplete, key.packed, key.kind,
+                              key.ast);
   }
 
   static StructTypeStorage *construct(TypeStorageAllocator &allocator,
@@ -74,6 +80,32 @@ struct StructTypeStorage : public TypeStorage {
         StructTypeStorage(allocator.copyInto(key.members), key.name,
                           key.incomplete, key.packed, key.kind, key.ast);
   }
+
+  /// Mutates the members and attributes an identified struct.
+  ///
+  /// Once a record is mutated, it is marked as complete, preventing further
+  /// mutations. Anonymous structs are always complete and cannot be mutated.
+  /// This method does not fail if a mutation of a complete struct does not
+  /// change the struct.
+  LogicalResult mutate(TypeStorageAllocator &allocator, ArrayRef<Type> members,
+                       bool packed, ASTRecordDeclInterface ast) {
+    // Anonymous structs cannot mutate.
+    if (!name)
+      return failure();
+
+    // Mutation of complete structs are allowed if they change nothing.
+    if (!incomplete)
+      return mlir::success((this->members == members) &&
+                           (this->packed == packed) && (this->ast == ast));
+
+    // Mutate incomplete struct.
+    this->members = allocator.copyInto(members);
+    this->packed = packed;
+    this->ast = ast;
+
+    incomplete = false;
+    return success();
+  }
 };
 
 } // namespace detail

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -435,6 +435,9 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   }
 
   /// Get a CIR named struct type.
+  ///
+  /// If a struct already exists and is complete, but the client tries to fetch
+  /// it with a different set of attributes, this method will crash.
   mlir::cir::StructType getCompleteStructTy(llvm::ArrayRef<mlir::Type> members,
                                             llvm::StringRef name, bool packed,
                                             const clang::RecordDecl *ast) {
@@ -445,8 +448,16 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
       astAttr = getAttr<mlir::cir::ASTRecordDeclAttr>(ast);
       kind = getRecordKind(ast->getTagKind());
     }
-    return getType<mlir::cir::StructType>(members, nameAttr, packed, kind,
-                                          astAttr);
+
+    // Create or get the struct.
+    auto type = getType<mlir::cir::StructType>(members, nameAttr, packed, kind,
+                                               astAttr);
+
+    // Complete an incomplete struct or ensure the existing complete struct
+    // matches the requested attributes.
+    type.complete(members, packed, astAttr);
+
+    return type;
   }
 
   //
@@ -689,7 +700,6 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     auto flag = getBool(val, loc);
     return create<mlir::cir::StoreOp>(loc, flag, dst);
   }
-
 };
 
 } // namespace cir

clang/lib/CIR/CodeGen/CIRRecordLayoutBuilder.cpp

@@ -596,7 +596,7 @@ std::unique_ptr<CIRGenRecordLayout>
 CIRGenTypes::computeRecordLayout(const RecordDecl *D,
                                  mlir::cir::StructType *Ty) {
   CIRRecordLowering builder(*this, D, /*packed=*/false);
-
+  assert(Ty->isIncomplete() && "recomputing record layout?");
   builder.lower(/*nonVirtualBaseType=*/false);
 
   // If we're in C++, compute the base subobject type.

clang/lib/CIR/Dialect/IR/CIRTypes.cpp

@@ -128,7 +128,9 @@ Type StructType::getLargestMember(const ::mlir::DataLayout &dataLayout) const {
 }
 
 Type StructType::parse(mlir::AsmParser &parser) {
+  FailureOr<AsmParser::CyclicParseReset> cyclicParseGuard;
   const auto loc = parser.getCurrentLocation();
+  const auto eLoc = parser.getEncodedSourceLoc(loc);
   bool packed = false;
   RecordKind kind;
   auto *context = parser.getContext();
@@ -152,6 +154,26 @@ Type StructType::parse(mlir::AsmParser &parser) {
   mlir::StringAttr name;
   parser.parseOptionalAttribute(name);
 
+  // Is a self reference: ensure referenced type was parsed.
+  if (name && parser.parseOptionalGreater().succeeded()) {
+    auto type = getChecked(eLoc, context, name, kind);
+    if (succeeded(parser.tryStartCyclicParse(type))) {
+      parser.emitError(loc, "invalid self-reference within record");
+      return {};
+    }
+    return type;
+  }
+
+  // Is a named record definition: ensure name has not been parsed yet.
+  if (name) {
+    auto type = getChecked(eLoc, context, name, kind);
+    cyclicParseGuard = parser.tryStartCyclicParse(type);
+    if (failed(cyclicParseGuard)) {
+      parser.emitError(loc, "record already defined");
+      return {};
+    }
+  }
+
   if (parser.parseOptionalKeyword("packed").succeeded())
     packed = true;
 
@@ -176,14 +198,17 @@ Type StructType::parse(mlir::AsmParser &parser) {
   if (parser.parseGreater())
     return {};
 
-  // Try to create the proper type.
-  mlir::Type type = {};
+  // Try to create the proper record type.
   ArrayRef<mlir::Type> membersRef(members); // Needed for template deduction.
-  const auto eLoc = parser.getEncodedSourceLoc(loc);
+  mlir::Type type = {};
   if (name && incomplete) { // Identified & incomplete
     type = getChecked(eLoc, context, name, kind);
   } else if (name && !incomplete) { // Identified & complete
     type = getChecked(eLoc, context, membersRef, name, packed, kind);
+    // If the record has a self-reference, its type already exists in a
+    // incomplete state. In this case, we must complete it.
+    if (type.cast<StructType>().isIncomplete())
+      type.cast<StructType>().complete(membersRef, packed, ast);
   } else if (!name && !incomplete) { // anonymous & complete
     type = getChecked(eLoc, context, membersRef, packed, kind);
   } else { // anonymous & incomplete
@@ -195,6 +220,7 @@ Type StructType::parse(mlir::AsmParser &parser) {
 }
 
 void StructType::print(mlir::AsmPrinter &printer) const {
+  FailureOr<AsmPrinter::CyclicPrintReset> cyclicPrintGuard;
   printer << '<';
 
   switch (getKind()) {
@@ -210,7 +236,17 @@ void StructType::print(mlir::AsmPrinter &printer) const {
   }
 
   if (getName())
-    printer << getName() << " ";
+    printer << getName();
+
+  // Current type has already been printed: print as self reference.
+  cyclicPrintGuard = printer.tryStartCyclicPrint(*this);
+  if (failed(cyclicPrintGuard)) {
+    printer << '>';
+    return;
+  }
+
+  // Type not yet printed: continue printing the entire record.
+  printer << ' ';
 
   if (getPacked())
     printer << "packed ";
@@ -308,6 +344,12 @@ mlir::cir::StructType::RecordKind StructType::getKind() const {
 
 ASTRecordDeclInterface StructType::getAst() const { return getImpl()->ast; }
 
+void StructType::complete(ArrayRef<Type> members, bool packed,
+                          ASTRecordDeclInterface ast) {
+  if (mutate(members, packed, ast).failed())
+    llvm_unreachable("failed to complete struct");
+}
+
 //===----------------------------------------------------------------------===//
 // Data Layout information for types
 //===----------------------------------------------------------------------===//

clang/test/CIR/CodeGen/agg-init.cpp

@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++17 -fclangir-enable -Wno-unused-value -emit-cir %s -o %t.cir
 // RUN: FileCheck --input-file=%t.cir %s
 
-// CHECK: !ty_22yep_22 = !cir.struct<struct "yep_" {!u32i, !u32i}>
+// CHECK: !ty_22yep_22 = !cir.struct<struct "yep_" {!cir.int<u, 32>, !cir.int<u, 32>}>
 
 typedef enum xxy_ {
   xxy_Low = 0,

clang/test/CIR/CodeGen/atomic.cpp

@@ -7,4 +7,4 @@ typedef struct _a {
 
 void m() { at y; }
 
-// CHECK: !ty_22_a22 = !cir.struct<struct "_a" {!s32i}>
+// CHECK: !ty_22_a22 = !cir.struct<struct "_a" {!cir.int<s, 32>}>

clang/test/CIR/CodeGen/bitfields.c

@@ -27,10 +27,10 @@ typedef struct {
   int a : 3;  // one bitfield with size < 8
   unsigned b;
 } T; 
-// CHECK: !ty_22S22 = !cir.struct<struct "S" {!u32i, !u32i, !u16i, !u32i}>
-// CHECK: !ty_22T22 = !cir.struct<struct "T" {!u8i, !u32i} #cir.record.decl.ast>
-// CHECK: !ty_22anon2E122 = !cir.struct<struct "anon.1" {!u32i} #cir.record.decl.ast>
-// CHECK: !ty_22__long22 = !cir.struct<struct "__long" {!ty_22anon2E122, !u32i, !cir.ptr<!u32i>}>
+// CHECK: !ty_22S22 = !cir.struct<struct "S" {!cir.int<u, 32>, !cir.int<u, 32>, !cir.int<u, 16>, !cir.int<u, 32>}>
+// CHECK: !ty_22T22 = !cir.struct<struct "T" {!cir.int<u, 8>, !cir.int<u, 32>} #cir.record.decl.ast>
+// CHECK: !ty_22anon2E122 = !cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>
+// CHECK: !ty_22__long22 = !cir.struct<struct "__long" {!cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>, !cir.int<u, 32>, !cir.ptr<!cir.int<u, 32>>}>
 
 // CHECK: cir.func {{.*@store_field}}
 // CHECK:   [[TMP0:%.*]] = cir.alloca !ty_22S22, cir.ptr <!ty_22S22>

clang/test/CIR/CodeGen/bitfields.cpp

@@ -27,11 +27,10 @@ typedef struct {
   int a : 3;  // one bitfield with size < 8
   unsigned b;
 } T; 
-
-// CHECK: !ty_22S22 = !cir.struct<struct "S" {!u32i, !u32i, !u16i, !u32i}>
-// CHECK: !ty_22T22 = !cir.struct<struct "T" {!u8i, !u32i} #cir.record.decl.ast>
-// CHECK: !ty_22anon2E122 = !cir.struct<struct "anon.1" {!u32i} #cir.record.decl.ast>
-// CHECK: !ty_22__long22 = !cir.struct<struct "__long" {!ty_22anon2E122, !u32i, !cir.ptr<!u32i>}>
+// CHECK: !ty_22S22 = !cir.struct<struct "S" {!cir.int<u, 32>, !cir.int<u, 32>, !cir.int<u, 16>, !cir.int<u, 32>}>
+// CHECK: !ty_22T22 = !cir.struct<struct "T" {!cir.int<u, 8>, !cir.int<u, 32>} #cir.record.decl.ast>
+// CHECK: !ty_22anon2E122 = !cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>
+// CHECK: !ty_22__long22 = !cir.struct<struct "__long" {!cir.struct<struct "anon.1" {!cir.int<u, 32>} #cir.record.decl.ast>, !cir.int<u, 32>, !cir.ptr<!cir.int<u, 32>>}>
 
 // CHECK: cir.func @_Z11store_field
 // CHECK:   [[TMP0:%.*]] = cir.alloca !ty_22S22, cir.ptr <!ty_22S22>,

clang/test/CIR/CodeGen/coro-task.cpp

@@ -126,13 +126,13 @@ co_invoke_fn co_invoke;
 
 }} // namespace folly::coro
 
-// CHECK-DAG: ![[IntTask:.*]] = !cir.struct<struct "folly::coro::Task<int>" {!u8i}>
-// CHECK-DAG: ![[VoidTask:.*]] = !cir.struct<struct "folly::coro::Task<void>" {!u8i}>
-// CHECK-DAG: ![[VoidPromisse:.*]] = !cir.struct<struct "folly::coro::Task<void>::promise_type" {!u8i}>
-// CHECK-DAG: ![[CoroHandleVoid:.*]] = !cir.struct<struct "std::coroutine_handle<void>" {!u8i}>
-// CHECK-DAG: ![[CoroHandlePromise:ty_.*]]  = !cir.struct<struct "std::coroutine_handle<folly::coro::Task<void>::promise_type>" {!u8i}>
-// CHECK-DAG: ![[StdString:.*]] = !cir.struct<struct "std::string" {!u8i}>
-// CHECK-DAG: ![[SuspendAlways:.*]] = !cir.struct<struct "std::suspend_always" {!u8i}>
+// CHECK-DAG: ![[IntTask:.*]] = !cir.struct<struct "folly::coro::Task<int>" {!cir.int<u, 8>}>
+// CHECK-DAG: ![[VoidTask:.*]] = !cir.struct<struct "folly::coro::Task<void>" {!cir.int<u, 8>}>
+// CHECK-DAG: ![[VoidPromisse:.*]] = !cir.struct<struct "folly::coro::Task<void>::promise_type" {!cir.int<u, 8>}>
+// CHECK-DAG: ![[CoroHandleVoid:.*]] = !cir.struct<struct "std::coroutine_handle<void>" {!cir.int<u, 8>}>
+// CHECK-DAG: ![[CoroHandlePromise:ty_.*]]  = !cir.struct<struct "std::coroutine_handle<folly::coro::Task<void>::promise_type>" {!cir.int<u, 8>}>
+// CHECK-DAG: ![[StdString:.*]] = !cir.struct<struct "std::string" {!cir.int<u, 8>}>
+// CHECK-DAG: ![[SuspendAlways:.*]] = !cir.struct<struct "std::suspend_always" {!cir.int<u, 8>}>
 
 // CHECK: module {{.*}} {
 // CHECK-NEXT: cir.global external @_ZN5folly4coro9co_invokeE = #cir.zero : !ty_22folly3A3Acoro3A3Aco_invoke_fn22