[CIR] Add 'core-flat' as an option value for '-emit-mlir='

- Both 'func' and 'scf' have structure control flow constraints, e.g.,
  'func.return' needs to have 'func.func' parent op. The alternative
  approach to lower CIR into MLIR standard dialects is to lower CIR into
  'cf' dialect and perform structurization on all or selected regions.
- Add 'core-flat' option to enable CFG flattening when lowering CIR into
  MLIR standard dialects.
- Add 'cir-unify-func-return' pass to unify returns into branches to a
  trialing block dedicated for function return.
- Fix 'cir.br' and 'cir.return' lowering to MLIR and allow function
  declarations.

Author: darkbuck

clang/include/clang/CIR/CIRToCIRPasses.h

@@ -35,7 +35,7 @@ mlir::LogicalResult runCIRToCIRPasses(
     llvm::StringRef idiomRecognizerOpts, bool enableLibOpt,
     llvm::StringRef libOptOpts, std::string &passOptParsingFailure,
     bool enableCIRSimplify, bool flattenCIR, bool emitMLIR,
-    bool enableCallConvLowering, bool enableMem2reg);
+    bool enableCallConvLowering, bool enableMem2reg, bool flattenCore);
 
 } // namespace cir
 

clang/include/clang/CIR/Dialect/Passes.h

@@ -39,11 +39,13 @@ std::unique_ptr<Pass> createLibOptPass(clang::ASTContext *astCtx);
 std::unique_ptr<Pass> createFlattenCFGPass();
 std::unique_ptr<Pass> createHoistAllocasPass();
 std::unique_ptr<Pass> createGotoSolverPass();
+std::unique_ptr<Pass> createUnifyFuncReturnPass();
 
 /// Create a pass to lower ABI-independent function definitions/calls.
 std::unique_ptr<Pass> createCallConvLoweringPass();
 
-void populateCIRPreLoweringPasses(mlir::OpPassManager &pm, bool useCCLowering);
+void populateCIRPreLoweringPasses(mlir::OpPassManager &pm, bool useCCLowering,
+                                  bool flattenCore);
 
 //===----------------------------------------------------------------------===//
 // Registration

clang/include/clang/CIR/Dialect/Passes.td

@@ -191,4 +191,14 @@ def CallConvLowering : Pass<"cir-call-conv-lowering"> {
   let dependentDialects = ["cir::CIRDialect"];
 }
 
+def UnifyFuncReturn : Pass<"cir-unify-func-return"> {
+  let summary = "Unify function return";
+  let description = [{
+    This pass creates a dedicated block as the only function return point and
+    unifies all returns as unconditional branches to that return block.
+  }];
+  let constructor = "mlir::createUnifyFuncReturnPass()";
+  let dependentDialects = ["cir::CIRDialect"];
+}
+
 #endif // MLIR_DIALECT_CIR_PASSES

clang/include/clang/Driver/Options.td

@@ -3120,9 +3120,9 @@ def emit_mlir : Flag<["-"], "emit-mlir">, Visibility<[ClangOption]>, Group<Actio
 def emit_mlir_EQ : Joined<["-"], "emit-mlir=">, Visibility<[ClangOption, CC1Option]>, Group<Action_Group>,
   HelpText<"Build ASTs and then lower through ClangIR to the selected MLIR dialect, emit the .mlir file. "
   "Allowed values are `core` for MLIR standard dialects and `llvm` for the LLVM dialect.">,
-  Values<"core,llvm,cir,cir-flat">,
+  Values<"core,llvm,cir,cir-flat,core-flat">,
   NormalizedValuesScope<"frontend">,
-  NormalizedValues<["MLIR_CORE", "MLIR_LLVM", "MLIR_CIR", "MLIR_CIR_FLAT"]>,
+  NormalizedValues<["MLIR_CORE", "MLIR_LLVM", "MLIR_CIR", "MLIR_CIR_FLAT", "MLIR_CORE_FLAT"]>,
   MarshallingInfoEnum<FrontendOpts<"MLIRTargetDialect">, "MLIR_CORE">;
 def emit_cir : Flag<["-"], "emit-cir">, Visibility<[ClangOption, CC1Option]>,
   Group<Action_Group>, Alias<emit_mlir_EQ>, AliasArgs<["cir"]>,

clang/include/clang/Frontend/FrontendOptions.h

@@ -154,7 +154,13 @@ enum ActionKind {
   PrintDependencyDirectivesSourceMinimizerOutput
 };
 
-enum MLIRDialectKind { MLIR_CORE, MLIR_LLVM, MLIR_CIR, MLIR_CIR_FLAT };
+enum MLIRDialectKind {
+  MLIR_CORE,
+  MLIR_LLVM,
+  MLIR_CIR,
+  MLIR_CIR_FLAT,
+  MLIR_CORE_FLAT
+};
 
 } // namespace frontend
 

clang/lib/CIR/CodeGen/CIRPasses.cpp

@@ -29,7 +29,7 @@ mlir::LogicalResult runCIRToCIRPasses(
     llvm::StringRef idiomRecognizerOpts, bool enableLibOpt,
     llvm::StringRef libOptOpts, std::string &passOptParsingFailure,
     bool enableCIRSimplify, bool flattenCIR, bool emitCore,
-    bool enableCallConvLowering, bool enableMem2Reg) {
+    bool enableCallConvLowering, bool enableMem2Reg, bool flattenCore) {
 
   llvm::TimeTraceScope scope("CIR To CIR Passes");
 
@@ -75,8 +75,8 @@ mlir::LogicalResult runCIRToCIRPasses(
 
   pm.addPass(mlir::createLoweringPreparePass(&astContext));
 
-  if (flattenCIR || enableMem2Reg)
-    mlir::populateCIRPreLoweringPasses(pm, enableCallConvLowering);
+  if (flattenCIR || flattenCore || enableMem2Reg)
+    mlir::populateCIRPreLoweringPasses(pm, enableCallConvLowering, flattenCore);
 
   if (enableMem2Reg)
     pm.addPass(mlir::createMem2Reg());
@@ -96,11 +96,14 @@ mlir::LogicalResult runCIRToCIRPasses(
 
 namespace mlir {
 
-void populateCIRPreLoweringPasses(OpPassManager &pm, bool useCCLowering) {
+void populateCIRPreLoweringPasses(OpPassManager &pm, bool useCCLowering,
+                                  bool flattenCore) {
   if (useCCLowering)
     pm.addPass(createCallConvLoweringPass());
   pm.addPass(createHoistAllocasPass());
   pm.addPass(createFlattenCFGPass());
+  if (flattenCore)
+    pm.addPass(createUnifyFuncReturnPass());
   pm.addPass(createGotoSolverPass());
 }
 

clang/lib/CIR/Dialect/Transforms/CMakeLists.txt

@@ -14,6 +14,7 @@ add_clang_library(MLIRCIRTransforms
   SCFPrepare.cpp
   CallConvLowering.cpp
   HoistAllocas.cpp
+  UnifyFuncReturn.cpp
 
   DEPENDS
   MLIRCIRPassIncGen

clang/lib/CIR/Dialect/Transforms/UnifyFuncReturn.cpp

@@ -0,0 +1,95 @@
+//====- UnifyFuncReturn.cpp -------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "PassDetail.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Support/LogicalResult.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "clang/CIR/Dialect/IR/CIRDialect.h"
+#include "clang/CIR/Dialect/Passes.h"
+#include "llvm/Support/TimeProfiler.h"
+
+using namespace mlir;
+using namespace cir;
+
+namespace {
+
+struct UnifyFuncReturnPass : public UnifyFuncReturnBase<UnifyFuncReturnPass> {
+  UnifyFuncReturnPass() = default;
+  void runOnOperation() override;
+
+private:
+  void unifyReturn(FuncOp func);
+};
+
+struct UnifyReturn : public OpRewritePattern<ReturnOp> {
+  using OpRewritePattern<ReturnOp>::OpRewritePattern;
+
+  UnifyReturn(MLIRContext *context, cir::FuncOp func, Block *retBlock)
+      : OpRewritePattern<ReturnOp>(context), func(func), retBlock(retBlock) {}
+
+  mlir::LogicalResult
+  matchAndRewrite(cir::ReturnOp ret,
+                  mlir::PatternRewriter &rewriter) const override {
+    mlir::OpBuilder::InsertionGuard guard(rewriter);
+    auto fn = ret->getParentOfType<cir::FuncOp>();
+    if (!fn || fn != func)
+      return mlir::failure();
+    // Replace 'return' with 'br <retBlock>'
+    rewriter.replaceOpWithNewOp<cir::BrOp>(ret, ret.getInput(), retBlock);
+    return mlir::success();
+  }
+
+private:
+  cir::FuncOp func;
+  Block *retBlock;
+};
+
+} // namespace
+
+void UnifyFuncReturnPass::unifyReturn(cir::FuncOp func) {
+  if (func.getRegion().empty())
+    return;
+
+  bool hasRetVals = func.getNumResults() > 0;
+  auto *endBody = &func.getBody().back();
+  auto *retBlock = endBody->splitBlock(endBody->end());
+  if (hasRetVals)
+    retBlock->addArguments(func.getResultTypes(), func.getLoc());
+
+  RewritePatternSet patterns(&getContext());
+  patterns.add<UnifyReturn>(patterns.getContext(), func, retBlock);
+
+  // Collect operations to apply patterns.
+  llvm::SmallVector<Operation *, 16> ops;
+  func->walk([&](cir::ReturnOp op) { ops.push_back(op.getOperation()); });
+
+  // Apply patterns.
+  if (applyOpPatternsGreedily(ops, std::move(patterns)).failed())
+    signalPassFailure();
+
+  auto builder = OpBuilder::atBlockBegin(retBlock);
+  if (hasRetVals)
+    builder.create<cir::ReturnOp>(func.getLoc(), retBlock->getArguments());
+  else
+    builder.create<cir::ReturnOp>(func.getLoc());
+}
+
+void UnifyFuncReturnPass::runOnOperation() {
+  llvm::TimeTraceScope scope("Unify function returns");
+
+  // Collect operations to apply patterns.
+  llvm::SmallVector<Operation *, 16> ops;
+  getOperation()->walk([&](cir::FuncOp op) { unifyReturn(op); });
+}
+
+namespace mlir {
+std::unique_ptr<Pass> createUnifyFuncReturnPass() {
+  return std::make_unique<UnifyFuncReturnPass>();
+}
+} // namespace mlir

clang/lib/CIR/FrontendAction/CIRGenAction.cpp

@@ -210,8 +210,13 @@ class CIRGenConsumer : public clang::ASTConsumer {
           action == CIRGenAction::OutputType::EmitMLIR &&
           feOptions.MLIRTargetDialect == clang::frontend::MLIR_CIR_FLAT;
 
-      bool emitCore = action == CIRGenAction::OutputType::EmitMLIR &&
-                      feOptions.MLIRTargetDialect == clang::frontend::MLIR_CORE;
+      bool emitCore =
+          action == CIRGenAction::OutputType::EmitMLIR &&
+          (feOptions.MLIRTargetDialect == clang::frontend::MLIR_CORE ||
+           feOptions.MLIRTargetDialect == clang::frontend::MLIR_CORE_FLAT);
+      bool flattenCore =
+          action == CIRGenAction::OutputType::EmitMLIR &&
+          feOptions.MLIRTargetDialect == clang::frontend::MLIR_CORE_FLAT;
 
       // Setup and run CIR pipeline.
       std::string passOptParsingFailure;
@@ -221,7 +226,7 @@ class CIRGenConsumer : public clang::ASTConsumer {
               feOptions.ClangIRIdiomRecognizer, idiomRecognizerOpts,
               feOptions.ClangIRLibOpt, libOptOpts, passOptParsingFailure,
               codeGenOptions.OptimizationLevel > 0, flattenCIR, emitCore,
-              enableCCLowering, feOptions.ClangIREnableMem2Reg)
+              enableCCLowering, feOptions.ClangIREnableMem2Reg, flattenCore)
               .failed()) {
         if (!passOptParsingFailure.empty())
           diagnosticsEngine.Report(diag::err_drv_cir_pass_opt_parsing)
@@ -283,6 +288,7 @@ class CIRGenConsumer : public clang::ASTConsumer {
     case CIRGenAction::OutputType::EmitMLIR: {
       switch (feOptions.MLIRTargetDialect) {
       case clang::frontend::MLIR_CORE:
+      case clang::frontend::MLIR_CORE_FLAT:
         // case for direct lowering is already checked in compiler invocation
         // no need to check here
         emitMLIR(lowerFromCIRToMLIR(mlirMod, mlirCtx.get()), false);

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

@@ -4788,7 +4788,7 @@ std::unique_ptr<mlir::Pass> createConvertCIRToLLVMPass() {
 }
 
 void populateCIRToLLVMPasses(mlir::OpPassManager &pm, bool useCCLowering) {
-  populateCIRPreLoweringPasses(pm, useCCLowering);
+  populateCIRPreLoweringPasses(pm, useCCLowering, /*flattenCore=*/false);
   pm.addPass(createConvertCIRToLLVMPass());
 }