[flang] Update tco tool pipline and add translation to LLVM IR

[clementval]

Summary

tco is a tool to test the FIR to LLVM IR pipeline of the Flang compiler.

This patch update tco pipelines and adds the translation to LLVM IR.

A simple test is added to make sure the tool is working with a simple
FIR program.
More tests will be upstream in follow up patch from the fir-dev branch.

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: Eric Schweitz <[e-mail]>
Co-authored-by: Jean Perier <[e-mail]>
Co-authored-by: Andrzej Warzynski <[e-mail]>

[mehdi_amini]

What's the difference between tco and fir-opt? Just that the former can emit LLVM IR instead of LLVM dialect? And that the no-argument invocation will run the lowering pipeline?
For running pipeline, why not involve the flang binary? (this is what clang is doing by the way: it can take LLVM IR as input as well and emit LLVM IR, run various optimization pipeline, assembly, object, and handles the usual options you need anyway through frontend options. Between what you'd want to expose through flang anyway and what you already have with fir-opt, it's not clear to me the fundamental role tco plays? (I think I remember that it just existed before fir-opt and before there was a flang driver).

flang/tools/tco/tco.cpp

108

Why deferring this? Can't you propagate the failure?

[clementval]

In D117781#3258461, @mehdi_amini wrote:

What's the difference between tco and fir-opt? Just that the former can emit LLVM IR instead of LLVM dialect? And that the no-argument invocation will run the lowering pipeline?
For running pipeline, why not involve the flang binary? (this is what clang is doing by the way: it can take LLVM IR as input as well and emit LLVM IR, run various optimization pipeline, assembly, object, and handles the usual options you need anyway through frontend options. Between what you'd want to expose through flang anyway and what you already have with fir-opt, it's not clear to me the fundamental role tco plays? (I think I remember that it just existed before fir-opt and before there was a flang driver).

fir-opt doesn't have any defined pipeline and is similar to mlir-opt. We use it to test FIR to FIR passes. tco is meant to test the second half of the pipeline from FIR to LLVMIR. It has the same defined pipeline that the final Flang binary will have. At the moment we do not have a proper flang driver upstream but it will come in the last steps of the upstreaming from fir-dev. The pipeline is currently shared in fir-dev so we are sure we test the same things (defined in CLOptions.inc). Once we have a proper flang driver that have similar capabilities than clang we might change the test to make use of it and maybe retire tco.

flang/tools/tco/tco.cpp

108

Sure. I spotted that after I pushed the patch and I'll change it.

[mehdi_amini]

In D117781#3258703, @clementval wrote:

fir-opt doesn't have any defined pipeline and is similar to mlir-opt.

Sure, but that's trivial to register pipelines and expose them on the command line. I think it is even desirable to do so (for example opt in LLVM exposes -O2 on the command line).

We use it to test FIR to FIR passes.

I think you're providing the definition for fir-opt here?

tco is meant to test the second half of the pipeline from FIR to LLVMIR. It has the same defined pipeline that the final Flang binary will have.

Right, but again I don't understand why you don't expose this by registering a pipeline in fir-opt?

Once we have a proper flang driver that have similar capabilities than clang we might change the test to make use of it and maybe retire tco.

LGTM, assuming this tool is temporary and will get removed. But I'd like to understand why the pipeline can't be all registered in fir-opt?

[clementval]

In D117781#3260316, @mehdi_amini wrote:

In D117781#3258703, @clementval wrote:

fir-opt doesn't have any defined pipeline and is similar to mlir-opt.

Sure, but that's trivial to register pipelines and expose them on the command line. I think it is even desirable to do so (for example opt in LLVM exposes -O2 on the command line).

We use it to test FIR to FIR passes.

I think you're providing the definition for fir-opt here?

Yes it's fir-opt.

Once we have a proper flang driver that have similar capabilities than clang we might change the test to make use of it and maybe retire tco.

LGTM, assuming this tool is temporary and will get removed. But I'd like to understand why the pipeline can't be all registered in fir-opt?

I guess we can merge the two tools at some point. tco was there before fir-opt so nobody took the time to merge the functionality of one into the other yet.

[clementval]

Address the FIXME present in the previous patch

[clementval]

Add target to avoid failure on windows

[awarzynski]

Hi @clementval , thanks for this patch! I saw the buildbot failure that led to this being reverted: https://lab.llvm.org/buildbot/#/builders/177/builds/3311:

./bin/tco --target=aarch64-unknown-linux-gnu /home/kircha02/llvm-project/flang/test/Fir/basic-program.fir
: CommandLine Error: Option 'aarch64-enable-ccmp' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options
Aborted (core dumped)

I took a quick look and I think that "flang/tools/tco/CMakeLists.txt" needs tweaking, In particular, LLVM_LINK_COMPONENTS is used in add_llvm_executable (which is called by add_flang_tool). So, I think that this will cause some libraries to be included twice in the list of dependencies:

target_link_libraries(tco PRIVATE
  ${llvm_libs}
)

which in turn would lead to some command line options being registered twice.

Also, llvm-config --components suggests that these aren't really components (I might be reading it wrong though):

set(LLVM_LINK_COMPONENTS
  AllTargetsAsmParsers
  AllTargetsCodeGens
  AllTargetsDescs
  AllTargetsInfos
)

Why not use ${LLVM_TARGETS_TO_BUILD} instead? HTH!

[clementval]

Update how the targets are linked to tco

This looks similar to other tools like: bolt/tools/driver/CMakeLists.txt

[clementval]

In D117781#3265649, @awarzynski wrote:

Hi @clementval , thanks for this patch! I saw the buildbot failure that led to this being reverted: https://lab.llvm.org/buildbot/#/builders/177/builds/3311:

./bin/tco --target=aarch64-unknown-linux-gnu /home/kircha02/llvm-project/flang/test/Fir/basic-program.fir
: CommandLine Error: Option 'aarch64-enable-ccmp' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options
Aborted (core dumped)

I took a quick look and I think that "flang/tools/tco/CMakeLists.txt" needs tweaking, In particular, LLVM_LINK_COMPONENTS is used in add_llvm_executable (which is called by add_flang_tool). So, I think that this will cause some libraries to be included twice in the list of dependencies:

target_link_libraries(tco PRIVATE
  ${llvm_libs}
)

which in turn would lead to some command line options being registered twice.

Also, llvm-config --components suggests that these aren't really components (I might be reading it wrong though):

set(LLVM_LINK_COMPONENTS
  AllTargetsAsmParsers
  AllTargetsCodeGens
  AllTargetsDescs
  AllTargetsInfos
)

Why not use ${LLVM_TARGETS_TO_BUILD} instead? HTH!

Hi @awarzynski!

I figured out the same thing I just updated the patch to reflect that. Other tools like the new bolt-driver or clang and llvm tools are using the same mechanism.

Thanks for looking at this as well.

[awarzynski]

flang/tools/tco/tco.cpp

40

Copy & paste error?

[kiranchandramohan]

Passes the dylib build and tests.

[clementval]

flang/tools/tco/tco.cpp

40

That's what we have in fir-dev but it does not make so much sense. I'll just remove it and update fir-dev.

[schweitz]

flang/tools/tco/tco.cpp

40

Just garbage copied over from elsewhere. Thanks for deleting it.

[mehdi_amini]

Why does this tool even need to initialize the targets? It is a bit surprising that this linking dependency is declared on the tool instead of on the actual library that needs it.

[awarzynski]

In D117781#3267662, @mehdi_amini wrote:

It is a bit surprising that this linking dependency is declared on the tool instead of on the actual library that needs it.

IIUC, these dependencies are not needed at all. tco is not meant for interfacing with the backend (i.e. machine code generation). I've submitted an update: https://reviews.llvm.org/D118112

Apologies for not pointing this out earlier. I was away for a bit and when I looked at this yesterday I focused on fixing the build failure.

Btw, I agree that merging fir-opt and tco into one tool would be a sensible direction.

[mehdi_amini]

In D117781#3260512, @clementval wrote:

In D117781#3260316, @mehdi_amini wrote:

LGTM, assuming this tool is temporary and will get removed. But I'd like to understand why the pipeline can't be all registered in fir-opt?

I guess we can merge the two tools at some point. tco was there before fir-opt so nobody took the time to merge the functionality of one into the other yet.

To be very clear in this revision because there seems to be some confusion in the chat:

• You got a conditional LGTM here and you committed based on this condition.
• You acknowledged that you're contributed a tool here that only exists because the functionalities haven't been merged yet to fir-opt, but that we can merge the tools in fir-opt (and so delete tco at this point) in the future.

If this isn't very clear, please revert ASAP.

[clementval]

In D117781#3313556, @mehdi_amini wrote:

In D117781#3260512, @clementval wrote:

In D117781#3260316, @mehdi_amini wrote:

LGTM, assuming this tool is temporary and will get removed. But I'd like to understand why the pipeline can't be all registered in fir-opt?

I guess we can merge the two tools at some point. tco was there before fir-opt so nobody took the time to merge the functionality of one into the other yet.

To be very clear in this revision because there seems to be some confusion in the chat:

• You got a conditional LGTM here and you committed based on this condition.
• You acknowledged that you're contributed a tool here that only exists because the functionalities haven't been merged yet to fir-opt, but that we can merge the tools in fir-opt (and so delete tco at this point) in the future.

If this isn't very clear, please revert ASAP.

In D117781#3313556, @mehdi_amini wrote:

In D117781#3260512, @clementval wrote:

In D117781#3260316, @mehdi_amini wrote:

LGTM, assuming this tool is temporary and will get removed. But I'd like to understand why the pipeline can't be all registered in fir-opt?

I guess we can merge the two tools at some point. tco was there before fir-opt so nobody took the time to merge the functionality of one into the other yet.

To be very clear in this revision because there seems to be some confusion in the chat:

• You got a conditional LGTM here and you committed based on this condition.
• You acknowledged that you're contributed a tool here that only exists because the functionalities haven't been merged yet to fir-opt, but that we can merge the tools in fir-opt (and so delete tco at this point) in the future.

If this isn't very clear, please revert ASAP.

As I mentioned in the chat, we do not have the equivalent of tco at this point so it cannot be removed now.

Also to make things clearer the tco tool is the equivalent of mlir-translate in MLIR and fir-opt is the equivalent of mlir-opt.

[mehdi_amini]

In D117781#3313606, @clementval wrote:

As I mentioned in the chat, we do not have the equivalent of tco at this point so it cannot be removed now.

Sure, that part was very clear above. But we also need to agree that:

1. there is a redundancy that isn't justified other than history (you wrote: nobody took the time to merge the functionality of one into the other yet)
2. this redundancy is not desirable and so tco is meant to disappear.

Also to make things clearer the tco tool is the equivalent of mlir-translate in MLIR and fir-opt is the equivalent of mlir-opt.

This is not clear at all actually, on the contrary: this even goes against the entire discussion in this revision which was about comparing tco and fir-opt.
This has nothing to do with mlir-translate which is purely about converting from an MLIR dialect to an external representation (basically exporting outside of MLIR), and nothing else. In particular mlir-translate does not run "MLIR to MLIR" transformations, and does not invoke passes.

[clementval]

In D117781#3313646, @mehdi_amini wrote:

In D117781#3313606, @clementval wrote:

As I mentioned in the chat, we do not have the equivalent of tco at this point so it cannot be removed now.

Sure, that part was very clear above. But we also need to agree that:

1. there is a redundancy that isn't justified other than history (you wrote: nobody took the time to merge the functionality of one into the other yet)
2. this redundancy is not desirable and so tco is meant to disappear.

Also to make things clearer the tco tool is the equivalent of mlir-translate in MLIR and fir-opt is the equivalent of mlir-opt.

This is not clear at all actually, on the contrary: this even goes against the entire discussion in this revision which was about comparing tco and fir-opt.
This has nothing to do with mlir-translate which is purely about converting from an MLIR dialect to an external representation (basically exporting outside of MLIR), and nothing else. In particular mlir-translate does not run "MLIR to MLIR" transformations, and does not invoke passes.

The part dealing with MLIR to MLIR transformations can be removed from tco and place in fir-opt but the translation to LLVM IR is very much what mlir-translate does. So I agree that a part of tco would be redundant when moved to fir-opt but not the entire tool.

[mehdi_amini]

Right, and at this point isn't it identical mlir-translate?

[clementval]

In D117781#3313677, @mehdi_amini wrote:

Right, and at this point isn't it identical mlir-translate?

Probably. I didn't check whether there is a difference in the translation phase but my guess would be that they are pretty similar.

[awarzynski]

@mehdi_amini, your approval was indeed conditional and we should've followed-up with a discussion on the future of tco. In the past, we only briefly discussed replacing it with flang-new. That was a while back, before flang-new could generate MLIR/LLVM IR/a.out. The situation is a bit different now and it does sound like with a bit of extra work we should be able to replace it with other tools. One major outstanding functionality in flang-new is the ability to consume MLIR. We've not really looked into it yet, but I can prioritize it.

Btw, I read @clementval's

we might change the test to make use of it and maybe retire tco

as:

it would make sense, but perhaps lets re-visit once upstreaming is complete?

Quite a few tests in fir-dev still use tco and retiring it now would require people shifting their focus quite a bit. It will be much easier once fir-dev is "read-only". Having said that, I think that Valentin has already initiated the transition when he introduced fir-opt. To support the transition, I can retrofit flang-new to all tests that use tco (where possible). Long term, I do support tco being retired unless we can identify a unique feature that we cannot replicate with one of the other tools.

Just my 2p.

[mehdi_amini]

In D117781#3314268, @awarzynski wrote:

@mehdi_amini, your approval was indeed conditional and we should've followed-up with a discussion on the future of tco. In the past, we only briefly discussed replacing it with flang-new. That was a while back, before flang-new could generate MLIR/LLVM IR/a.out. The situation is a bit different now and it does sound like with a bit of extra work we should be able to replace it with other tools. One major outstanding functionality in flang-new is the ability to consume MLIR. We've not really looked into it yet, but I can prioritize it.

To be clear: I don't think there is a strong need to change any priority (at least I am not aware of anything).

Btw, I read @clementval's

we might change the test to make use of it and maybe retire tco

as:

it would make sense, but perhaps lets re-visit once upstreaming is complete?

Just note that what you're quoting is not the most recent answer (which was I guess we can merge the two tools at some point. tco was there before fir-opt so nobody took the time to merge the functionality of one into the other yet.).

Quite a few tests in fir-dev still use tco and retiring it now would require people shifting their focus quite a bit. It will be much easier once fir-dev is "read-only".

Yes, which is why I was perfectly fine to add it now to help the upstreaming. But that required an agreement about the future plans, hence the conditional approval. There is no urgency to do anything, if it takes a year to get there it's perfectly fine as well, but there is a difference between "yes this is redundant, 'nobody took the time to merge the functionality' yet, and we'll address this post-upstreaming" and "we don't know what we may or may not want to do".

Long term, I do support tco being retired unless we can identify a unique feature that we cannot replicate with one of the other tools.

I've not been asking anything more than an agreement on this :)

[awarzynski]

In D117781#3316245, @mehdi_amini wrote:

I've not been asking anything more than an agreement on this :)

Great, I think that we are on the same page here! :)

This has been very constructive and I think that it has really helped to clarify the status of tco (which is the most contentious element of this patch). Thank you all!

flang/include/flang/Optimizer/CodeGen/CodeGen.h

 //===-- Optimizer/CodeGen/CodeGen.h -- code generation ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_CODEGEN_CODEGEN_H
 #define FORTRAN_OPTIMIZER_CODEGEN_CODEGEN_H
 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassRegistry.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 namespace fir {
 
 struct NameUniquer;
 
 /// Prerequiste pass for code gen. Perform intermediate rewrites to perform
 /// the code gen (to LLVM-IR dialect) conversion.
 std::unique_ptr<mlir::Pass> createFirCodeGenRewritePass();
 
 /// FirTargetRewritePass options.
 struct TargetRewriteOptions {
   bool noCharacterConversion{};
   bool noComplexConversion{};
 };
 
 /// Prerequiste pass for code gen. Perform intermediate rewrites to tailor the
 /// FIR for the chosen target.
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> createFirTargetRewritePass(
     const TargetRewriteOptions &options = TargetRewriteOptions());
 
 /// Convert FIR to the LLVM IR dialect
 std::unique_ptr<mlir::Pass> createFIRToLLVMPass();
 
+using LLVMIRLoweringPrinter =
+    std::function<void(llvm::Module &, llvm::raw_ostream &)>;
 /// Convert the LLVM IR dialect to LLVM-IR proper
-std::unique_ptr<mlir::Pass>
-createLLVMDialectToLLVMPass(llvm::raw_ostream &output);
+std::unique_ptr<mlir::Pass> createLLVMDialectToLLVMPass(
+    llvm::raw_ostream &output,
+    LLVMIRLoweringPrinter printer =
+        [](llvm::Module &m, llvm::raw_ostream &out) { m.print(out, nullptr); });
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/CodeGen/CGPasses.h.inc"
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_CODEGEN_CODEGEN_H

flang/include/flang/Optimizer/Support/InitFIR.h

 //===-- Optimizer/Support/InitFIR.h -----------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_SUPPORT_INITFIR_H
 #define FORTRAN_OPTIMIZER_SUPPORT_INITFIR_H
 
-#include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "mlir/Conversion/Passes.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/InitAllDialects.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassRegistry.h"
 #include "mlir/Transforms/LocationSnapshot.h"
 #include "mlir/Transforms/Passes.h"
 
 namespace fir::support {
 
 #define FLANG_NONCODEGEN_DIALECT_LIST                                          \
   mlir::AffineDialect, FIROpsDialect, mlir::acc::OpenACCDialect,               \
       mlir::omp::OpenMPDialect, mlir::scf::SCFDialect,                         \
       mlir::arith::ArithmeticDialect, mlir::StandardOpsDialect,                \
       mlir::vector::VectorDialect
 
 // The definitive list of dialects used by flang.
 #define FLANG_DIALECT_LIST                                                     \
   FLANG_NONCODEGEN_DIALECT_LIST, FIRCodeGenDialect, mlir::LLVM::LLVMDialect
 
+inline void registerNonCodegenDialects(mlir::DialectRegistry &registry) {
+  registry.insert<FLANG_NONCODEGEN_DIALECT_LIST>();
+}
+
 /// Register all the dialects used by flang.
 inline void registerDialects(mlir::DialectRegistry &registry) {
   registry.insert<FLANG_DIALECT_LIST>();
 }
 
+inline void loadNonCodegenDialects(mlir::MLIRContext &context) {
+  context.loadDialect<FLANG_NONCODEGEN_DIALECT_LIST>();
+}
+
 /// Forced load of all the dialects used by flang.  Lowering is not an MLIR
 /// pass, but a producer of FIR and MLIR. It is therefore a requirement that the
 /// dialects be preloaded to be able to build the IR.
 inline void loadDialects(mlir::MLIRContext &context) {
   context.loadDialect<FLANG_DIALECT_LIST>();
 }
 
 /// Register the standard passes we use. This comes from registerAllPasses(),
inline void registerMLIRPassesForFortranTools() {
   mlir::registerSimplifyAffineStructuresPass();
   mlir::registerAffineLoopInvariantCodeMotionPass();
   mlir::registerAffineLoopTilingPass();
   mlir::registerAffineDataCopyGenerationPass();
 
   mlir::registerConvertAffineToStandardPass();
 }
 
+/// Register the interfaces needed to lower to LLVM IR.
+void registerLLVMTranslation(mlir::MLIRContext &context);
+
 } // namespace fir::support
 
 #endif // FORTRAN_OPTIMIZER_SUPPORT_INITFIR_H

flang/include/flang/Tools/CLOptions.inc

+//===-- CLOptions.inc -- command line options -------------------*- 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 file defines some shared command-line options that can be used when
+/// debugging the test tools. This file must be included into the tool.
+
+#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "mlir/Transforms/Passes.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "llvm/Support/CommandLine.h"
+
+#define DisableOption(DOName, DOOption, DODescription) \
+  static llvm::cl::opt<bool> disable##DOName("disable-" DOOption, \
+      llvm::cl::desc("disable " DODescription " pass"), llvm::cl::init(false), \
+      llvm::cl::Hidden)
+
+/// Shared option in tools to control whether dynamically sized array
+/// allocations should always be on the heap.
+static llvm::cl::opt<bool> dynamicArrayStackToHeapAllocation(
+    "fdynamic-heap-array",
+    llvm::cl::desc("place all array allocations of dynamic size on the heap"),
+    llvm::cl::init(false), llvm::cl::Hidden);
+
+/// Shared option in tools to set a maximum value for the number of elements in
+/// a compile-time sized array that can be allocated on the stack.
+static llvm::cl::opt<std::size_t> arrayStackAllocationThreshold(
+    "fstack-array-size",
+    llvm::cl::desc(
+        "place all array allocations more than <size> elements on the heap"),
+    llvm::cl::init(~static_cast<std::size_t>(0)), llvm::cl::Hidden);
+
+namespace {
+/// Optimizer Passes
+DisableOption(CfgConversion, "cfg-conversion", "disable FIR to CFG pass");
+DisableOption(FirAvc, "avc", "array value copy analysis and transformation");
+DisableOption(
+    FirMao, "memory-allocation-opt", "memory allocation optimization");
+
+/// CodeGen Passes
+#if !defined(FLANG_EXCLUDE_CODEGEN)
+DisableOption(CodeGenRewrite, "codegen-rewrite", "rewrite FIR for codegen");
+DisableOption(TargetRewrite, "target-rewrite", "rewrite FIR for target");
+DisableOption(FirToLlvmIr, "fir-to-llvmir", "FIR to LLVM-IR dialect");
+DisableOption(LlvmIrToLlvm, "llvm", "conversion to LLVM");
+#endif
+
+/// Generic for adding a pass to the pass manager if it is not disabled.
+template <typename F>
+void addPassConditionally(
+    mlir::PassManager &pm, llvm::cl::opt<bool> &disabled, F ctor) {
+  if (!disabled)
+    pm.addPass(ctor());
+}
+
+template <typename OP, typename F>
+void addNestedPassConditionally(
+    mlir::PassManager &pm, llvm::cl::opt<bool> &disabled, F ctor) {
+  if (!disabled)
+    pm.addNestedPass<OP>(ctor());
+}
+
+} // namespace
+
+namespace fir {
+
+static void defaultFlangInlinerOptPipeline(mlir::OpPassManager &pm) {
+  mlir::GreedyRewriteConfig config;
+  config.enableRegionSimplification = false;
+  pm.addPass(mlir::createCanonicalizerPass(config));
+}
+
+inline void addCfgConversionPass(mlir::PassManager &pm) {
+  addNestedPassConditionally<mlir::FuncOp>(
+      pm, disableCfgConversion, fir::createFirToCfgPass);
+}
+
+inline void addAVC(mlir::PassManager &pm) {
+  addNestedPassConditionally<mlir::FuncOp>(
+      pm, disableFirAvc, fir::createArrayValueCopyPass);
+}
+
+#if !defined(FLANG_EXCLUDE_CODEGEN)
+inline void addCodeGenRewritePass(mlir::PassManager &pm) {
+  addPassConditionally(
+      pm, disableCodeGenRewrite, fir::createFirCodeGenRewritePass);
+}
+
+inline void addTargetRewritePass(mlir::PassManager &pm) {
+  addPassConditionally(pm, disableTargetRewrite, []() {
+    return fir::createFirTargetRewritePass(fir::TargetRewriteOptions{});
+  });
+}
+
+inline void addFIRToLLVMPass(mlir::PassManager &pm) {
+  addPassConditionally(pm, disableFirToLlvmIr, fir::createFIRToLLVMPass);
+}
+
+inline void addLLVMDialectToLLVMPass(
+    mlir::PassManager &pm, llvm::raw_ostream &output) {
+  addPassConditionally(pm, disableLlvmIrToLlvm,
+      [&]() { return fir::createLLVMDialectToLLVMPass(output); });
+}
+#endif
+
+/// Create a pass pipeline for running default optimization passes for
+/// incremental conversion of FIR.
+///
+/// \param pm - MLIR pass manager that will hold the pipeline definition
+inline void createDefaultFIROptimizerPassPipeline(mlir::PassManager &pm) {
+  // simplify the IR
+  mlir::GreedyRewriteConfig config;
+  config.enableRegionSimplification = false;
+  fir::addAVC(pm);
+  pm.addNestedPass<mlir::FuncOp>(fir::createCharacterConversionPass());
+  pm.addPass(mlir::createCanonicalizerPass(config));
+
+  // The default inliner pass adds the canonicalizer pass with the default
+  // configuration. Create the inliner pass with tco config.
+  llvm::StringMap<mlir::OpPassManager> pipelines;
+  pm.addPass(
+      mlir::createInlinerPass(pipelines, defaultFlangInlinerOptPipeline));
+  pm.addPass(mlir::createCSEPass());
+
+  // convert control flow to CFG form
+  fir::addCfgConversionPass(pm);
+  pm.addPass(mlir::createLowerToCFGPass());
+
+  pm.addPass(mlir::createCanonicalizerPass(config));
+}
+
+#if !defined(FLANG_EXCLUDE_CODEGEN)
+inline void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm) {
+  pm.addNestedPass<mlir::FuncOp>(fir::createAbstractResultOptPass());
+  fir::addCodeGenRewritePass(pm);
+  fir::addTargetRewritePass(pm);
+  fir::addFIRToLLVMPass(pm);
+}
+
+/// Create a pass pipeline for lowering from MLIR to LLVM IR
+///
+/// \param pm - MLIR pass manager that will hold the pipeline definition
+inline void createMLIRToLLVMPassPipeline(mlir::PassManager &pm) {
+  // Add default optimizer pass pipeline.
+  fir::createDefaultFIROptimizerPassPipeline(pm);
+
+  // Add codegen pass pipeline.
+  fir::createDefaultFIRCodeGenPassPipeline(pm);
+}
+#undef FLANG_EXCLUDE_CODEGEN
+#endif
+
+} // namespace fir

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Support/TypeCode.h"
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
+#include "mlir/Target/LLVMIR/ModuleTranslation.h"
 #include "llvm/ADT/ArrayRef.h"
 
 #define DEBUG_TYPE "flang-codegen"
 
 // fir::LLVMTypeConverter for converting to LLVM IR dialect types.
 #include "TypeConverter.h"
 
 // TODO: This should really be recovered from the specified target.
void runOnOperation() override final {
 
     // apply the patterns
     if (mlir::failed(mlir::applyFullConversion(getModule(), target,
                                                std::move(pattern)))) {
       signalPassFailure();
     }
   }
 };
+
+/// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
+struct LLVMIRLoweringPass
+    : public mlir::PassWrapper<LLVMIRLoweringPass,
+                               mlir::OperationPass<mlir::ModuleOp>> {
+  using Printer = fir::LLVMIRLoweringPrinter;
+  LLVMIRLoweringPass(raw_ostream &output, Printer p)
+      : output{output}, printer{p} {}
+
+  mlir::ModuleOp getModule() { return getOperation(); }
+
+  void runOnOperation() override final {
+    auto *ctx = getModule().getContext();
+    auto optName = getModule().getName();
+    llvm::LLVMContext llvmCtx;
+    if (auto llvmModule = mlir::translateModuleToLLVMIR(
+            getModule(), llvmCtx, optName ? *optName : "FIRModule")) {
+      printer(*llvmModule, output);
+      return;
+    }
+
+    mlir::emitError(mlir::UnknownLoc::get(ctx), "could not emit LLVM-IR\n");
+    signalPassFailure();
+  }
+
+private:
+  raw_ostream &output;
+  Printer printer;
+};
+
 } // namespace
 
 std::unique_ptr<mlir::Pass> fir::createFIRToLLVMPass() {
   return std::make_unique<FIRToLLVMLowering>();
 }
+
+std::unique_ptr<mlir::Pass>
+fir::createLLVMDialectToLLVMPass(raw_ostream &output,
+                                 fir::LLVMIRLoweringPrinter printer) {
+  return std::make_unique<LLVMIRLoweringPass>(output, printer);
+}

flang/lib/Optimizer/Support/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FIRSupport
   FIRContext.cpp
+  InitFIR.cpp
   InternalNames.cpp
   KindMapping.cpp
 
   DEPENDS
   FIROpsIncGen
   MLIRIR
   ${dialect_libs}
 
   LINK_LIBS
   ${dialect_libs}
   MLIROpenMPToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
 )

flang/lib/Optimizer/Support/InitFIR.cpp

+//===-- Optimizer/Support/InitFIR.cpp -------------------------------------===//
+//
+// 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 "flang/Optimizer/Support/InitFIR.h"
+#include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.h"
+#include "mlir/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.h"
+
+void fir::support::registerLLVMTranslation(mlir::MLIRContext &context) {
+  mlir::DialectRegistry registry;
+  // Register OpenMP dialect interface here as well.
+  mlir::registerOpenMPDialectTranslation(registry);
+  // Register LLVM-IR dialect interface.
+  registerLLVMDialectTranslation(registry);
+  context.appendDialectRegistry(registry);
+}

flang/test/Fir/basic-program.fir

+// RUN: tco --target=x86_64-unknown-linux-gnu %s | FileCheck %s
+
+// Check that tco is working with a basic test.
+
+func @_QQmain() {
+  return
+}
+
+// CHECK: ; ModuleID = 'FIRModule'
+// CHECK-LABEL: define void @_QQmain()
+// CHECK:       ret void

flang/tools/tco/CMakeLists.txt

-get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+set(LLVM_LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
+)
 
-set(LIBS
+add_flang_tool(tco tco.cpp)
+llvm_update_compile_flags(tco)
+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+target_link_libraries(tco PRIVATE
   FIRCodeGen
   FIRDialect
   FIRSupport
   FIRTransforms
+  FIRBuilder
   ${dialect_libs}
   MLIRIR
   MLIRLLVMIR
+  MLIRLLVMToLLVMIRTranslation
+  MLIRTargetLLVMIRExport
   MLIRPass
   MLIRStandardToLLVM
   MLIRTransforms
   MLIRAffineToStandard
   MLIRAnalysis
   MLIRSCFToStandard
   MLIRParser
   MLIRStandardToLLVM
   MLIRSupport
   MLIRVectorToLLVM
 )
-
-add_flang_tool(tco tco.cpp)
-target_link_libraries(tco PRIVATE ${LIBS})

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/Support/FIRContext.h"
 #include "flang/Optimizer/Support/InitFIR.h"
+#include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
+#include "mlir/IR/AsmState.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.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"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 static cl::opt<std::string>
     inputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
 
 static cl::opt<std::string> outputFilename("o",
                                            cl::desc("Specify output filename"),
                                            cl::value_desc("filename"),
                                            cl::init("-"));
 
 static cl::opt<bool> emitFir("emit-fir",
                              cl::desc("Parse and pretty-print the input"),
                              cl::init(false));
 
+static cl::opt<std::string> targetTriple("target",
+                                         cl::desc("specify a target triple"),
+                                         cl::init("native"));
+
+#include "flang/Tools/CLOptions.inc"
+
 static void printModuleBody(mlir::ModuleOp mod, raw_ostream &output) {
-  for (auto &op : mod.getBody()->without_terminator())
+  for (auto &op : *mod.getBody())
     output << op << '\n';
 }
 
 // compile a .fir file
 static mlir::LogicalResult
 compileFIR(const mlir::PassPipelineCLParser &passPipeline) {
   // check that there is a file to load
   ErrorOr<std::unique_ptr<MemoryBuffer>> fileOrErr =
       MemoryBuffer::getFileOrSTDIN(inputFilename);
 
   if (std::error_code EC = fileOrErr.getError()) {
     errs() << "Could not open file: " << EC.message() << '\n';
     return mlir::failure();
   }
 
   // load the file into a module
   SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), SMLoc());
   mlir::DialectRegistry registry;
   fir::support::registerDialects(registry);
   mlir::MLIRContext context(registry);
+  fir::support::loadDialects(context);
+  fir::support::registerLLVMTranslation(context);
   auto owningRef = mlir::parseSourceFile(sourceMgr, &context);
 
   if (!owningRef) {
     errs() << "Error can't load file " << inputFilename << '\n';
     return mlir::failure();
   }
   if (mlir::failed(owningRef->verify())) {
     errs() << "Error verifying FIR module\n";
     return mlir::failure();
   }
 
   std::error_code ec;
   ToolOutputFile out(outputFilename, ec, sys::fs::OF_None);
 
   // run passes
-  mlir::PassManager pm{&context};
+  fir::KindMapping kindMap{&context};
+  fir::setTargetTriple(*owningRef, targetTriple);
+  fir::setKindMapping(*owningRef, kindMap);
+  mlir::PassManager pm(&context, mlir::OpPassManager::Nesting::Implicit);
+  pm.enableVerifier(/*verifyPasses=*/true);
   mlir::applyPassManagerCLOptions(pm);
   if (emitFir) {
     // parse the input and pretty-print it back out
     // -emit-fir intentionally disables all the passes
+  } else if (passPipeline.hasAnyOccurrences()) {
+    auto errorHandler = [&](const Twine &msg) {
+      mlir::emitError(mlir::UnknownLoc::get(pm.getContext())) << msg;
+      return mlir::failure();
+    };
+    if (mlir::failed(passPipeline.addToPipeline(pm, errorHandler)))
+      return mlir::failure();
   } else {
-    // TODO: Actually add passes when added to FIR code base
-    // add all the passes
-    // the user can disable them individually
+    fir::createMLIRToLLVMPassPipeline(pm);
+    fir::addLLVMDialectToLLVMPass(pm, out.os());
   }
 
   // run the pass manager
   if (mlir::succeeded(pm.run(*owningRef))) {
     // passes ran successfully, so keep the output
-    if (emitFir)
+    if (emitFir || passPipeline.hasAnyOccurrences())
       printModuleBody(*owningRef, out.os());
     out.keep();
     return mlir::success();
   }
 
   // pass manager failed
   printModuleBody(*owningRef, errs());
   errs() << "\n\nFAILED: " << inputFilename << '\n';
   return mlir::failure();
 }
 
 int main(int argc, char **argv) {
-  fir::support::registerMLIRPassesForFortranTools();
   [[maybe_unused]] InitLLVM y(argc, argv);
+  fir::support::registerMLIRPassesForFortranTools();
+  fir::registerOptCodeGenPasses();
+  fir::registerOptTransformPasses();
+  InitializeAllTargets();
+  mlir::registerAsmPrinterCLOptions();
+  mlir::registerMLIRContextCLOptions();
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
   cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Optimizer\n");
   return mlir::failed(compileFIR(passPipe));
 }