Revert "[CIR] Infrastructure: class CIRGenBuilderTy; cache CIR types (llvm#119037)"

lanza · lanza · commit 88b1d088fe0d · 2025-02-28T10:52:17.000-08:00
This reverts commit ffb19f4.
diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -29,22 +29,9 @@ CIRGenModule::CIRGenModule(mlir::MLIRContext &context,
                            clang::ASTContext &astctx,
                            const clang::CodeGenOptions &cgo,
                            DiagnosticsEngine &diags)
-    : builder(context, *this), astCtx(astctx), langOpts(astctx.getLangOpts()),
+    : builder(&context), astCtx(astctx), langOpts(astctx.getLangOpts()),
       theModule{mlir::ModuleOp::create(mlir::UnknownLoc::get(&context))},
-      diags(diags), target(astctx.getTargetInfo()), genTypes(*this) {
-
-  // Initialize cached types
-  SInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/true);
-  SInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/true);
-  SInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/true);
-  SInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/true);
-  SInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/true);
-  UInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/false);
-  UInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/false);
-  UInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/false);
-  UInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/false);
-  UInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/false);
-}
+      diags(diags), target(astCtx.getTargetInfo()), genTypes(*this) {}
 
 mlir::Location CIRGenModule::getLoc(SourceLocation cLoc) {
   assert(cLoc.isValid() && "expected valid source location");
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.h b/clang/lib/CIR/CodeGen/CIRGenModule.h
@@ -13,7 +13,6 @@
 #ifndef LLVM_CLANG_LIB_CIR_CODEGEN_CIRGENMODULE_H
 #define LLVM_CLANG_LIB_CIR_CODEGEN_CIRGENMODULE_H
 
-#include "CIRGenBuilder.h"
 #include "CIRGenTypeCache.h"
 #include "CIRGenTypes.h"
 
@@ -48,7 +47,9 @@ class CIRGenModule : public CIRGenTypeCache {
   ~CIRGenModule() = default;
 
 private:
-  CIRGenBuilderTy builder;
+  // TODO(CIR) 'builder' will change to CIRGenBuilderTy once that type is
+  // defined
+  mlir::OpBuilder builder;
 
   /// Hold Clang AST information.
   clang::ASTContext &astCtx;
@@ -66,10 +67,9 @@ class CIRGenModule : public CIRGenTypeCache {
 
 public:
   mlir::ModuleOp getModule() const { return theModule; }
-  CIRGenBuilderTy &getBuilder() { return builder; }
+  mlir::OpBuilder &getBuilder() { return builder; }
   clang::ASTContext &getASTContext() const { return astCtx; }
   CIRGenTypes &getTypes() { return genTypes; }
-  mlir::MLIRContext &getMLIRContext() { return *builder.getContext(); }
 
   /// Helpers to convert the presumed location of Clang's SourceLocation to an
   /// MLIR Location.
diff --git a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h b/clang/lib/CIR/CodeGen/CIRGenTypeCache.h
@@ -13,29 +13,13 @@
 #ifndef LLVM_CLANG_LIB_CIR_CIRGENTYPECACHE_H
 #define LLVM_CLANG_LIB_CIR_CIRGENTYPECACHE_H
 
-#include "clang/CIR/Dialect/IR/CIRTypes.h"
-
 namespace clang::CIRGen {
 
 /// This structure provides a set of types that are commonly used
 /// during IR emission. It's initialized once in CodeGenModule's
 /// constructor and then copied around into new CIRGenFunction's.
 struct CIRGenTypeCache {
   CIRGenTypeCache() = default;
-
-  // ClangIR signed integral types of common sizes
-  cir::IntType SInt8Ty;
-  cir::IntType SInt16Ty;
-  cir::IntType SInt32Ty;
-  cir::IntType SInt64Ty;
-  cir::IntType SInt128Ty;
-
-  // ClangIR unsigned integral type of common sizes
-  cir::IntType UInt8Ty;
-  cir::IntType UInt16Ty;
-  cir::IntType UInt32Ty;
-  cir::IntType UInt64Ty;
-  cir::IntType UInt128Ty;
 };
 
 } // namespace clang::CIRGen
diff --git a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp
@@ -9,32 +9,22 @@ using namespace clang;
 using namespace clang::CIRGen;
 
 CIRGenTypes::CIRGenTypes(CIRGenModule &genModule)
-    : cgm(genModule), context(genModule.getASTContext()),
-      builder(cgm.getBuilder()) {}
+    : cgm(genModule), context(genModule.getASTContext()) {}
 
 CIRGenTypes::~CIRGenTypes() {}
 
-mlir::MLIRContext &CIRGenTypes::getMLIRContext() const {
-  return *builder.getContext();
-}
-
 mlir::Type CIRGenTypes::convertType(QualType type) {
   type = context.getCanonicalType(type);
   const Type *ty = type.getTypePtr();
 
-  // Has the type already been processed?
-  TypeCacheTy::iterator tci = typeCache.find(ty);
-  if (tci != typeCache.end())
-    return tci->second;
-
   // For types that haven't been implemented yet or are otherwise unsupported,
   // report an error and return 'int'.
 
   mlir::Type resultType = nullptr;
   switch (ty->getTypeClass()) {
   case Type::Builtin: {
     switch (cast<BuiltinType>(ty)->getKind()) {
-    // Signed integral types.
+    // Signed types.
     case BuiltinType::Char_S:
     case BuiltinType::Int:
     case BuiltinType::Int128:
@@ -43,10 +33,11 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
     case BuiltinType::SChar:
     case BuiltinType::Short:
     case BuiltinType::WChar_S:
-      resultType = cir::IntType::get(&getMLIRContext(), context.getTypeSize(ty),
+      resultType = cir::IntType::get(cgm.getBuilder().getContext(),
+                                     context.getTypeSize(ty),
                                      /*isSigned=*/true);
       break;
-    // Unsigned integral types.
+    // Unsigned types.
     case BuiltinType::Char8:
     case BuiltinType::Char16:
     case BuiltinType::Char32:
@@ -58,12 +49,14 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
     case BuiltinType::ULongLong:
     case BuiltinType::UShort:
     case BuiltinType::WChar_U:
-      resultType = cir::IntType::get(&getMLIRContext(), context.getTypeSize(ty),
+      resultType = cir::IntType::get(cgm.getBuilder().getContext(),
+                                     context.getTypeSize(ty),
                                      /*isSigned=*/false);
       break;
     default:
       cgm.errorNYI(SourceLocation(), "processing of built-in type", type);
-      resultType = cgm.SInt32Ty;
+      resultType = cir::IntType::get(cgm.getBuilder().getContext(), 32,
+                                     /*isSigned=*/true);
       break;
     }
     break;
@@ -72,21 +65,23 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
     const auto *bitIntTy = cast<BitIntType>(type);
     if (bitIntTy->getNumBits() > cir::IntType::maxBitwidth()) {
       cgm.errorNYI(SourceLocation(), "large _BitInt type", type);
-      resultType = cgm.SInt32Ty;
+      resultType = cir::IntType::get(cgm.getBuilder().getContext(), 32,
+                                     /*isSigned=*/true);
     } else {
-      resultType = cir::IntType::get(&getMLIRContext(), bitIntTy->getNumBits(),
-                                     bitIntTy->isSigned());
+      resultType =
+          cir::IntType::get(cgm.getBuilder().getContext(),
+                            bitIntTy->getNumBits(), bitIntTy->isSigned());
     }
     break;
   }
   default:
     cgm.errorNYI(SourceLocation(), "processing of type", type);
-    resultType = cgm.SInt32Ty;
+    resultType =
+        cir::IntType::get(cgm.getBuilder().getContext(), 32, /*isSigned=*/true);
     break;
   }
 
   assert(resultType && "Type conversion not yet implemented");
 
-  typeCache[ty] = resultType;
   return resultType;
 }
diff --git a/clang/lib/CIR/CodeGen/CIRGenTypes.h b/clang/lib/CIR/CodeGen/CIRGenTypes.h
@@ -15,12 +15,9 @@
 
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
 
-#include "llvm/ADT/SmallPtrSet.h"
-
 namespace clang {
 class ASTContext;
 class QualType;
-class Type;
 } // namespace clang
 
 namespace mlir {
@@ -29,27 +26,18 @@ class Type;
 
 namespace clang::CIRGen {
 
-class CIRGenBuilderTy;
 class CIRGenModule;
 
 /// This class organizes the cross-module state that is used while lowering
 /// AST types to CIR types.
 class CIRGenTypes {
   CIRGenModule &cgm;
   clang::ASTContext &context;
-  CIRGenBuilderTy &builder;
 
 public:
   CIRGenTypes(CIRGenModule &cgm);
   ~CIRGenTypes();
 
-  /// This map of clang::Type to mlir::Type (which includes CIR type) is a
-  /// cache of types that have already been processed.
-  using TypeCacheTy = llvm::DenseMap<const clang::Type *, mlir::Type>;
-  TypeCacheTy typeCache;
-
-  mlir::MLIRContext &getMLIRContext() const;
-
   /// Convert a Clang type into a mlir::Type.
   mlir::Type convertType(clang::QualType type);
 };
