[CIR] Add option to emit MLIR in LLVM dialect.

clang/include/clang/CIR/LowerToLLVM.h

@@ -29,13 +29,19 @@ class ModuleOp;
 namespace cir {
 
 namespace direct {
+mlir::ModuleOp lowerDirectlyFromCIRToLLVMDialect(mlir::ModuleOp theModule,
+                                                 bool disableVerifier = false,
+                                                 bool disableCCLowering = false,
+                                                 bool disableDebugInfo = false);
+
+// Lower directly from pristine CIR to LLVMIR.
 std::unique_ptr<llvm::Module> lowerDirectlyFromCIRToLLVMIR(
     mlir::ModuleOp theModule, llvm::LLVMContext &llvmCtx,
     bool disableVerifier = false, bool disableCCLowering = false,
     bool disableDebugInfo = false);
-}
 
-// Lower directly from pristine CIR to LLVMIR.
+} // namespace direct
+
 std::unique_ptr<llvm::Module>
 lowerFromCIRToMLIRToLLVMIR(mlir::ModuleOp theModule,
                            std::unique_ptr<mlir::MLIRContext> mlirCtx,

clang/include/clang/CIR/LowerToMLIR.h

@@ -12,10 +12,16 @@
 #ifndef CLANG_CIR_LOWERTOMLIR_H
 #define CLANG_CIR_LOWERTOMLIR_H
 
+#include "mlir/Transforms/DialectConversion.h"
+
 namespace cir {
 
 void populateCIRLoopToSCFConversionPatterns(mlir::RewritePatternSet &patterns,
                                             mlir::TypeConverter &converter);
+
+mlir::ModuleOp
+lowerFromCIRToMLIRToLLVMDialect(mlir::ModuleOp theModule,
+                                mlir::MLIRContext *mlirCtx = nullptr);
 } // namespace cir
 
 #endif // CLANG_CIR_LOWERTOMLIR_H_

clang/include/clang/Driver/Options.td

@@ -3120,7 +3120,16 @@ def emit_cir_only : Flag<["-"], "emit-cir-only">,
 def emit_cir_flat : Flag<["-"], "emit-cir-flat">, Visibility<[ClangOption, CC1Option]>,
   Group<Action_Group>, HelpText<"Similar to -emit-cir but also lowers structured CFG into basic blocks.">;
 def emit_mlir : Flag<["-"], "emit-mlir">, Visibility<[CC1Option]>, Group<Action_Group>,
-  HelpText<"Build ASTs and then lower through ClangIR to MLIR, emit the .milr file">;
+  HelpText<"Build ASTs and then lower through ClangIR to MLIR (standard dialects "
+  "when `-fno-clangir-direct-lowering` is used or the LLVM dialect when "
+  "`-fclangir-direct-lowering` is used), emit the .mlir file.">;
+def emit_mlir_EQ : Joined<["-"], "emit-mlir=">, Visibility<[CC1Option]>, Group<Action_Group>,
+  HelpText<"Build ASTs and then lower through ClangIR to the selected MLIR dialect, emit the .mlir file. "
+  "Allowed values are `std` for MLIR standard dialects and `llvm` for the LLVM dialect.">,
+  Values<"std,llvm">,
+  NormalizedValuesScope<"FrontendOptions">,
+  NormalizedValues<["MLIR_STD", "MLIR_LLVM"]>,
+  MarshallingInfoEnum<FrontendOpts<"MLIRTargetDialect">, "MLIR_Default">;
 /// ClangIR-specific options - END
 
 def flto : Flag<["-"], "flto">,

clang/include/clang/Frontend/FrontendOptions.h

@@ -530,6 +530,8 @@ class FrontendOptions {
   std::string ClangIRIdiomRecognizerOpts;
   std::string ClangIRLibOptOpts;
 
+  enum { MLIR_Default, MLIR_STD, MLIR_LLVM } MLIRTargetDialect = MLIR_Default;
+
   /// The input kind, either specified via -x argument or deduced from the input
   /// file name.
   InputKind DashX;

clang/lib/CIR/FrontendAction/CIRGenAction.cpp

@@ -26,6 +26,7 @@
 #include "clang/CIR/CIRToCIRPasses.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/LowerToLLVM.h"
+#include "clang/CIR/LowerToMLIR.h"
 #include "clang/CIR/Passes.h"
 #include "clang/CodeGen/BackendUtil.h"
 #include "clang/CodeGen/ModuleBuilder.h"
@@ -273,7 +274,20 @@ class CIRGenConsumer : public clang::ASTConsumer {
       }
       break;
     case CIRGenAction::OutputType::EmitMLIR: {
-      auto loweredMlirModule = lowerFromCIRToMLIR(mlirMod, mlirCtx.get());
+      mlir::ModuleOp loweredMlirModule;
+      if (feOptions.ClangIRDirectLowering) {
+        // Attempting to emit std with direct lowering is already checked by
+        // Compiler Invocation
+        loweredMlirModule = direct::lowerDirectlyFromCIRToLLVMDialect(mlirMod);
+      } else {
+        if (feOptions.MLIRTargetDialect == clang::FrontendOptions::MLIR_LLVM)
+          loweredMlirModule =
+              lowerFromCIRToMLIRToLLVMDialect(mlirMod, mlirCtx.get());
+        else // STD and Default cases
+          loweredMlirModule = lowerFromCIRToMLIR(mlirMod, mlirCtx.get());
+      }
+      assert(loweredMlirModule &&
+             "MLIR module does not exist, but lowering did not fail?");
       assert(outputStream && "Why are we here without an output stream?");
       // FIXME: we cannot roundtrip prettyForm=true right now.
       mlir::OpPrintingFlags flags;

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -4689,11 +4689,11 @@ void populateCIRToLLVMPasses(mlir::OpPassManager &pm, bool useCCLowering) {
 
 extern void registerCIRDialectTranslation(mlir::MLIRContext &context);
 
-std::unique_ptr<llvm::Module>
-lowerDirectlyFromCIRToLLVMIR(mlir::ModuleOp theModule, LLVMContext &llvmCtx,
-                             bool disableVerifier, bool disableCCLowering,
-                             bool disableDebugInfo) {
-  llvm::TimeTraceScope scope("lower from CIR to LLVM directly");
+mlir::ModuleOp lowerDirectlyFromCIRToLLVMDialect(mlir::ModuleOp theModule,
+                                                 bool disableVerifier,
+                                                 bool disableCCLowering,
+                                                 bool disableDebugInfo) {
+  llvm::TimeTraceScope scope("lower from CIR to LLVM Dialect");
 
   mlir::MLIRContext *mlirCtx = theModule.getContext();
   mlir::PassManager pm(mlirCtx);
@@ -4722,6 +4722,20 @@ lowerDirectlyFromCIRToLLVMIR(mlir::ModuleOp theModule, LLVMContext &llvmCtx,
   if (theModule.verify().failed())
     report_fatal_error("Verification of the final LLVMIR dialect failed!");
 
+  return theModule;
+}
+
+std::unique_ptr<llvm::Module>
+lowerDirectlyFromCIRToLLVMIR(mlir::ModuleOp theModule, LLVMContext &llvmCtx,
+                             bool disableVerifier, bool disableCCLowering,
+                             bool disableDebugInfo) {
+  llvm::TimeTraceScope scope("lower from CIR to LLVM directly");
+
+  lowerDirectlyFromCIRToLLVMDialect(theModule, disableVerifier,
+                                    disableCCLowering, disableDebugInfo);
+
+  mlir::MLIRContext *mlirCtx = theModule.getContext();
+
   mlir::registerBuiltinDialectTranslation(*mlirCtx);
   mlir::registerLLVMDialectTranslation(*mlirCtx);
   mlir::registerOpenMPDialectTranslation(*mlirCtx);

clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp

@@ -47,6 +47,7 @@
 #include "mlir/Transforms/DialectConversion.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include "clang/CIR/LowerToLLVM.h"
 #include "clang/CIR/LowerToMLIR.h"
 #include "clang/CIR/LoweringHelpers.h"
 #include "clang/CIR/Passes.h"
@@ -1458,13 +1459,14 @@ void ConvertCIRToMLIRPass::runOnOperation() {
     signalPassFailure();
 }
 
-std::unique_ptr<llvm::Module>
-lowerFromCIRToMLIRToLLVMIR(mlir::ModuleOp theModule,
-                           std::unique_ptr<mlir::MLIRContext> mlirCtx,
-                           LLVMContext &llvmCtx) {
-  llvm::TimeTraceScope scope("Lower from CIR to MLIR To LLVM");
+mlir::ModuleOp lowerFromCIRToMLIRToLLVMDialect(mlir::ModuleOp theModule,
+                                               mlir::MLIRContext *mlirCtx) {
+  llvm::TimeTraceScope scope("Lower from CIR to MLIR To LLVM Dialect");
+  if (!mlirCtx) {
+    mlirCtx = theModule.getContext();
+  }
 
-  mlir::PassManager pm(mlirCtx.get());
+  mlir::PassManager pm(mlirCtx);
 
   pm.addPass(createConvertCIRToMLIRPass());
   pm.addPass(createConvertMLIRToLLVMPass());
@@ -1478,6 +1480,17 @@ lowerFromCIRToMLIRToLLVMIR(mlir::ModuleOp theModule,
   if (theModule.verify().failed())
     report_fatal_error("Verification of the final LLVMIR dialect failed!");
 
+  return theModule;
+}
+
+std::unique_ptr<llvm::Module>
+lowerFromCIRToMLIRToLLVMIR(mlir::ModuleOp theModule,
+                           std::unique_ptr<mlir::MLIRContext> mlirCtx,
+                           LLVMContext &llvmCtx) {
+  llvm::TimeTraceScope scope("Lower from CIR to MLIR To LLVM");
+
+  lowerFromCIRToMLIRToLLVMDialect(theModule, mlirCtx.get());
+
   mlir::registerBuiltinDialectTranslation(*mlirCtx);
   mlir::registerLLVMDialectTranslation(*mlirCtx);
   mlir::registerOpenMPDialectTranslation(*mlirCtx);

clang/lib/Frontend/CompilerInvocation.cpp

@@ -2738,6 +2738,7 @@ static const auto &getFrontendActionTable() {
       {frontend::EmitCIRFlat, OPT_emit_cir_flat},
       {frontend::EmitCIROnly, OPT_emit_cir_only},
       {frontend::EmitMLIR, OPT_emit_mlir},
+      {frontend::EmitMLIR, OPT_emit_mlir_EQ},
       {frontend::EmitHTML, OPT_emit_html},
       {frontend::EmitLLVM, OPT_emit_llvm},
       {frontend::EmitLLVMOnly, OPT_emit_llvm_only},
@@ -2849,6 +2850,13 @@ static void GenerateFrontendArgs(const FrontendOptions &Opts,
     };
   }
 
+  if (Opts.ProgramAction == frontend::EmitMLIR) {
+    GenerateProgramAction = [&]() {
+      if (Opts.MLIRTargetDialect == FrontendOptions::MLIR_Default)
+        GenerateArg(Consumer, OPT_emit_mlir);
+    };
+  }
+
   if (Opts.ProgramAction == frontend::FixIt && !Opts.FixItSuffix.empty()) {
     GenerateProgramAction = [&]() {
       GenerateArg(Consumer, OPT_fixit_EQ, Opts.FixItSuffix);

clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

@@ -60,9 +60,10 @@ CreateFrontendBaseAction(CompilerInstance &CI) {
     llvm::report_fatal_error(
         "-emit-cir and -emit-cir-only only valid when using -fclangir");
 
-  if (CI.getFrontendOpts().ClangIRDirectLowering && Act == EmitMLIR)
-    llvm::report_fatal_error(
-        "ClangIR direct lowering is incompatible with -emit-mlir");
+  if (Act == EmitMLIR && CI.getFrontendOpts().ClangIRDirectLowering &&
+      CI.getFrontendOpts().MLIRTargetDialect == FrontendOptions::MLIR_STD)
+    llvm::report_fatal_error("ClangIR direct lowering is incompatible with "
+                             "emitting of MLIR standard dialects");
 
   switch (CI.getFrontendOpts().ProgramAction) {
   case ASTDeclList:            return std::make_unique<ASTDeclListAction>();

clang/test/CIR/emit-mlir.c

@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-mlir %s -o - | FileCheck %s -check-prefix=LLVM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fno-clangir-direct-lowering -emit-mlir %s -o - | FileCheck %s -check-prefix=STD
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-mlir=llvm %s -o - | FileCheck %s -check-prefix=LLVM
+// RUN: not %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-mlir=std %s -o - 2>&1 | FileCheck %s -check-prefix=STD_ERR
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fno-clangir-direct-lowering -emit-mlir=llvm %s -o - | FileCheck %s -check-prefix=LLVM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fno-clangir-direct-lowering -emit-mlir=std %s -o - | FileCheck %s -check-prefix=STD
+
+// RUN: %clang -fclangir -Xclang -emit-mlir %s -o - -### 2>&1 | FileCheck %s -check-prefix=OPTS_NO_VALUE
+// RUN: %clang -fclangir -Xclang -emit-mlir=llvm %s -o - -###  2>&1 | FileCheck %s -check-prefix=OPTS_LLVM
+// RUN: %clang -fno-clangir-direct-lowering -Xclang -emit-mlir=std %s -o - -### 2>&1 | FileCheck %s -check-prefix=OPTS_STD
+
+int foo(int a, int b) {
+    return a + b;
+}
+
+// LLVM: llvm.func @foo
+// STD: func.func @foo
+// STD_ERR: ClangIR direct lowering is incompatible with emitting of MLIR standard dialects
+// OPTS_NO_VALUE: "-emit-mlir"
+// OPTS_LLVM: "-emit-mlir=llvm"
+// OPTS_STD: "-emit-mlir=std"