[flang] Add rudimentary empty function lowering to tco

[mehdi_amini]

We really need passes to be tested individually with an opt like tool, let me know if you need more pointers.
I suspect you also should invest up-front in the same registration/description for passes as in the mlir core folder.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1

There should be a license header here I believe?

18

This kind of option is unusual: if you want to disable passes this is better done at the point where the pass pipeline is built.

(Also please use PassOptions instead of globals)

26

This comment seems misplaced

62

In general passes aren't supposed to depends on external entities like this: they are expected to be registered and invoked from an *-opt tool.

Here isn't clear why it can't just be a private instance for the pass?

[DavidTruby]

As discussed on flang-dev I am closing this to not block anyone else's progress on upstreaming.

flang/lib/Optimizer/CMakeLists.txt

 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-error")
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FIROptimizer
   Dialect/FIRAttr.cpp
   Dialect/FIRDialect.cpp
   Dialect/FIROps.cpp
   Dialect/FIRType.cpp
 
   Support/InternalNames.cpp
   Support/KindMapping.cpp
 
+  CodeGen/CodeGen.cpp
+
   Transforms/Inliner.cpp
 
   DEPENDS
   FIROpsIncGen
   FIROptTransformsPassIncGen
   ${dialect_libs}
 
   LINK_LIBS

flang/lib/Optimizer/CodeGen/CodeGen.cpp

+#include "flang/Optimizer/CodeGen/CodeGen.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Target/LLVMIR.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/IR/Module.h"
+
+using namespace llvm;
+
+static cl::opt<bool>
+    disableFirToLLVMIR("disable-fir2llvmir",
+                       cl::desc("disable FIR to LLVM-IR dialect pass"),
+                       cl::init(false), cl::Hidden);
+
+static cl::opt<bool> disableLLVM("disable-llvm", cl::desc("disable LLVM pass"),
+                                 cl::init(false), cl::Hidden);
+
+class FIRToLLVMTypeConverter : public mlir::LLVMTypeConverter {
+public:
+  FIRToLLVMTypeConverter(mlir::MLIRContext *context, fir::NameUniquer &uniquer)
+      : LLVMTypeConverter(context) {}
+};
+// Lower a SELECT operation into a cascade of conditional branches. The
+// last case must be the `true` condition.
+/// Convert FIR dialect to LLVM dialect
+///
+/// This pass lowers all FIR dialect operations to LLVM IR dialect.  An
+/// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
+struct FIRToLLVMLoweringPass
+    : public mlir::PassWrapper<FIRToLLVMLoweringPass,
+                               mlir::OperationPass<mlir::ModuleOp>> {
+  FIRToLLVMLoweringPass(fir::NameUniquer &uniquer) : uniquer{uniquer} {}
+
+  mlir::ModuleOp getModule() { return getOperation(); }
+
+  void runOnOperation() override final {
+    if (disableFirToLLVMIR)
+      return;
+
+    auto *context{&getContext()};
+    FIRToLLVMTypeConverter typeConverter{context, uniquer};
+    auto loc = mlir::UnknownLoc::get(context);
+    mlir::OwningRewritePatternList pattern;
+    mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);
+    mlir::ConversionTarget target{*context};
+    target.addLegalDialect<mlir::LLVM::LLVMDialect>();
+
+    // required NOPs for applying a full conversion
+    target.addLegalOp<mlir::ModuleOp, mlir::ModuleTerminatorOp>();
+
+    // apply the patterns
+    if (mlir::failed(mlir::applyFullConversion(getModule(), target,
+                                               std::move(pattern)))) {
+      mlir::emitError(loc, "error in converting to LLVM-IR dialect\n");
+      signalPassFailure();
+    }
+  }
+
+private:
+  fir::NameUniquer &uniquer;
+};
+
+/// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
+struct LLVMIRLoweringPass
+    : public mlir::PassWrapper<LLVMIRLoweringPass,
+                               mlir::OperationPass<mlir::ModuleOp>> {
+  LLVMIRLoweringPass(raw_ostream &output) : output{output} {}
+
+  mlir::ModuleOp getModule() { return getOperation(); }
+
+  void runOnOperation() override final {
+    if (disableLLVM)
+      return;
+
+    if (auto llvmModule = mlir::translateModuleToLLVMIR(getModule())) {
+      llvmModule->print(output, nullptr);
+      return;
+    }
+
+    auto *ctxt = getModule().getContext();
+    mlir::emitError(mlir::UnknownLoc::get(ctxt), "could not emit LLVM-IR\n");
+    signalPassFailure();
+  }
+
+private:
+  llvm::raw_ostream &output;
+};
+
+std::unique_ptr<mlir::Pass>
+fir::createFIRToLLVMPass(fir::NameUniquer &nameUniquer) {
+  return std::make_unique<FIRToLLVMLoweringPass>(nameUniquer);
+}
+
+std::unique_ptr<mlir::Pass>
+fir::createLLVMDialectToLLVMPass(llvm::raw_ostream &output) {
+  return std::make_unique<LLVMIRLoweringPass>(output);
+}

flang/test/Fir/empty-function.fir

+// RUN: tco -o - %s | FileCheck %s
+
+// CHECK-LABEL: define void @f
+func @f() {
+   // CHECK: ret void
+   return
+}

flang/tools/tco/CMakeLists.txt

set(LIBS
   MLIRParser
   MLIRStandardToLLVM
   MLIRSupport
   MLIRVectorToLLVM
 )
 
 add_flang_tool(tco tco.cpp)
 target_link_libraries(tco PRIVATE ${LIBS})
+add_dependencies(tco FIROptCodeGenPassIncGen)

flang/tools/tco/tco.cpp

 //===- tco.cpp - Tilikum Crossing Opt ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This is to be like LLVM's opt program, only for FIR.  Such a program is
 // required for roundtrip testing, etc.
 //
 //===----------------------------------------------------------------------===//
 
+#include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/Support/CommandLine.h"
if (mlir::failed(owningRef->verify())) {
     errs() << "Error verifying FIR module\n";
     return 4;
   }
 
   std::error_code ec;
   ToolOutputFile out(outputFilename, ec, sys::fs::OF_None);
 
   // run passes
+  fir::NameUniquer uniquer;
   mlir::PassManager pm{context.get()};
   mlir::applyPassManagerCLOptions(pm);
   if (emitFir) {
     // parse the input and pretty-print it back out
     // -emit-fir intentionally disables all the passes
   } else {
     // TODO: Actually add passes when added to FIR code base
     // add all the passes
     // the user can disable them individually
+    pm.addPass(fir::createFIRToLLVMPass(uniquer));
+    pm.addPass(fir::createLLVMDialectToLLVMPass(out.os()));
   }
 
   // run the pass manager
   if (mlir::succeeded(pm.run(*owningRef))) {
     // passes ran successfully, so keep the output
     if (emitFir)
       printModuleBody(*owningRef, out.os());
     out.keep();