Change cir.struct to cir.record

Author: andykaylor

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

@@ -21,7 +21,7 @@
 namespace cir {
 
 namespace detail {
-struct StructTypeStorage;
+struct RecordTypeStorage;
 } // namespace detail
 
 bool isAnyFloatingPointType(mlir::Type t);

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

@@ -401,52 +401,51 @@ def VoidPtr : Type<
 }
 
 //===----------------------------------------------------------------------===//
-// StructType
+// RecordType
 //
 // The base type for all RecordDecls.
 //===----------------------------------------------------------------------===//
 
-def CIR_StructType : CIR_Type<"Struct", "struct",
+def CIR_RecordType : CIR_Type<"Record", "record",
     [
       DeclareTypeInterfaceMethods<DataLayoutTypeInterface>,
       MutableType,
     ]> {
-  let summary = "CIR struct type";
+  let summary = "CIR record type";
   let description = [{
-    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.
+    Each unique clang::RecordDecl is mapped to a `cir.record` and any object in
+    C/C++ that has a struct or class type will have a `cir.record` 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 unknown body.
-     - Anonymous structs: no name and a known body.
+     - Identified and complete records: unique name and a known body.
+     - Identified and incomplete records: unique name and unknown body.
+     - Anonymous records: 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 an existing name,
+    Identified records are uniqued by their name, and anonymous records are
+    uniqued by their body. This means that two anonymous records with the same
+    body will be the same type, and two identified records with the same name
+    will be the same type. Attempting to build a record with an 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>}>
+        !complete = !cir.record<struct "complete" {!cir.int<u, 8>}>
+        !incomplete = !cir.record<struct "incomplete" incomplete>
+        !anonymous = !cir.record<struct {!cir.int<u, 8>}>
     ```
 
-    Incomplete structs are mutable, meaning they can be later completed with a
+    Incomplete records are mutable, meaning they 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
+    incomplete record. Mutability allows for recursive types to be represented,
+    meaning the record 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:
+    In the example below, the `Node` record has a member that is a pointer to a
+    `Node` record:
 
     ```mlir
-        !struct = !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct
-        "Node">>}>
+        !s = !cir.record<struct "Node" {!cir.ptr<!cir.record<struct "Node">>}>
     ```
   }];
 
@@ -456,18 +455,18 @@ def CIR_StructType : CIR_Type<"Struct", "struct",
     "bool":$incomplete,
     "bool":$packed,
     "bool":$padded,
-    "StructType::RecordKind":$kind
+    "RecordType::RecordKind":$kind
   );
 
   // StorageClass is defined in C++ for mutability.
-  let storageClass = "StructTypeStorage";
+  let storageClass = "RecordTypeStorage";
   let genStorageClass = 0;
 
   let skipDefaultBuilders = 1;
   let genVerifyDecl = 1;
 
   let builders = [
-    // Create an identified and incomplete struct type.
+    // Create an identified and incomplete record type.
     TypeBuilder<(ins
       "mlir::StringAttr":$name,
       "RecordKind":$kind
@@ -480,9 +479,8 @@ def CIR_StructType : CIR_Type<"Struct", "struct",
   let extraClassDeclaration = [{
     using Base::verifyInvariants;
 
-    enum RecordKind : uint32_t { Class, Union, Struct };
+    enum RecordKind : uint32_t { Struct, Union };
 
-    bool isClass() const { return getKind() == RecordKind::Class; };
     bool isStruct() const { return getKind() == RecordKind::Struct; };
     bool isUnion() const { return getKind() == RecordKind::Union; };
     bool isComplete() const { return !isIncomplete(); };
@@ -491,14 +489,12 @@ def CIR_StructType : CIR_Type<"Struct", "struct",
     size_t getNumElements() const { return getMembers().size(); };
     std::string getKindAsStr() {
       switch (getKind()) {
-      case RecordKind::Class:
-        return "class";
       case RecordKind::Union:
         return "union";
       case RecordKind::Struct:
         return "struct";
       }
-      llvm_unreachable("Invalid value for StructType::getKind()");
+      llvm_unreachable("Invalid value for RecordType::getKind()");
     }
     std::string getPrefixedName() {
       return getKindAsStr() + "." + getName().getValue().str();
@@ -508,18 +504,18 @@ def CIR_StructType : CIR_Type<"Struct", "struct",
   let hasCustomAssemblyFormat = 1;
 }
 
-// Note CIRStructType is used instead of CIR_StructType
+// Note CIRRecordType is used instead of CIR_RecordType
 // because of tablegen conflicts.
-def CIRStructType : Type<
-  CPred<"::mlir::isa<::cir::StructType>($_self)">, "CIR struct type">;
+def CIRRecordType : Type<
+  CPred<"::mlir::isa<::cir::RecordType>($_self)">, "CIR record type">;
 
 //===----------------------------------------------------------------------===//
 // Global type constraints
 //===----------------------------------------------------------------------===//
 
 def CIR_AnyType : AnyTypeOf<[
   CIR_VoidType, CIR_BoolType, CIR_ArrayType, CIR_IntType, CIR_AnyFloat,
-  CIR_PointerType, CIR_FuncType, CIR_StructType
+  CIR_PointerType, CIR_FuncType, CIR_RecordType
 ]>;
 
 #endif // MLIR_CIR_DIALECT_CIR_TYPES

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

@@ -22,22 +22,22 @@ namespace cir {
 namespace detail {
 
 //===----------------------------------------------------------------------===//
-// CIR StructTypeStorage
+// CIR RecordTypeStorage
 //===----------------------------------------------------------------------===//
 
 /// Type storage for CIR record types.
-struct StructTypeStorage : public mlir::TypeStorage {
+struct RecordTypeStorage : public mlir::TypeStorage {
   struct KeyTy {
     llvm::ArrayRef<mlir::Type> members;
     mlir::StringAttr name;
     bool incomplete;
     bool packed;
     bool padded;
-    StructType::RecordKind kind;
+    RecordType::RecordKind kind;
 
     KeyTy(llvm::ArrayRef<mlir::Type> members, mlir::StringAttr name,
           bool incomplete, bool packed, bool padded,
-          StructType::RecordKind kind)
+          RecordType::RecordKind kind)
         : members(members), name(name), incomplete(incomplete), packed(packed),
           padded(padded), kind(kind) {}
   };
@@ -47,14 +47,14 @@ struct StructTypeStorage : public mlir::TypeStorage {
   bool incomplete;
   bool packed;
   bool padded;
-  StructType::RecordKind kind;
+  RecordType::RecordKind kind;
 
-  StructTypeStorage(llvm::ArrayRef<mlir::Type> members, mlir::StringAttr name,
+  RecordTypeStorage(llvm::ArrayRef<mlir::Type> members, mlir::StringAttr name,
                     bool incomplete, bool packed, bool padded,
-                    StructType::RecordKind kind)
+                    RecordType::RecordKind kind)
       : members(members), name(name), incomplete(incomplete), packed(packed),
         padded(padded), kind(kind) {
-          assert(name || !incomplete && "Incomplete structs must have a name");
+          assert(name || !incomplete && "Incomplete records must have a name");
         }
 
   KeyTy getAsKey() const {
@@ -76,33 +76,33 @@ struct StructTypeStorage : public mlir::TypeStorage {
                               key.padded, key.kind);
   }
 
-  static StructTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+  static RecordTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                       const KeyTy &key) {
-    return new (allocator.allocate<StructTypeStorage>())
-        StructTypeStorage(allocator.copyInto(key.members), key.name,
+    return new (allocator.allocate<RecordTypeStorage>())
+        RecordTypeStorage(allocator.copyInto(key.members), key.name,
                           key.incomplete, key.packed, key.padded, key.kind);
   }
 
-  /// Mutates the members and attributes an identified struct.
+  /// Mutates the members and attributes an identified record.
   ///
   /// 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.
+  /// mutations. Anonymous records are always complete and cannot be mutated.
+  /// This method does not fail if a mutation of a complete record does not
+  /// change the record.
   llvm::LogicalResult mutate(mlir::TypeStorageAllocator &allocator,
                              llvm::ArrayRef<mlir::Type> members, bool packed,
                              bool padded) {
-    // Anonymous structs cannot mutate.
+    // Anonymous records cannot mutate.
     if (!name)
       return llvm::failure();
 
-    // Mutation of complete structs are allowed if they change nothing.
+    // Mutation of complete records are allowed if they change nothing.
     if (!incomplete)
       return mlir::success((this->members == members) &&
                            (this->packed == packed) &&
                            (this->padded == padded));
 
-    // Mutate incomplete struct.
+    // Mutate incomplete record.
     this->members = allocator.copyInto(members);
     this->packed = packed;
     this->padded = padded;

clang/include/clang/CIR/MissingFeatures.h

@@ -101,8 +101,8 @@ struct MissingFeatures {
   static bool mayHaveIntegerOverflow() { return false; }
   static bool shouldReverseUnaryCondOnBoolExpr() { return false; }
 
-  // StructType
-  static bool structTypeLayoutInfo() { return false; }
+  // RecordType
+  static bool recordTypeLayoutInfo() { return false; }
 
   // Misc
   static bool cxxABI() { return false; }

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -51,14 +51,13 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
   }
 
   /// Get a CIR record kind from a AST declaration tag.
-  cir::StructType::RecordKind getRecordKind(const clang::TagTypeKind kind) {
+  cir::RecordType::RecordKind getRecordKind(const clang::TagTypeKind kind) {
     switch (kind) {
+    case clang::TagTypeKind::Class:
     case clang::TagTypeKind::Struct:
-      return cir::StructType::Struct;
+      return cir::RecordType::Struct;
     case clang::TagTypeKind::Union:
-      return cir::StructType::Union;
-    case clang::TagTypeKind::Class:
-      return cir::StructType::Class;
+      return cir::RecordType::Union;
     case clang::TagTypeKind::Interface:
       llvm_unreachable("interface records are NYI");
     case clang::TagTypeKind::Enum:
@@ -69,13 +68,13 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
   /// Get an incomplete CIR struct type. If we have a complete record
   /// declaration, we may create an incomplete type and then add the
   /// members, so \p rd here may be complete.
-  cir::StructType getIncompleteStructTy(llvm::StringRef name,
+  cir::RecordType getIncompleteRecordTy(llvm::StringRef name,
                                         const clang::RecordDecl *rd) {
     const mlir::StringAttr nameAttr = getStringAttr(name);
-    cir::StructType::RecordKind kind = cir::StructType::RecordKind::Struct;
+    cir::RecordType::RecordKind kind = cir::RecordType::RecordKind::Struct;
     if (rd)
       kind = getRecordKind(rd->getTagKind());
-    return getType<cir::StructType>(nameAttr, kind);
+    return getType<cir::RecordType>(nameAttr, kind);
   }
 
   bool isSized(mlir::Type ty) {

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -117,14 +117,14 @@ mlir::Type CIRGenTypes::convertRecordDeclType(const clang::RecordDecl *rd) {
   // TagDecl's are not necessarily unique, instead use the (clang) type
   // connected to the decl.
   const Type *key = astContext.getTagDeclType(rd).getTypePtr();
-  cir::StructType entry = recordDeclTypes[key];
+  cir::RecordType entry = recordDeclTypes[key];
 
   // If we don't have an entry for this record yet, create one.
   // We create an incomplete type initially. If `rd` is complete, we will
   // add the members below.
   if (!entry) {
     auto name = getRecordTypeName(rd, "");
-    entry = builder.getIncompleteStructTy(name, rd);
+    entry = builder.getIncompleteRecordTy(name, rd);
     recordDeclTypes[key] = entry;
   }
 

clang/lib/CIR/CodeGen/CIRGenTypes.h

@@ -46,7 +46,7 @@ class CIRGenTypes {
   CIRGenBuilderTy &builder;
 
   /// Contains the CIR type for any converted RecordDecl
-  llvm::DenseMap<const clang::Type *, cir::StructType> recordDeclTypes;
+  llvm::DenseMap<const clang::Type *, cir::RecordType> recordDeclTypes;
 
   /// Hold memoized CIRGenFunctionInfo results
   llvm::FoldingSet<CIRGenFunctionInfo> functionInfos;