Recommit [CIR][Pipeline] Support -fclangir-analysis-only (llvm#832)

Reland llvm#638

This was reverted due to llvm#655. I
tried to address the problem in the newest commit.

The changes of the PR since the last landed one includes:
- Move the definition of `cir::CIRGenConsumer` to
`clang/include/clang/CIRFrontendAction/CIRGenConsumer.h`, and leave its
`HandleTranslationUnit` interface is left empty. So that
`cir::CIRGenConsumer` won't need to depend on CodeGen any more.
- Change the old definition of `cir::CIRGenConsumer` in
`clang/lib/CIR/FrontendAction/CIRGenAction.cpp` and to
`CIRLoweringConsumer`, inherited from `cir::CIRGenConsumer`, which
implements the original `HandleTranslationUnit` interface.

I feel this may improve the readability more even without my original
patch.

Author: ChuanqiXu9

clang/include/clang/CIRFrontendAction/CIRGenAction.h

@@ -9,6 +9,7 @@
 #ifndef LLVM_CLANG_CIR_CIRGENACTION_H
 #define LLVM_CLANG_CIR_CIRGENACTION_H
 
+#include "clang/CodeGen/CodeGenAction.h"
 #include "clang/Frontend/FrontendAction.h"
 #include <memory>
 
@@ -128,6 +129,60 @@ class EmitObjAction : public CIRGenAction {
   EmitObjAction(mlir::MLIRContext *mlirCtx = nullptr);
 };
 
+// Used for -fclangir-analysis-only: use CIR analysis but still use original LLVM codegen path
+class AnalysisOnlyActionBase : public clang::CodeGenAction {
+  virtual void anchor();
+
+protected:
+  std::unique_ptr<clang::ASTConsumer>
+  CreateASTConsumer(clang::CompilerInstance &CI,
+                    llvm::StringRef InFile) override;
+
+  AnalysisOnlyActionBase(unsigned _Act,
+                         llvm::LLVMContext *_VMContext = nullptr);
+};
+
+class AnalysisOnlyAndEmitAssemblyAction : public AnalysisOnlyActionBase {
+  virtual void anchor() override;
+
+public:
+  AnalysisOnlyAndEmitAssemblyAction(llvm::LLVMContext *_VMContext = nullptr);
+};
+
+class AnalysisOnlyAndEmitBCAction : public AnalysisOnlyActionBase {
+  virtual void anchor() override;
+
+public:
+  AnalysisOnlyAndEmitBCAction(llvm::LLVMContext *_VMContext = nullptr);
+};
+
+class AnalysisOnlyAndEmitLLVMAction : public AnalysisOnlyActionBase {
+  virtual void anchor() override;
+
+public:
+  AnalysisOnlyAndEmitLLVMAction(llvm::LLVMContext *_VMContext = nullptr);
+};
+
+class AnalysisOnlyAndEmitLLVMOnlyAction : public AnalysisOnlyActionBase {
+  virtual void anchor() override;
+
+public:
+  AnalysisOnlyAndEmitLLVMOnlyAction(llvm::LLVMContext *_VMContext = nullptr);
+};
+
+class AnalysisOnlyAndEmitCodeGenOnlyAction : public AnalysisOnlyActionBase {
+  virtual void anchor() override;
+
+public:
+  AnalysisOnlyAndEmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext = nullptr);
+};
+
+class AnalysisOnlyAndEmitObjAction : public AnalysisOnlyActionBase {
+  virtual void anchor() override;
+
+public:
+  AnalysisOnlyAndEmitObjAction(llvm::LLVMContext *_VMContext = nullptr);
+};
 } // namespace cir
 
 #endif

clang/include/clang/CIRFrontendAction/CIRGenConsumer.h

@@ -3066,6 +3066,11 @@ defm clangir_direct_lowering : BoolFOption<"clangir-direct-lowering",
   FrontendOpts<"ClangIRDirectLowering">, DefaultTrue,
   PosFlag<SetTrue, [], [ClangOption, CC1Option], "Lower directly from ClangIR to LLVM">,
   NegFlag<SetFalse, [], [ClangOption, CC1Option],  "Lower through MLIR to LLVM">>;
+defm clangir_analysis_only : BoolFOption<"clangir-analysis-only",
+  FrontendOpts<"ClangIRAnalysisOnly">, DefaultFalse,
+  PosFlag<SetTrue, [], [ClangOption, CC1Option],
+    "Enable CIR analysis but keep traditional LLVM codegen (not through CIR)">,
+  NegFlag<SetFalse, [], [ClangOption, CC1Option],  "">>;
 
 def emit_cir : Flag<["-"], "emit-cir">, Visibility<[CC1Option]>,
   Group<Action_Group>, HelpText<"Build ASTs and then lower to ClangIR, emit the .cir file">;

clang/include/clang/Driver/Options.td

@@ -454,6 +454,10 @@ class FrontendOptions {
   // Enable Clang IR mem2reg pass on the flat CIR.
   unsigned ClangIREnableMem2Reg : 1;
 
+  // Enable Clang IR analysis only pipeline that uses tranditional code gen
+  // pipeline.
+  unsigned ClangIRAnalysisOnly : 1;
+
   CodeCompleteOptions CodeCompleteOpts;
 
   /// Specifies the output format of the AST.
@@ -653,7 +657,8 @@ class FrontendOptions {
         ClangIRDisablePasses(false), ClangIRDisableCIRVerifier(false),
         ClangIRDisableEmitCXXDefault(false), ClangIRLifetimeCheck(false),
         ClangIRIdiomRecognizer(false), ClangIRLibOpt(false),
-        TimeTraceGranularity(500), TimeTraceVerbose(false) {}
+        ClangIRAnalysisOnly(false), TimeTraceGranularity(500),
+        TimeTraceVerbose(false) {}
 
   /// getInputKindForExtension - Return the appropriate input kind for a file
   /// extension. For example, "c" would return Language::C.

clang/include/clang/Frontend/FrontendOptions.h

@@ -32,6 +32,7 @@
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
+#include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/IR/DebugInfo.h"
@@ -439,6 +440,7 @@ void CIRGenAction::ExecuteAction() {
     llvmModule->print(*outstream, nullptr);
 }
 
+namespace cir {
 void EmitAssemblyAction::anchor() {}
 EmitAssemblyAction::EmitAssemblyAction(mlir::MLIRContext *_MLIRContext)
     : CIRGenAction(OutputType::EmitAssembly, _MLIRContext) {}
@@ -470,3 +472,52 @@ EmitBCAction::EmitBCAction(mlir::MLIRContext *_MLIRContext)
 void EmitObjAction::anchor() {}
 EmitObjAction::EmitObjAction(mlir::MLIRContext *_MLIRContext)
     : CIRGenAction(OutputType::EmitObj, _MLIRContext) {}
+} // namespace cir
+
+// Used for -fclangir-analysis-only: use CIR analysis but still use original LLVM codegen path
+void AnalysisOnlyActionBase::anchor() {}
+AnalysisOnlyActionBase::AnalysisOnlyActionBase(unsigned _Act,
+                                               llvm::LLVMContext *_VMContext)
+    : clang::CodeGenAction(_Act, _VMContext) {}
+
+std::unique_ptr<ASTConsumer>
+AnalysisOnlyActionBase::CreateASTConsumer(clang::CompilerInstance &ci,
+                                          llvm::StringRef inFile) {
+  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
+  Consumers.push_back(clang::CodeGenAction::CreateASTConsumer(ci, inFile));
+  Consumers.push_back(std::make_unique<cir::CIRGenConsumer>(
+      CIRGenAction::OutputType::None, ci.getDiagnostics(),
+      &ci.getVirtualFileSystem(), ci.getHeaderSearchOpts(), ci.getCodeGenOpts(),
+      ci.getTargetOpts(), ci.getLangOpts(), ci.getFrontendOpts(), nullptr));
+  return std::make_unique<MultiplexConsumer>(std::move(Consumers));
+}
+
+void AnalysisOnlyAndEmitAssemblyAction::anchor() {}
+AnalysisOnlyAndEmitAssemblyAction::AnalysisOnlyAndEmitAssemblyAction(
+    llvm::LLVMContext *_VMContext)
+    : AnalysisOnlyActionBase(Backend_EmitAssembly, _VMContext) {}
+
+void AnalysisOnlyAndEmitBCAction::anchor() {}
+AnalysisOnlyAndEmitBCAction::AnalysisOnlyAndEmitBCAction(
+    llvm::LLVMContext *_VMContext)
+    : AnalysisOnlyActionBase(Backend_EmitBC, _VMContext) {}
+
+void AnalysisOnlyAndEmitLLVMAction::anchor() {}
+AnalysisOnlyAndEmitLLVMAction::AnalysisOnlyAndEmitLLVMAction(
+    llvm::LLVMContext *_VMContext)
+    : AnalysisOnlyActionBase(Backend_EmitLL, _VMContext) {}
+
+void AnalysisOnlyAndEmitLLVMOnlyAction::anchor() {}
+AnalysisOnlyAndEmitLLVMOnlyAction::AnalysisOnlyAndEmitLLVMOnlyAction(
+    llvm::LLVMContext *_VMContext)
+    : AnalysisOnlyActionBase(Backend_EmitNothing, _VMContext) {}
+
+void AnalysisOnlyAndEmitCodeGenOnlyAction::anchor() {}
+AnalysisOnlyAndEmitCodeGenOnlyAction::AnalysisOnlyAndEmitCodeGenOnlyAction(
+    llvm::LLVMContext *_VMContext)
+    : AnalysisOnlyActionBase(Backend_EmitMCNull, _VMContext) {}
+
+void AnalysisOnlyAndEmitObjAction::anchor() {}
+AnalysisOnlyAndEmitObjAction::AnalysisOnlyAndEmitObjAction(
+    llvm::LLVMContext *_VMContext)
+    : AnalysisOnlyActionBase(Backend_EmitObj, _VMContext) {}

clang/lib/CIR/FrontendAction/CIRGenAction.cpp

@@ -5164,6 +5164,15 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
       CmdArgs.push_back("-fclangir-idiom-recognizer");
   }
 
+  if (Args.hasArg(options::OPT_fclangir_analysis_only)) {
+    CmdArgs.push_back("-fclangir-analysis-only");
+
+    // TODO: We should pass some default analysis configuration here.
+
+    // TODO2: Should we emit some diagnostics if the configurations conflict
+    // with each other?
+  }
+
   if (IsOpenMPDevice) {
     // We have to pass the triple of the host if compiling for an OpenMP device.
     std::string NormalizedTriple =

clang/lib/Driver/ToolChains/Clang.cpp

@@ -3059,6 +3059,9 @@ static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
   if (Args.hasArg(OPT_fclangir_call_conv_lowering))
     Opts.ClangIREnableCallConvLowering = true;
 
+  if (Args.hasArg(OPT_fclangir_analysis_only))
+    Opts.ClangIRAnalysisOnly = true;
+
   if (const Arg *A = Args.getLastArg(OPT_fclangir_lifetime_check,
                                      OPT_fclangir_lifetime_check_EQ)) {
     Opts.ClangIRLifetimeCheck = true;

clang/lib/Frontend/CompilerInvocation.cpp

@@ -53,6 +53,7 @@ CreateFrontendBaseAction(CompilerInstance &CI) {
 
   auto UseCIR = CI.getFrontendOpts().UseClangIRPipeline;
   auto Act = CI.getFrontendOpts().ProgramAction;
+  auto CIRAnalysisOnly = CI.getFrontendOpts().ClangIRAnalysisOnly;
   auto EmitsCIR = Act == EmitCIR || Act == EmitCIRFlat || Act == EmitCIROnly;
 
   if (!UseCIR && EmitsCIR)
@@ -76,12 +77,16 @@ CreateFrontendBaseAction(CompilerInstance &CI) {
 #if CLANG_ENABLE_CIR
     if (UseCIR)
       return std::make_unique<::cir::EmitAssemblyAction>();
+    if (CIRAnalysisOnly)
+      return std::make_unique<::cir::AnalysisOnlyAndEmitAssemblyAction>();
 #endif
     return std::make_unique<EmitAssemblyAction>();
   case EmitBC: {
 #if CLANG_ENABLE_CIR
     if (UseCIR)
       return std::make_unique<::cir::EmitBCAction>();
+    if (CIRAnalysisOnly)
+      return std::make_unique<::cir::AnalysisOnlyAndEmitBCAction>();
 #endif
     return std::make_unique<EmitBCAction>();
   }
@@ -102,15 +107,31 @@ CreateFrontendBaseAction(CompilerInstance &CI) {
 #if CLANG_ENABLE_CIR
     if (UseCIR)
       return std::make_unique<::cir::EmitLLVMAction>();
+    if (CIRAnalysisOnly)
+      return std::make_unique<::cir::AnalysisOnlyAndEmitLLVMAction>();
 #endif
     return std::make_unique<EmitLLVMAction>();
   }
-  case EmitLLVMOnly:           return std::make_unique<EmitLLVMOnlyAction>();
-  case EmitCodeGenOnly:        return std::make_unique<EmitCodeGenOnlyAction>();
+  case EmitLLVMOnly: {
+#if CLANG_ENABLE_CIR
+    if (CIRAnalysisOnly)
+      return std::make_unique<::cir::AnalysisOnlyAndEmitLLVMOnlyAction>();
+#endif
+    return std::make_unique<EmitLLVMOnlyAction>();
+  }
+  case EmitCodeGenOnly: {
+#if CLANG_ENABLE_CIR
+    if (CIRAnalysisOnly)
+      return std::make_unique<::cir::AnalysisOnlyAndEmitLLVMOnlyAction>();
+#endif
+    return std::make_unique<EmitCodeGenOnlyAction>();
+  }
   case EmitObj: {
 #if CLANG_ENABLE_CIR
     if (UseCIR)
       return std::make_unique<::cir::EmitObjAction>();
+    if (CIRAnalysisOnly)
+      return std::make_unique<::cir::AnalysisOnlyAndEmitObjAction>();
 #endif
     return std::make_unique<EmitObjAction>();
   }

clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

@@ -0,0 +1,8 @@
+// Check `-fclangir-analysis-only` would generate code correctly.
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir-analysis-only -std=c++20 \
+// RUN:     -O2 -emit-llvm %s -o - | FileCheck %s
+
+extern "C" void foo() {}
+
+// CHECK: define{{.*}} @foo(
+

clang/test/CIR/CodeGen/analysis-only.cpp

@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -mconstructor-aliases -fclangir -clangir-disable-emit-cxx-default -fclangir-lifetime-check="history=all;remarks=all" -clangir-verify-diagnostics -emit-cir %s -o %t.cir
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -mconstructor-aliases -fclangir-analysis-only -fclangir-lifetime-check="history=all;remarks=all" %s -clangir-verify-diagnostics -emit-obj -o /dev/null
 
 typedef enum SType {
   INFO_ENUM_0 = 9,