Revert "[CIR] Add framework for CIR to LLVM IR lowering (llvm#124650)"

This reverts commit 38ddcb7.

Author: lanza

clang/include/clang/CIR/FrontendAction/CIRGenAction.h

@@ -26,7 +26,6 @@ class CIRGenAction : public clang::ASTFrontendAction {
 public:
   enum class OutputType {
     EmitCIR,
-    EmitLLVM,
   };
 
 private:
@@ -56,13 +55,6 @@ class EmitCIRAction : public CIRGenAction {
   EmitCIRAction(mlir::MLIRContext *MLIRCtx = nullptr);
 };
 
-class EmitLLVMAction : public CIRGenAction {
-  virtual void anchor();
-
-public:
-  EmitLLVMAction(mlir::MLIRContext *MLIRCtx = nullptr);
-};
-
 } // namespace cir
 
 #endif

clang/include/clang/CIR/LowerToLLVM.h

@@ -5,4 +5,3 @@ add_subdirectory(Dialect)
 add_subdirectory(CodeGen)
 add_subdirectory(FrontendAction)
 add_subdirectory(Interfaces)
-add_subdirectory(Lowering)

clang/lib/CIR/CMakeLists.txt

@@ -7,60 +7,42 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/CIR/FrontendAction/CIRGenAction.h"
-#include "mlir/IR/MLIRContext.h"
-#include "mlir/IR/OwningOpRef.h"
 #include "clang/CIR/CIRGenerator.h"
-#include "clang/CIR/LowerToLLVM.h"
-#include "clang/CodeGen/BackendUtil.h"
 #include "clang/Frontend/CompilerInstance.h"
-#include "llvm/IR/Module.h"
+
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/OwningOpRef.h"
 
 using namespace cir;
 using namespace clang;
 
 namespace cir {
 
-static BackendAction
-getBackendActionFromOutputType(CIRGenAction::OutputType Action) {
-  switch (Action) {
-  case CIRGenAction::OutputType::EmitCIR:
-    assert(false &&
-           "Unsupported output type for getBackendActionFromOutputType!");
-    break; // Unreachable, but fall through to report that
-  case CIRGenAction::OutputType::EmitLLVM:
-    return BackendAction::Backend_EmitLL;
-  }
-  // We should only get here if a non-enum value is passed in or we went through
-  // the assert(false) case above
-  llvm_unreachable("Unsupported output type!");
-}
-
-static std::unique_ptr<llvm::Module>
-lowerFromCIRToLLVMIR(mlir::ModuleOp MLIRModule, llvm::LLVMContext &LLVMCtx) {
-  return direct::lowerDirectlyFromCIRToLLVMIR(MLIRModule, LLVMCtx);
-}
-
 class CIRGenConsumer : public clang::ASTConsumer {
 
   virtual void anchor();
 
   CIRGenAction::OutputType Action;
 
-  CompilerInstance &CI;
-
   std::unique_ptr<raw_pwrite_stream> OutputStream;
 
   ASTContext *Context{nullptr};
   IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS;
   std::unique_ptr<CIRGenerator> Gen;
 
 public:
-  CIRGenConsumer(CIRGenAction::OutputType Action, CompilerInstance &CI,
+  CIRGenConsumer(CIRGenAction::OutputType Action,
+                 DiagnosticsEngine &DiagnosticsEngine,
+                 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+                 const HeaderSearchOptions &HeaderSearchOptions,
+                 const CodeGenOptions &CodeGenOptions,
+                 const TargetOptions &TargetOptions,
+                 const LangOptions &LangOptions,
+                 const FrontendOptions &FEOptions,
                  std::unique_ptr<raw_pwrite_stream> OS)
-      : Action(Action), CI(CI), OutputStream(std::move(OS)),
-        FS(&CI.getVirtualFileSystem()),
-        Gen(std::make_unique<CIRGenerator>(CI.getDiagnostics(), std::move(FS),
-                                           CI.getCodeGenOpts())) {}
+      : Action(Action), OutputStream(std::move(OS)), FS(VFS),
+        Gen(std::make_unique<CIRGenerator>(DiagnosticsEngine, std::move(VFS),
+                                           CodeGenOptions)) {}
 
   void Initialize(ASTContext &Ctx) override {
     assert(!Context && "initialized multiple times");
@@ -84,17 +66,6 @@ class CIRGenConsumer : public clang::ASTConsumer {
         MlirModule->print(*OutputStream, Flags);
       }
       break;
-    case CIRGenAction::OutputType::EmitLLVM: {
-      llvm::LLVMContext LLVMCtx;
-      std::unique_ptr<llvm::Module> LLVMModule =
-          lowerFromCIRToLLVMIR(MlirModule, LLVMCtx);
-
-      BackendAction BEAction = getBackendActionFromOutputType(Action);
-      emitBackendOutput(
-          CI, CI.getCodeGenOpts(), C.getTargetInfo().getDataLayoutString(),
-          LLVMModule.get(), BEAction, FS, std::move(OutputStream));
-      break;
-    }
     }
   }
 };
@@ -113,8 +84,6 @@ getOutputStream(CompilerInstance &CI, StringRef InFile,
   switch (Action) {
   case CIRGenAction::OutputType::EmitCIR:
     return CI.createDefaultOutputFile(false, InFile, "cir");
-  case CIRGenAction::OutputType::EmitLLVM:
-    return CI.createDefaultOutputFile(false, InFile, "ll");
   }
   llvm_unreachable("Invalid CIRGenAction::OutputType");
 }
@@ -126,16 +95,14 @@ CIRGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   if (!Out)
     Out = getOutputStream(CI, InFile, Action);
 
-  auto Result =
-      std::make_unique<cir::CIRGenConsumer>(Action, CI, std::move(Out));
+  auto Result = std::make_unique<cir::CIRGenConsumer>(
+      Action, CI.getDiagnostics(), &CI.getVirtualFileSystem(),
+      CI.getHeaderSearchOpts(), CI.getCodeGenOpts(), CI.getTargetOpts(),
+      CI.getLangOpts(), CI.getFrontendOpts(), std::move(Out));
 
   return Result;
 }
 
 void EmitCIRAction::anchor() {}
 EmitCIRAction::EmitCIRAction(mlir::MLIRContext *MLIRCtx)
     : CIRGenAction(OutputType::EmitCIR, MLIRCtx) {}
-
-void EmitLLVMAction::anchor() {}
-EmitLLVMAction::EmitLLVMAction(mlir::MLIRContext *MLIRCtx)
-    : CIRGenAction(OutputType::EmitLLVM, MLIRCtx) {}

clang/lib/CIR/FrontendAction/CIRGenAction.cpp

@@ -12,7 +12,6 @@ add_clang_library(clangCIRFrontendAction
   clangAST
   clangFrontend
   clangCIR
-  clangCIRLoweringDirectToLLVM
   MLIRCIR
   MLIRIR
   )

clang/lib/CIR/FrontendAction/CMakeLists.txt

@@ -71,13 +71,7 @@ CreateFrontendBaseAction(CompilerInstance &CI) {
     llvm_unreachable("CIR suppport not built into clang");
 #endif
   case EmitHTML:               return std::make_unique<HTMLPrintAction>();
-  case EmitLLVM: {
-#if CLANG_ENABLE_CIR
-    if (UseCIR)
-      return std::make_unique<cir::EmitLLVMAction>();
-#endif
-    return std::make_unique<EmitLLVMAction>();
-  }
+  case EmitLLVM:               return std::make_unique<EmitLLVMAction>();
   case EmitLLVMOnly:           return std::make_unique<EmitLLVMOnlyAction>();
   case EmitCodeGenOnly:        return std::make_unique<EmitCodeGenOnlyAction>();
   case EmitObj:                return std::make_unique<EmitObjAction>();