[CIR][NFC] Break default method emission to run after CIR passes

This prevents us from doing unecessary codegen until we need the
body of default methods. Some analysis won't require going inside
such methods.

In the future we should only enable the codegen in the pipeline
that goes out to LLVM codegen.

Author: bcardosolopes

clang/include/clang/CIR/CIRGenerator.h

@@ -92,6 +92,7 @@ class CIRGenerator : public clang::ASTConsumer {
   bool verifyModule();
 
   void buildDeferredDecls();
+  void buildDefaultMethods();
 };
 
 } // namespace cir

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -1471,6 +1471,14 @@ mlir::cir::FuncOp CIRGenModule::createCIRFunction(mlir::Location loc,
   return f;
 }
 
+bool isDefaultedMethod(const clang::FunctionDecl *FD) {
+  if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&
+      (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
+       cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator()))
+    return true;
+  return false;
+}
+
 /// If the specified mangled name is not in the module,
 /// create and return a CIR Function with the specified type. If there is
 /// something in the module with the specified name, return it potentially
@@ -1608,7 +1616,10 @@ mlir::cir::FuncOp CIRGenModule::GetOrCreateCIRFunction(
            FD = FD->getPreviousDecl()) {
         if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
           if (FD->doesThisDeclarationHaveABody()) {
-            addDeferredDeclToEmit(GD.getWithDecl(FD));
+            if (isDefaultedMethod(FD))
+              addDefaultMethodsToEmit(GD.getWithDecl(FD));
+            else
+              addDeferredDeclToEmit(GD.getWithDecl(FD));
             break;
           }
         }
@@ -1646,6 +1657,44 @@ mlir::Location CIRGenModule::getLoc(mlir::Location lhs, mlir::Location rhs) {
   return mlir::FusedLoc::get(locs, metadata, builder.getContext());
 }
 
+void CIRGenModule::buildGlobalDecl(clang::GlobalDecl &D) {
+  // We should call GetAddrOfGlobal with IsForDefinition set to true in order
+  // to get a Value with exactly the type we need, not something that might
+  // have been created for another decl with the same mangled name but
+  // different type.
+  auto *Op = GetAddrOfGlobal(D, ForDefinition);
+
+  // In case of different address spaces, we may still get a cast, even with
+  // IsForDefinition equal to true. Query mangled names table to get
+  // GlobalValue.
+  if (!Op) {
+    Op = getGlobalValue(getMangledName(D));
+  }
+
+  // Make sure getGlobalValue returned non-null.
+  assert(Op);
+  assert(isa<mlir::cir::FuncOp>(Op) &&
+         "not implemented, only supports FuncOp for now");
+
+  // Check to see if we've already emitted this. This is necessary for a
+  // couple of reasons: first, decls can end up in deferred-decls queue
+  // multiple times, and second, decls can end up with definitions in unusual
+  // ways (e.g. by an extern inline function acquiring a strong function
+  // redefinition). Just ignore those cases.
+  // TODO: Not sure what to map this to for MLIR
+  if (auto Fn = cast<mlir::cir::FuncOp>(Op))
+    if (!Fn.isDeclaration())
+      return;
+
+  // If this is OpenMP, check if it is legal to emit this global normally.
+  if (getLangOpts().OpenMP) {
+    llvm_unreachable("NYI");
+  }
+
+  // Otherwise, emit the definition and move on to the next one.
+  buildGlobalDefinition(D, Op);
+}
+
 void CIRGenModule::buildDeferred() {
   // Emit deferred declare target declarations
   if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd)
@@ -1676,41 +1725,7 @@ void CIRGenModule::buildDeferred() {
   CurDeclsToEmit.swap(DeferredDeclsToEmit);
 
   for (auto &D : CurDeclsToEmit) {
-    // We should call GetAddrOfGlobal with IsForDefinition set to true in order
-    // to get a Value with exactly the type we need, not something that might
-    // have been created for another decl with the same mangled name but
-    // different type.
-    auto *Op = GetAddrOfGlobal(D, ForDefinition);
-
-    // In case of different address spaces, we may still get a cast, even with
-    // IsForDefinition equal to true. Query mangled names table to get
-    // GlobalValue.
-    if (!Op) {
-      Op = getGlobalValue(getMangledName(D));
-    }
-
-    // Make sure getGlobalValue returned non-null.
-    assert(Op);
-    assert(isa<mlir::cir::FuncOp>(Op) &&
-           "not implemented, only supports FuncOp for now");
-
-    // Check to see if we've already emitted this. This is necessary for a
-    // couple of reasons: first, decls can end up in deferred-decls queue
-    // multiple times, and second, decls can end up with definitions in unusual
-    // ways (e.g. by an extern inline function acquiring a strong function
-    // redefinition). Just ignore those cases.
-    // TODO: Not sure what to map this to for MLIR
-    if (auto Fn = cast<mlir::cir::FuncOp>(Op))
-      if (!Fn.isDeclaration())
-        continue;
-
-    // If this is OpenMP, check if it is legal to emit this global normally.
-    if (getLangOpts().OpenMP) {
-      llvm_unreachable("NYI");
-    }
-
-    // Otherwise, emit the definition and move on to the next one.
-    buildGlobalDefinition(D, Op);
+    buildGlobalDecl(D);
 
     // If we found out that we need to emit more decls, do that recursively.
     // This has the advantage that the decls are emitted in a DFS and related
@@ -1722,6 +1737,13 @@ void CIRGenModule::buildDeferred() {
   }
 }
 
+void CIRGenModule::buildDefaultMethods() {
+  // Differently from DeferredDeclsToEmit, there's no recurrent use of
+  // DefaultMethodsToEmit, so use it directly for emission.
+  for (auto &D : DefaultMethodsToEmit)
+    buildGlobalDecl(D);
+}
+
 mlir::IntegerAttr CIRGenModule::getSize(CharUnits size) {
   return mlir::IntegerAttr::get(
       mlir::IntegerType::get(builder.getContext(), 64), size.getQuantity());

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -262,6 +262,14 @@ class CIRGenModule {
     DeferredDeclsToEmit.emplace_back(GD);
   }
 
+  // After HandleTranslation finishes, differently from DeferredDeclsToEmit,
+  // DefaultMethodsToEmit is only called after a set of CIR passes run. See
+  // addDefaultMethodsToEmit usage for examples.
+  std::vector<clang::GlobalDecl> DefaultMethodsToEmit;
+  void addDefaultMethodsToEmit(clang::GlobalDecl GD) {
+    DefaultMethodsToEmit.emplace_back(GD);
+  }
+
   std::pair<mlir::FunctionType, mlir::cir::FuncOp> getAddrAndTypeOfCXXStructor(
       clang::GlobalDecl GD, const CIRGenFunctionInfo *FnInfo = nullptr,
       mlir::FunctionType FnType = nullptr, bool Dontdefer = false,
@@ -329,6 +337,12 @@ class CIRGenModule {
   /// Emit any needed decls for which code generation was deferred.
   void buildDeferred();
 
+  /// Helper for `buildDeferred` to apply actual codegen.
+  void buildGlobalDecl(clang::GlobalDecl &D);
+
+  /// Build default methods not emitted before this point.
+  void buildDefaultMethods();
+
   const llvm::Triple &getTriple() const { return target.getTriple(); }
 
   // Finalize CIR code generation.

clang/lib/CIR/CodeGen/CIRGenerator.cpp

@@ -106,6 +106,8 @@ void CIRGenerator::HandleInlineFunctionDefinition(FunctionDecl *D) {
     CGM->AddDeferredUnusedCoverageMapping(D);
 }
 
+void CIRGenerator::buildDefaultMethods() { CGM->buildDefaultMethods(); }
+
 void CIRGenerator::buildDeferredDecls() {
   if (DeferredInlineMemberFuncDefs.empty())
     return;

clang/lib/CIR/FrontendAction/CIRGenAction.cpp

@@ -143,12 +143,19 @@ class CIRGenConsumer : public clang::ASTConsumer {
     switch (action) {
     case CIRGenAction::OutputType::EmitCIR:
       if (outputStream && mlirMod) {
+
+        // Run CIR cleanup, in the future also the relevent raising and
+        // some code analysis.
         if (!feOptions.DisableCIRPasses) {
           runCIRToCIRPasses(mlirMod, mlirCtx.get(),
                             !feOptions.DisableCIRVerifier);
         }
-        mlir::OpPrintingFlags flags;
+
+        // Emit remaining defaulted C++ methods
+        gen->buildDefaultMethods();
+
         // FIXME: we cannot roundtrip prettyForm=true right now.
+        mlir::OpPrintingFlags flags;
         flags.enableDebugInfo(/*prettyForm=*/false);
         mlirMod->print(*outputStream, flags);
       }