[CIR][CIRGen][NFC] Refactor struct type building

Updates every struct type creation to use the CIRGenBuilder API.

ghstack-source-id: b868f82
Pull Request resolved: #225

Author: sitio-couto

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -27,10 +27,12 @@
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
+#include <optional>
 #include <string>
 
 namespace cir {
@@ -185,11 +187,10 @@ class CIRGenBuilderTy : public mlir::OpBuilder {
       assert(ta && "expected typed attribute member");
       members.push_back(ta.getType());
     }
-    auto *ctx = arrayAttr.getContext();
+
     if (!ty)
-      ty = mlir::cir::StructType::get(ctx, members, mlir::StringAttr::get(ctx),
-                                      /*body=*/true, packed,
-                                      /*ast=*/std::nullopt);
+      ty = getAnonStructTy(members, /*body=*/true, packed);
+
     auto sTy = ty.dyn_cast<mlir::cir::StructType>();
     assert(sTy && "expected struct type");
     return mlir::cir::ConstStructAttr::get(sTy, arrayAttr);
@@ -376,6 +377,25 @@ class CIRGenBuilderTy : public mlir::OpBuilder {
     return typeCache.VoidPtrTy;
   }
 
+  /// Get a CIR anonymous struct type.
+  mlir::cir::StructType
+  getAnonStructTy(llvm::ArrayRef<mlir::Type> members, bool body,
+                  bool packed = false, const clang::RecordDecl *ast = nullptr) {
+    return getStructTy(members, "", body, packed, ast);
+  }
+
+  /// Get a CIR named struct type.
+  mlir::cir::StructType getStructTy(llvm::ArrayRef<mlir::Type> members,
+                                    llvm::StringRef name, bool body,
+                                    bool packed, const clang::RecordDecl *ast) {
+    const auto nameAttr = getStringAttr(name);
+    std::optional<mlir::cir::ASTRecordDeclAttr> astAttr = std::nullopt;
+    if (ast)
+      astAttr = getAttr<mlir::cir::ASTRecordDeclAttr>(ast);
+    return mlir::cir::StructType::get(getContext(), members, nameAttr, body,
+                                      packed, astAttr);
+  }
+
   //
   // Constant creation helpers
   // -------------------------

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -169,10 +169,8 @@ mlir::Type CIRGenTypes::convertRecordDeclType(const clang::RecordDecl *RD) {
   // Handle forward decl / incomplete types.
   if (!entry) {
     auto name = getRecordTypeName(RD, "");
-    auto identifier = mlir::StringAttr::get(&getMLIRContext(), name);
-    entry = mlir::cir::StructType::get(
-        &getMLIRContext(), {}, identifier, /*body=*/false, /**packed=*/false,
-        mlir::cir::ASTRecordDeclAttr::get(&getMLIRContext(), RD));
+    entry = Builder.getStructTy({}, name, /*body=*/false,
+                                /*packed=*/false, RD);
     recordDeclTypes[key] = entry;
   }
 

clang/lib/CIR/CodeGen/CIRGenVTables.cpp

@@ -58,7 +58,7 @@ mlir::Type CIRGenVTables::getVTableType(const VTableLayout &layout) {
 
   // FIXME(cir): should VTableLayout be encoded like we do for some
   // AST nodes?
-  return mlir::cir::StructType::get(ctx, tys, "", /*body=*/true);
+  return CGM.getBuilder().getAnonStructTy(tys, /*body=*/true);
 }
 
 /// At this point in the translation unit, does it appear that can we

clang/lib/CIR/CodeGen/CIRRecordLayoutBuilder.cpp

@@ -571,9 +571,6 @@ CIRGenTypes::computeRecordLayout(const RecordDecl *D,
 
   builder.lower(/*nonVirtualBaseType=*/false);
 
-  auto name = getRecordTypeName(D, "");
-  auto identifier = mlir::StringAttr::get(&getMLIRContext(), name);
-
   // If we're in C++, compute the base subobject type.
   mlir::cir::StructType *BaseTy = nullptr;
   if (llvm::isa<CXXRecordDecl>(D) && !D->isUnion() &&
@@ -582,12 +579,9 @@ CIRGenTypes::computeRecordLayout(const RecordDecl *D,
     if (builder.astRecordLayout.getNonVirtualSize() !=
         builder.astRecordLayout.getSize()) {
       CIRRecordLowering baseBuilder(*this, D, /*Packed=*/builder.isPacked);
-      auto baseIdentifier =
-          mlir::StringAttr::get(&getMLIRContext(), name + ".base");
-      *BaseTy = mlir::cir::StructType::get(
-          &getMLIRContext(), baseBuilder.fieldTypes, baseIdentifier,
-          /*body=*/true, /**packed=*/false,
-          mlir::cir::ASTRecordDeclAttr::get(&getMLIRContext(), D));
+      auto baseIdentifier = getRecordTypeName(D, ".base");
+      *BaseTy = Builder.getStructTy(baseBuilder.fieldTypes, baseIdentifier,
+                                    /*body=*/true, /*packed=*/false, D);
       // TODO(cir): add something like addRecordTypeName
 
       // BaseTy and Ty must agree on their packedness for getCIRFieldNo to work
@@ -600,10 +594,8 @@ CIRGenTypes::computeRecordLayout(const RecordDecl *D,
   // Fill in the struct *after* computing the base type.  Filling in the body
   // signifies that the type is no longer opaque and record layout is complete,
   // but we may need to recursively layout D while laying D out as a base type.
-  *Ty = mlir::cir::StructType::get(
-      &getMLIRContext(), builder.fieldTypes, identifier,
-      /*body=*/true, /**packed=*/false,
-      mlir::cir::ASTRecordDeclAttr::get(&getMLIRContext(), D));
+  *Ty = Builder.getStructTy(builder.fieldTypes, getRecordTypeName(D, ""),
+                            /*body=*/true, /*packed=*/false, D);
 
   auto RL = std::make_unique<CIRGenRecordLayout>(
       Ty ? *Ty : mlir::cir::StructType{},

clang/lib/CIR/CodeGen/ConstantInitBuilder.cpp

@@ -277,19 +277,6 @@ static mlir::cir::ConstArrayAttr getConstArray(mlir::Attribute attrs,
                                                mlir::cir::ArrayType arrayTy) {
   return mlir::cir::ConstArrayAttr::get(arrayTy, attrs);
 }
-static mlir::Attribute getAnonConstStruct(mlir::ArrayAttr arrayAttr,
-                                          bool packed = false) {
-  assert(!packed && "NYI");
-  llvm::SmallVector<mlir::Type, 4> members;
-  for (auto &f : arrayAttr) {
-    auto ta = f.dyn_cast<mlir::TypedAttr>();
-    assert(ta && "expected typed attribute member");
-    members.push_back(ta.getType());
-  }
-  auto sTy = mlir::cir::StructType::get(arrayAttr.getContext(), members, "",
-                                        /*body=*/true);
-  return mlir::cir::ConstStructAttr::get(sTy, arrayAttr);
-}
 
 mlir::Attribute ConstantAggregateBuilderBase::finishArray(mlir::Type eltTy) {
   markFinished();
@@ -323,8 +310,6 @@ ConstantAggregateBuilderBase::finishStruct(mlir::MLIRContext *ctx,
 
   if (ty == nullptr && elts.empty()) {
     llvm_unreachable("NYI");
-    // ty = mlir::cir::StructType::get(Builder.CGM.getLLVMContext(), {},
-    // Packed);
   }
 
   mlir::Attribute constant;
@@ -333,8 +318,8 @@ ConstantAggregateBuilderBase::finishStruct(mlir::MLIRContext *ctx,
     // assert(ty->isPacked() == Packed);
     // constant = llvm::ConstantStruct::get(ty, elts);
   } else {
-    assert(!Packed && "NYI");
-    constant = getAnonConstStruct(mlir::ArrayAttr::get(ctx, elts), Packed);
+    const auto members = mlir::ArrayAttr::get(ctx, elts);
+    constant = Builder.CGM.getBuilder().getAnonConstStruct(members, Packed);
   }
 
   buffer.erase(buffer.begin() + Begin, buffer.end());