[flang] Add TargetRewrite pass

[rovka]

Summary

This patch adds the basic infrastructure for the TargetRewrite pass,
which rewrites certain FIR dialect operations into target specific
forms. In particular, it converts boxchar function parameters, call
arguments and return values. Other rewritings will be included in
future patches.

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

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

[awarzynski]

Thanks for sending this @rovka ! Please see my questions/suggestions inline.

flang/lib/Optimizer/CodeGen/Target.h

75

What is sret?

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

57

[nit] IR --> MLIR (I think that IR is too ambiguous here)

flang/test/Fir/target.fir

6

Could you add comments to highlight which cases from the pass implementation are tested? Based on comments in TargetRewrite.cpp, I'd expect to see

• type conversion on signatures and call sites.
• ops conversion in target-specific patterns.

54

This signature is also modified - could you add a CHECK line?

[rovka]

flang/lib/Optimizer/CodeGen/Target.h

75

It's an LLVM parameter attribute for a parameter that's actually the return value of the function (probably short for 'struct return'). Would it be clearer if I rephrased the comment to "[...] converted that return value to an argument with the sret attribute"? The attribute is also mentioned in the last sentence in the comment, so I'm not sure if rephrasing really adds anything.

flang/test/Fir/target.fir

54

Good point, thanks!

[rovka]

Fixup comments based on feedback from Andrzej.

[rovka]

Fixup test (didn't rename function everywhere).

[awarzynski]

Thanks for addressing my comments! I've added a few more suggestions, but nothing major.

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

31

[nit] In line with the change in TargetRewrite.cpp, IR --> FIR

flang/lib/Optimizer/CodeGen/Target.cpp

39

I think that I understand why append=!sret, but why is sret initialized with {}rather than the input argument?

flang/lib/Optimizer/CodeGen/Target.h

71

nit

75

Ah, thanks! I think that context is key here :) How about:

/// A function that returns a `boxchar<n>` type value must already have
/// converted that return value to an argument decorated with LLVM's `sret` attribute.

?

I don't know what Attribute is L78 referring to TBH. I'm guessing fir::details::Attributes?

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

26–30

[nit] Why not move this to the top of the file? It looks like a comment that will apply to everything in this file.

flang/test/Fir/target.fir

34

Would it make sense to add a few more cases here?

// More than one `sret` arg (verify that the array length is stored next to the `sret` arg)
func @boxcharsret_1(%arg0 : !fir.boxchar<1> {llvm.sret}, %arg1 : !fir.boxchar<1> {llvm.sret}, %arg2 : !fir.boxchar<1>) {
  return
}

// Multiple non `sret` args (verify that the array length is stored at the end, after the array args)
func @boxcharsret_2(%arg0 : !fir.boxchar<1> {llvm.sret}, %arg1 : !fir.boxchar<1>, %arg2 : !fir.boxchar<1>) {
  return
}

You can skip the function body and just verify that the signature is updated.

[rovka]

flang/lib/Optimizer/CodeGen/Target.cpp

39

Good catch. That looks like an oversight and it seems we're never actually checking the value of that 'sret' anyway. I'm just going to trim this class and we can add the other bits back when actually needed.

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

26–30

Fair point

flang/test/Fir/target.fir

34

Sure, I can add a testcase for the latter, but I think if we try to do multiple srets we'll hit the FIXME in this patch at TargetRewrite.cpp line 126. To be honest I'm not sure if multiple srets are possible, my understanding of LLVM IR is that if a function has multiple results they all get bundled up in a single struct and that's the sret argument (there's no use in having more than 1). Personally I would sooner have an llvm_unreachable on that path. But then again my understanding might be blatantly wrong or skewed towards how clang does things. It would be nice to have some input from someone that actually knows FIR :)

[awarzynski]

LGTM!

Thank you for addressing my comments :)

flang/test/Fir/target.fir

34

Thanks! I would be in favor of llvm_unreachable on L126 in TargetRewrite.cpp, but will leave it as a nit.

[schweitz]

flang/lib/Optimizer/CodeGen/Target.cpp

39

sret is a parameter to the function as well as a field in the attribute set.

Other targets and data types will need sret support. I don't know that dropping it on the floor will help.

flang/lib/Optimizer/CodeGen/Target.h

75

How about putting a link to the LLVM language reference? No need to restate the LLVM concept again here, as these rewrites are specifically targeting LLVM.

flang/test/Fir/target.fir

34

I don't think llvm_unreachable is what we want here. (Especially introducing undefined behavior for what could become a valid case.)

FIR allows specialization of functions and letting them return anonymous tuples/vectors of results.

That said, the definition for exactly how the ABI should look in LLVM IR for these has not been nailed down. Currently this takes a hands off approach and omits the rewriting. That may be sufficient or not in the long run.

[rovka]

flang/lib/Optimizer/CodeGen/Target.cpp

39

I agree that it will probably be needed in the future and we can add it back when that happens. I also removed the byval, which I'll be adding back in the very next patch (rewriting complex stuff). I'd like to avoid having dead/untested code around, since that makes it difficult to know for sure what's properly supported. If somebody did need the sret for something and ran into this bug it would probably take them more time to figure out what's going on than it would take them to add it from scratch.

flang/lib/Optimizer/CodeGen/Target.h

75

Sounds like a good idea, thanks.

flang/test/Fir/target.fir

34

I don't think llvm_unreachable is what we want here. (Especially introducing undefined behavior for what could become a valid case.)

It's only undefined behaviour for release builds :) Otherwise it's a very important tool for finding and debugging issues.

In any case, I only suggested llvm_unreachable because that's what I'm used to from the rest of llvm. What I really meant was something that would either crash or elegantly error out rather than roll along and generate something that we're uncertain about. Do we have something better that we can use? I see this has been discussed before here but I don't know the whole story.

FIR allows specialization of functions and letting them return anonymous tuples/vectors of results.

That said, the definition for exactly how the ABI should look in LLVM IR for these has not been nailed down. Currently this takes a hands off approach and omits the rewriting. That may be sufficient or not in the long run.

I'm not sure that's the best approach. If code outside TargetRewrite doesn't know how to handle a single boxchar sret it seems unlikely that it will know how to handle multiple boxchar srets, so we'll probably either get errors in other parts of the compiler or worse generate wrong code. I think it's better to be conservative and get a hard error here (and in any other places that may touch sret but don't yet handle multiple srets). This will make it easier to figure out which parts need to be updated if we do decide to support multiple srets in the future.

As a sidenote, I also tried to run a test with 2 srets, and the output seemed buggy to me (it left both srets in but also added a rewritten one). I didn't investigate much because if this is not supported in the rest of the pipeline I don't think it's worth putting any effort in it right now.

[awarzynski]

flang/lib/Optimizer/CodeGen/Target.cpp

39

+1

flang/test/Fir/target.fir

34

I only suggested llvm_unreachable because that's what I'm used to from the rest of llvm.

+1. llvm_unreachable is a well known and popular mechanism within LLVM. In this case, we would be using it to document that a particular case is not supported _yet_. If we do decide to implement support for more sret arguments, then the compiler will hit this code and llvm_unreachable will contain a helpful message that will add some useful context. This context is quite clear just now (we are discussing it), but it might not be so obvious to our future selves. Or to some other developer that will be adding this support.

[schweitz]

flang/lib/Optimizer/CodeGen/Target.cpp

39

I don't see a problem with adding things in small increments, so long as there is a plan to not leave behind holes in the functionality.

flang/test/Fir/target.fir

34

Sorry for the misunderstanding.

Yes, we do not currently return multiple values. And obviously the LLVM-IR dialect isn't going to deal well with FIR types.

Placing a TODO() here is the current approach.

(In Flang, llvm_unreachable is considered bad practice precisely because it gets compiled to undefined behavior in release builds, which some developers prefer.)

[mehdi_amini]

flang/test/Fir/target.fir

5

This is running a pass, this should be testable/tested with fir-opt.

If the only thing that tco provides is overriding the triple, this can also be done in a trivial pass that you just apply on the module (strawman, it'd look: pipeline=module(overrideTargetTriple{target=aarch64-unknown-linux-gnu}, target-rewrite)

34

llvm_unreachable isn't meant for things that should work but aren't implemented yet, they are meant for things that really cannot happen from a system point of view: I should be able to plug a Fuzzer in front of a component and never hit an unreachable (assuming you don't break a documented API invariant).
In general the invariant for the IR is "does it pass the verifier": hitting an unreachable on "valid IR" wouldn't seem right to me.
(llvm::report_fatal_error provides with the same "helpful message and context" you referred to, but isn't optimized away in release mode)

[rovka]

Replaced all llvm_unreachable with TODOs.
Added a pass option for the target triple.
Switched the tests to fir-opt and removed all changes to tco.

[rovka]

flang/test/Fir/target.fir

5

I added a pass option instead since it seemed easier / less boilerplate.

34

Ok, thanks, TODO sounds fine to me.

[rovka]

@mehdi_amini Does this look ok now?

[mehdi_amini]

In D112910#3114784, @rovka wrote:

@mehdi_amini Does this look ok now?

I haven't reviewed the patch deeply, but feel free to move forward with Andrzej's review here! Thanks for checking :)

[clementval]

Thanks for the patch @rovka LG!

flang/include/flang/Optimizer/CodeGen/CGPasses.td

let dependentDialects = [
     "fir::FIROpsDialect", "fir::FIRCodeGenDialect", "mlir::BuiltinDialect",
     "mlir::LLVM::LLVMDialect", "mlir::omp::OpenMPDialect"
   ];
   let statistics = [
     Statistic<"numDCE", "num-dce'd", "Number of operations eliminated">
   ];
 }
 
+def TargetRewrite : Pass<"target-rewrite", "mlir::ModuleOp"> {
+  let summary = "Rewrite some FIR dialect into target specific forms.";
+  let description = [{
+      Certain abstractions in the FIR dialect need to be rewritten to reflect
+      representations that may differ based on the target machine.
+  }];
+  let constructor = "::fir::createFirTargetRewritePass()";
+  let dependentDialects = [ "fir::FIROpsDialect" ];
+  let options = [
+    Option<"noCharacterConversion", "no-character-conversion",
+           "bool", /*default=*/"false",
+           "Disable target-specific conversion of CHARACTER.">
+  ];
+}
+
 #endif // FORTRAN_OPTIMIZER_CODEGEN_FIR_PASSES

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

 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{};
+};
+
+/// Prerequiste pass for code gen. Perform intermediate rewrites to tailor the
+/// IR 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();
 
 /// Convert the LLVM IR dialect to LLVM-IR proper
 std::unique_ptr<mlir::Pass>
 createLLVMDialectToLLVMPass(llvm::raw_ostream &output);
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/CodeGen/CGPasses.h.inc"
 
 } // namespace fir
 
 #endif // OPTIMIZER_CODEGEN_CODEGEN_H

flang/lib/Optimizer/CodeGen/CMakeLists.txt

 add_flang_library(FIRCodeGen
   CGOps.cpp
   CodeGen.cpp
   PreCGRewrite.cpp
+  Target.cpp
+  TargetRewrite.cpp
 
   DEPENDS
   FIRDialect
   FIRSupport
   FIROptCodeGenPassIncGen
   CGOpsIncGen
 
   LINK_LIBS

flang/lib/Optimizer/CodeGen/Target.h

+//===- Target.h - target specific details -----------------------*- 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_OPTMIZER_CODEGEN_TARGET_H
+#define FORTRAN_OPTMIZER_CODEGEN_TARGET_H
+
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "llvm/ADT/Triple.h"
+#include <memory>
+#include <tuple>
+#include <vector>
+
+namespace fir {
+
+namespace details {
+/// Extra information about how to marshal an argument or return value that
+/// modifies a signature per a particular ABI's calling convention.
+/// Note: llvm::Attribute is not used directly, because its use depends on an
+/// LLVMContext.
+class Attributes {
+public:
+  Attributes() : alignment{0}, byval{false}, sret{false}, append{false} {}
+  Attributes(unsigned short alignment, bool byval = false, bool sret = false,
+             bool append = false)
+      : alignment{alignment}, byval{byval}, sret{sret}, append{append} {}
+
+  unsigned getAlignment() const { return alignment; }
+  bool hasAlignment() const { return alignment != 0; }
+  bool isByVal() const { return byval; }
+  bool returnValueAsArgument() const { return isSRet(); }
+  bool isSRet() const { return sret; }
+  bool isAppend() const { return append; }
+
+private:
+  unsigned short alignment{};
+  bool byval : 1;
+  bool sret : 1;
+  bool append : 1;
+};
+
+} // namespace details
+
+/// Some details of how to represent certain features depend on the target and
+/// ABI that is being used.  These specifics are captured here and guide the
+/// lowering of FIR to LLVM-IR dialect.
+class CodeGenSpecifics {
+public:
+  using Attributes = details::Attributes;
+  using Marshalling = std::vector<std::tuple<mlir::Type, Attributes>>;
+
+  static std::unique_ptr<CodeGenSpecifics>
+  get(mlir::MLIRContext *ctx, llvm::Triple &&trp, KindMapping &&kindMap);
+
+  CodeGenSpecifics(mlir::MLIRContext *ctx, llvm::Triple &&trp,
+                   KindMapping &&kindMap)
+      : context{*ctx}, triple{std::move(trp)}, kindMap{std::move(kindMap)} {}
+  CodeGenSpecifics() = delete;
+  virtual ~CodeGenSpecifics() {}
+
+  /// Type presentation of a `boxchar<n>` type argument when passed by value. An
+  /// argument value may need to be passed as a (safe) reference argument.
+  ///
+  /// A function that returns a `boxchar<n>` type value must already have
+  /// converted that return value to an sret argument. This requirement is in
+  /// keeping with Fortran semantics, which require the caller to allocate the
+  /// space for the return CHARACTER value and pass a pointer and the length of
+  /// that space (a boxchar) to the called function. Such functions should be
+  /// annotated with an Attribute to distinguish the sret argument.
+  virtual Marshalling boxcharArgumentType(mlir::Type eleTy,
+                                          bool sret = false) const = 0;
+
+protected:
+  mlir::MLIRContext &context;
+  llvm::Triple triple;
+  KindMapping kindMap;
+};
+
+} // namespace fir
+
+#endif // FORTRAN_OPTMIZER_CODEGEN_TARGET_H

flang/lib/Optimizer/CodeGen/Target.cpp

+//===-- Target.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#include "Target.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/TypeRange.h"
+
+#define DEBUG_TYPE "flang-codegen-target"
+
+using namespace fir;
+
+namespace {
+template <typename S>
+struct GenericTarget : public CodeGenSpecifics {
+  using CodeGenSpecifics::CodeGenSpecifics;
+  using AT = CodeGenSpecifics::Attributes;
+
+  Marshalling boxcharArgumentType(mlir::Type eleTy, bool sret) const override {
+    CodeGenSpecifics::Marshalling marshal;
+    auto idxTy = mlir::IntegerType::get(eleTy.getContext(), S::defaultWidth);
+    auto ptrTy = fir::ReferenceType::get(eleTy);
+    marshal.emplace_back(ptrTy, AT{});
+    // Return value arguments are grouped as a pair. Others are passed in a
+    // split format with all pointers first (in the declared position) and all
+    // LEN arguments appended after all of the dummy arguments.
+    // NB: Other conventions/ABIs can/should be supported via options.
+    marshal.emplace_back(idxTy, AT{0, {}, {}, /*append=*/!sret});
+    return marshal;
+  }
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// i386 (x86 32 bit) linux target specifics.
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TargetI386 : public GenericTarget<TargetI386> {
+  using GenericTarget::GenericTarget;
+
+  static constexpr int defaultWidth = 32;
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// x86_64 (x86 64 bit) linux target specifics.
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TargetX86_64 : public GenericTarget<TargetX86_64> {
+  using GenericTarget::GenericTarget;
+
+  static constexpr int defaultWidth = 64;
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// AArch64 linux target specifics.
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TargetAArch64 : public GenericTarget<TargetAArch64> {
+  using GenericTarget::GenericTarget;
+
+  static constexpr int defaultWidth = 64;
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// PPC64le linux target specifics.
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TargetPPC64le : public GenericTarget<TargetPPC64le> {
+  using GenericTarget::GenericTarget;
+
+  static constexpr int defaultWidth = 64;
+};
+} // namespace
+
+// Instantiate the overloaded target instance based on the triple value.
+// Currently, the implementation only instantiates `i386-unknown-linux-gnu`,
+// `x86_64-unknown-linux-gnu`, aarch64 and ppc64le like triples. Other targets
+// should be added to this file as needed.
+std::unique_ptr<fir::CodeGenSpecifics>
+fir::CodeGenSpecifics::get(mlir::MLIRContext *ctx, llvm::Triple &&trp,
+                           KindMapping &&kindMap) {
+  switch (trp.getArch()) {
+  default:
+    break;
+  case llvm::Triple::ArchType::x86:
+    switch (trp.getOS()) {
+    default:
+      break;
+    case llvm::Triple::OSType::Linux:
+    case llvm::Triple::OSType::Darwin:
+      return std::make_unique<TargetI386>(ctx, std::move(trp),
+                                          std::move(kindMap));
+    }
+    break;
+  case llvm::Triple::ArchType::x86_64:
+    switch (trp.getOS()) {
+    default:
+      break;
+    case llvm::Triple::OSType::Linux:
+    case llvm::Triple::OSType::Darwin:
+      return std::make_unique<TargetX86_64>(ctx, std::move(trp),
+                                            std::move(kindMap));
+    }
+    break;
+  case llvm::Triple::ArchType::aarch64:
+    switch (trp.getOS()) {
+    default:
+      break;
+    case llvm::Triple::OSType::Linux:
+    case llvm::Triple::OSType::Darwin:
+      return std::make_unique<TargetAArch64>(ctx, std::move(trp),
+                                             std::move(kindMap));
+    }
+    break;
+  case llvm::Triple::ArchType::ppc64le:
+    switch (trp.getOS()) {
+    default:
+      break;
+    case llvm::Triple::OSType::Linux:
+      return std::make_unique<TargetPPC64le>(ctx, std::move(trp),
+                                             std::move(kindMap));
+    }
+    break;
+  }
+  llvm::report_fatal_error("target not implemented");
+}

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

+//===-- TargetRewrite.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#include "PassDetail.h"
+#include "Target.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/FIRContext.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/TypeSwitch.h"
+#include "llvm/Support/Debug.h"
+
+//===----------------------------------------------------------------------===//
+// Target rewrite: rewriting of ops to make target-specific lowerings manifest.
+// LLVM expects different lowering idioms to be used for distinct target
+// triples. These distinctions are handled by this pass.
+//===----------------------------------------------------------------------===//
+
+using namespace fir;
+
+#define DEBUG_TYPE "flang-target-rewrite"
+
+namespace {
+
+/// Fixups for updating a FuncOp's arguments and return values.
+struct FixupTy {
+  enum class Codes { CharPair, Trailing };
+
+  FixupTy(Codes code, std::size_t index, std::size_t second = 0)
+      : code{code}, index{index}, second{second} {}
+  FixupTy(Codes code, std::size_t index,
+          std::function<void(mlir::FuncOp)> &&finalizer)
+      : code{code}, index{index}, finalizer{finalizer} {}
+  FixupTy(Codes code, std::size_t index, std::size_t second,
+          std::function<void(mlir::FuncOp)> &&finalizer)
+      : code{code}, index{index}, second{second}, finalizer{finalizer} {}
+
+  Codes code;
+  std::size_t index;
+  std::size_t second{};
+  llvm::Optional<std::function<void(mlir::FuncOp)>> finalizer{};
+}; // namespace
+
+/// Target-specific rewriting of the FIR. This is a prerequisite pass to code
+/// generation that traverses the FIR and modifies types and operations to a
+/// form that is appropriate for the specific target. LLVM IR has specific
+/// idioms that are used for distinct target processor and ABI combinations.
+class TargetRewrite : public TargetRewriteBase<TargetRewrite> {
+public:
+  TargetRewrite(const TargetRewriteOptions &options) {
+    noCharacterConversion = options.noCharacterConversion;
+  }
+
+  void runOnOperation() override final {
+    auto &context = getContext();
+    mlir::OpBuilder rewriter(&context);
+    auto mod = getModule();
+    auto specifics = CodeGenSpecifics::get(getOperation().getContext(),
+                                           getTargetTriple(getOperation()),
+                                           getKindMapping(getOperation()));
+    setMembers(specifics.get(), &rewriter);
+
+    // Perform type conversion on signatures and call sites.
+    if (mlir::failed(convertTypes(mod))) {
+      mlir::emitError(mlir::UnknownLoc::get(&context),
+                      "error in converting types to target abi");
+      signalPassFailure();
+    }
+
+    // Convert ops in target-specific patterns.
+    mod.walk([&](mlir::Operation *op) {
+      if (auto call = dyn_cast<fir::CallOp>(op)) {
+        if (!hasPortableSignature(call.getFunctionType()))
+          convertCallOp(call);
+      } else if (auto dispatch = dyn_cast<DispatchOp>(op)) {
+        if (!hasPortableSignature(dispatch.getFunctionType()))
+          convertCallOp(dispatch);
+      }
+    });
+
+    clearMembers();
+  }
+
+  mlir::ModuleOp getModule() { return getOperation(); }
+
+  // Convert fir.call and fir.dispatch Ops.
+  template <typename A>
+  void convertCallOp(A callOp) {
+    auto fnTy = callOp.getFunctionType();
+    auto loc = callOp.getLoc();
+    rewriter->setInsertionPoint(callOp);
+    llvm::SmallVector<mlir::Type> newResTys;
+    llvm::SmallVector<mlir::Type> newInTys;
+    llvm::SmallVector<mlir::Value> newOpers;
+
+    // If the call is indirect, the first argument must still be the function
+    // to call.
+    int dropFront = 0;
+    if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
+      if (!callOp.callee().hasValue()) {
+        newInTys.push_back(fnTy.getInput(0));
+        newOpers.push_back(callOp.getOperand(0));
+        dropFront = 1;
+      }
+    }
+
+    // Determine the rewrite function, `wrap`, for the result value.
+    llvm::Optional<std::function<mlir::Value(mlir::Operation *)>> wrap;
+    if (fnTy.getResults().size() == 1) {
+      mlir::Type ty = fnTy.getResult(0);
+      newResTys.push_back(ty);
+    } else if (fnTy.getResults().size() > 1) {
+      // If the function is returning more than 1 result, do not perform any
+      // target-specific lowering. (FIXME?) This may need to be revisited.
+      newResTys.insert(newResTys.end(), fnTy.getResults().begin(),
+                       fnTy.getResults().end());
+    }
+
+    llvm::SmallVector<mlir::Type> trailingInTys;
+    llvm::SmallVector<mlir::Value> trailingOpers;
+    for (auto e : llvm::enumerate(
+             llvm::zip(fnTy.getInputs().drop_front(dropFront),
+                       callOp.getOperands().drop_front(dropFront)))) {
+      mlir::Type ty = std::get<0>(e.value());
+      mlir::Value oper = std::get<1>(e.value());
+      unsigned index = e.index();
+      llvm::TypeSwitch<mlir::Type>(ty)
+          .template Case<BoxCharType>([&](BoxCharType boxTy) {
+            bool sret;
+            if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
+              sret = callOp.callee() &&
+                     functionArgIsSRet(index,
+                                       getModule().lookupSymbol<mlir::FuncOp>(
+                                           *callOp.callee()));
+            } else {
+              // TODO: dispatch case; how do we put arguments on a call?
+              // We cannot put both an sret and the dispatch object first.
+              sret = false;
+              llvm_unreachable("not implemented");
+            }
+            auto m = specifics->boxcharArgumentType(boxTy.getEleTy(), sret);
+            auto unbox =
+                rewriter->create<UnboxCharOp>(loc, std::get<mlir::Type>(m[0]),
+                                              std::get<mlir::Type>(m[1]), oper);
+            // unboxed CHARACTER arguments
+            for (auto e : llvm::enumerate(m)) {
+              unsigned idx = e.index();
+              auto attr = std::get<CodeGenSpecifics::Attributes>(e.value());
+              auto argTy = std::get<mlir::Type>(e.value());
+              if (attr.isAppend()) {
+                trailingInTys.push_back(argTy);
+                trailingOpers.push_back(unbox.getResult(idx));
+              } else {
+                newInTys.push_back(argTy);
+                newOpers.push_back(unbox.getResult(idx));
+              }
+            }
+          })
+          .Default([&](mlir::Type ty) {
+            newInTys.push_back(ty);
+            newOpers.push_back(oper);
+          });
+    }
+    newInTys.insert(newInTys.end(), trailingInTys.begin(), trailingInTys.end());
+    newOpers.insert(newOpers.end(), trailingOpers.begin(), trailingOpers.end());
+    if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
+      fir::CallOp newCall;
+      if (callOp.callee().hasValue()) {
+        newCall = rewriter->create<A>(loc, callOp.callee().getValue(),
+                                      newResTys, newOpers);
+      } else {
+        // Force new type on the input operand.
+        newOpers[0].setType(mlir::FunctionType::get(
+            callOp.getContext(),
+            mlir::TypeRange{newInTys}.drop_front(dropFront), newResTys));
+        newCall = rewriter->create<A>(loc, newResTys, newOpers);
+      }
+      LLVM_DEBUG(llvm::dbgs() << "replacing call with " << newCall << '\n');
+      if (wrap.hasValue())
+        replaceOp(callOp, (*wrap)(newCall.getOperation()));
+      else
+        replaceOp(callOp, newCall.getResults());
+    } else {
+      // A is fir::DispatchOp
+      llvm_unreachable("not implemented"); // TODO
+    }
+  }
+  /// Convert the type signatures on all the functions present in the module.
+  /// As the type signature is being changed, this must also update the
+  /// function itself to use any new arguments, etc.
+  mlir::LogicalResult convertTypes(mlir::ModuleOp mod) {
+    for (auto fn : mod.getOps<mlir::FuncOp>())
+      convertSignature(fn);
+    return mlir::success();
+  }
+
+  /// If the signature does not need any special target-specific converions,
+  /// then it is considered portable for any target, and this function will
+  /// return `true`. Otherwise, the signature is not portable and `false` is
+  /// returned.
+  bool hasPortableSignature(mlir::Type signature) {
+    assert(signature.isa<mlir::FunctionType>());
+    auto func = signature.dyn_cast<mlir::FunctionType>();
+    for (auto ty : func.getResults())
+      if ((ty.isa<BoxCharType>() && !noCharacterConversion)) {
+        LLVM_DEBUG(llvm::dbgs() << "rewrite " << signature << " for target\n");
+        return false;
+      }
+    for (auto ty : func.getInputs())
+      if ((ty.isa<BoxCharType>() && !noCharacterConversion)) {
+        LLVM_DEBUG(llvm::dbgs() << "rewrite " << signature << " for target\n");
+        return false;
+      }
+    return true;
+  }
+
+  /// Rewrite the signatures and body of the `FuncOp`s in the module for
+  /// the immediately subsequent target code gen.
+  void convertSignature(mlir::FuncOp func) {
+    auto funcTy = func.getType().cast<mlir::FunctionType>();
+    if (hasPortableSignature(funcTy))
+      return;
+    llvm::SmallVector<mlir::Type> newResTys;
+    llvm::SmallVector<mlir::Type> newInTys;
+    llvm::SmallVector<FixupTy> fixups;
+
+    // Convert return value(s)
+    for (auto ty : funcTy.getResults())
+      newResTys.push_back(ty);
+
+    // Convert arguments
+    llvm::SmallVector<mlir::Type> trailingTys;
+    for (auto e : llvm::enumerate(funcTy.getInputs())) {
+      auto ty = e.value();
+      unsigned index = e.index();
+      llvm::TypeSwitch<mlir::Type>(ty)
+          .Case<BoxCharType>([&](BoxCharType boxTy) {
+            if (noCharacterConversion) {
+              newInTys.push_back(boxTy);
+            } else {
+              // Convert a CHARACTER argument type. This can involve separating
+              // the pointer and the LEN into two arguments and moving the LEN
+              // argument to the end of the arg list.
+              bool sret = functionArgIsSRet(index, func);
+              for (auto e : llvm::enumerate(specifics->boxcharArgumentType(
+                       boxTy.getEleTy(), sret))) {
+                auto &tup = e.value();
+                auto index = e.index();
+                auto attr = std::get<CodeGenSpecifics::Attributes>(tup);
+                auto argTy = std::get<mlir::Type>(tup);
+                if (attr.isAppend()) {
+                  trailingTys.push_back(argTy);
+                } else {
+                  if (sret) {
+                    fixups.emplace_back(FixupTy::Codes::CharPair,
+                                        newInTys.size(), index);
+                  } else {
+                    fixups.emplace_back(FixupTy::Codes::Trailing,
+                                        newInTys.size(), trailingTys.size());
+                  }
+                  newInTys.push_back(argTy);
+                }
+              }
+            }
+          })
+          .Default([&](mlir::Type ty) { newInTys.push_back(ty); });
+    }
+
+    if (!func.empty()) {
+      // If the function has a body, then apply the fixups to the arguments and
+      // return ops as required. These fixups are done in place.
+      auto loc = func.getLoc();
+      const auto fixupSize = fixups.size();
+      const auto oldArgTys = func.getType().getInputs();
+      int offset = 0;
+      for (std::remove_const_t<decltype(fixupSize)> i = 0; i < fixupSize; ++i) {
+        const auto &fixup = fixups[i];
+        switch (fixup.code) {
+        case FixupTy::Codes::CharPair: {
+          // The FIR boxchar argument has been split into a pair of distinct
+          // arguments that are in juxtaposition to each other.
+          auto newArg =
+              func.front().insertArgument(fixup.index, newInTys[fixup.index]);
+          if (fixup.second == 1) {
+            rewriter->setInsertionPointToStart(&func.front());
+            auto boxTy = oldArgTys[fixup.index - offset - fixup.second];
+            auto box = rewriter->create<EmboxCharOp>(
+                loc, boxTy, func.front().getArgument(fixup.index - 1), newArg);
+            func.getArgument(fixup.index + 1).replaceAllUsesWith(box);
+            func.front().eraseArgument(fixup.index + 1);
+            offset++;
+          }
+        } break;
+        case FixupTy::Codes::Trailing: {
+          // The FIR argument has been split into a pair of distinct arguments.
+          // The first part of the pair appears in the original argument
+          // position. The second part of the pair is appended after all the
+          // original arguments. (Boxchar arguments.)
+          auto newBufArg =
+              func.front().insertArgument(fixup.index, newInTys[fixup.index]);
+          auto newLenArg = func.front().addArgument(trailingTys[fixup.second]);
+          auto boxTy = oldArgTys[fixup.index - offset];
+          rewriter->setInsertionPointToStart(&func.front());
+          auto box =
+              rewriter->create<EmboxCharOp>(loc, boxTy, newBufArg, newLenArg);
+          func.getArgument(fixup.index + 1).replaceAllUsesWith(box);
+          func.front().eraseArgument(fixup.index + 1);
+        } break;
+        }
+      }
+    }
+
+    // Set the new type and finalize the arguments, etc.
+    newInTys.insert(newInTys.end(), trailingTys.begin(), trailingTys.end());
+    auto newFuncTy =
+        mlir::FunctionType::get(func.getContext(), newInTys, newResTys);
+    LLVM_DEBUG(llvm::dbgs() << "new func: " << newFuncTy << '\n');
+    func.setType(newFuncTy);
+
+    for (auto &fixup : fixups)
+      if (fixup.finalizer)
+        (*fixup.finalizer)(func);
+  }
+
+  inline bool functionArgIsSRet(unsigned index, mlir::FuncOp func) {
+    if (auto attr = func.getArgAttrOfType<mlir::UnitAttr>(index, "llvm.sret"))
+      return true;
+    return false;
+  }
+
+private:
+  // Replace `op` and remove it.
+  void replaceOp(mlir::Operation *op, mlir::ValueRange newValues) {
+    op->replaceAllUsesWith(newValues);
+    op->dropAllReferences();
+    op->erase();
+  }
+
+  inline void setMembers(CodeGenSpecifics *s, mlir::OpBuilder *r) {
+    specifics = s;
+    rewriter = r;
+  }
+
+  inline void clearMembers() { setMembers(nullptr, nullptr); }
+
+  CodeGenSpecifics *specifics{};
+  mlir::OpBuilder *rewriter;
+}; // namespace
+} // namespace
+
+std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
+fir::createFirTargetRewritePass(const TargetRewriteOptions &options) {
+  return std::make_unique<TargetRewrite>(options);
+}

flang/test/Fir/target.fir

+// RUN: tco --target=i386-unknown-linux-gnu --target-rewrite %s | FileCheck %s --check-prefix=INT32
+// RUN: tco --target=x86_64-unknown-linux-gnu --target-rewrite %s | FileCheck %s --check-prefix=INT64
+// RUN: tco --target=aarch64-unknown-linux-gnu --target-rewrite %s | FileCheck %s --check-prefix=INT64
+// RUN: tco --target=powerpc64le-unknown-linux-gnu --target-rewrite %s | FileCheck %s --check-prefix=INT64
+
+// Test that we rewrite the signatures and bodies of functions that take boxchar
+// parameters.
+// INT32-LABEL: @boxcharparams
+// INT32-SAME: [[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG1:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG2:%[0-9A-Za-z]+]]: i32, [[ARG3:%[0-9A-Za-z]+]]: i32) -> i64
+// INT64-LABEL: @boxcharparams
+// INT64-SAME: [[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG1:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG2:%[0-9A-Za-z]+]]: i64, [[ARG3:%[0-9A-Za-z]+]]: i64) -> i64
+func @boxcharparams(%arg0 : !fir.boxchar<1>, %arg1 : !fir.boxchar<1>) -> i64 {
+  // INT32-DAG: [[B0:%[0-9]+]] = fir.emboxchar [[ARG1]], [[ARG3]] : (!fir.ref<!fir.char<1,?>>, i32) -> !fir.boxchar<1>
+  // INT32-DAG: [[B1:%[0-9]+]] = fir.emboxchar [[ARG0]], [[ARG2]] : (!fir.ref<!fir.char<1,?>>, i32) -> !fir.boxchar<1>
+  // INT32-DAG: fir.unboxchar [[B0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
+  // INT32-DAG: fir.unboxchar [[B1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
+  // INT64-DAG: [[B0:%[0-9]+]] = fir.emboxchar [[ARG1]], [[ARG3]] : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
+  // INT64-DAG: [[B1:%[0-9]+]] = fir.emboxchar [[ARG0]], [[ARG2]] : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
+  // INT64-DAG: fir.unboxchar [[B0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
+  // INT64-DAG: fir.unboxchar [[B1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
+  %1:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
+  %2:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i64)
+  %3 = arith.addi %1#1, %2#1 : i64
+  return %3 : i64
+}
+
+// Test that we rewrite the signatures and bodies of functions that return a
+// boxchar.
+// INT32-LABEL: @boxcharsret
+// INT32-SAME: [[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>> {llvm.sret}, [[ARG1:%[0-9A-Za-z]+]]: i32, [[ARG2:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG3:%[0-9A-Za-z]+]]: i32)
+// INT64-LABEL: @boxcharsret
+// INT64-SAME: [[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>> {llvm.sret}, [[ARG1:%[0-9A-Za-z]+]]: i64, [[ARG2:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG3:%[0-9A-Za-z]+]]: i64)
+func @boxcharsret(%arg0 : !fir.boxchar<1> {llvm.sret}, %arg1 : !fir.boxchar<1>) {
+  // INT32-DAG: [[B0:%[0-9]+]] = fir.emboxchar [[ARG0]], [[ARG1]] : (!fir.ref<!fir.char<1,?>>, i32) -> !fir.boxchar<1>
+  // INT32-DAG: [[B1:%[0-9]+]] = fir.emboxchar [[ARG2]], [[ARG3]] : (!fir.ref<!fir.char<1,?>>, i32) -> !fir.boxchar<1>
+  // INT32-DAG: fir.unboxchar [[B0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
+  // INT32-DAG: fir.unboxchar [[B1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
+  // INT64-DAG: [[B0:%[0-9]+]] = fir.emboxchar [[ARG0]], [[ARG1]] : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
+  // INT64-DAG: [[B1:%[0-9]+]] = fir.emboxchar [[ARG2]], [[ARG3]] : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
+  // INT64-DAG: fir.unboxchar [[B0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
+  // INT64-DAG: fir.unboxchar [[B1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
+  %1:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
+  %2:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.array<?x!fir.char<1>>>, i64)
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %3 = fir.convert %1#1 : (i64) -> index
+  %last = arith.subi %3, %c1 : index
+  fir.do_loop %i = %c0 to %last step %c1 {
+    %in_pos = fir.coordinate_of %2#0, %i : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+    %out_pos = fir.coordinate_of %1#0, %i : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+    %ch = fir.load %in_pos : !fir.ref<!fir.char<1>>
+    fir.store %ch to %out_pos : !fir.ref<!fir.char<1>>
+  }
+  return
+}
+
+// Test that we rewrite calls to functions that take boxchar arguments.
+
+// INT32-LABEL: @boxcharcallee
+// INT32-SAME: [[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG1:%[0-9A-Za-z]+]]: i32
+// INT64-LABEL: @boxcharcallee
+// INT64-SAME: [[ARG0:%[0-9A-Za-z]+]]: !fir.ref<!fir.char<1,?>>, [[ARG1:%[0-9A-Za-z]+]]: i64
+func private @boxcharcallee(%x : !fir.boxchar<1>)
+
+// INT32: @boxchararg
+// INT64: @boxchararg
+func @boxchararg() {
+  %1 = fir.address_of (@name) : !fir.ref<!fir.char<1,9>>
+  %2 = arith.constant 9 : i64
+  %3 = fir.convert %1 : (!fir.ref<!fir.char<1,9>>) -> !fir.ref<!fir.char<1,?>>
+  // INT32: [[B:%[0-9A-Za-z]+]] = fir.emboxchar {{.*}} : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
+  // INT32: [[U:%[0-9A-Za-z]+]]:2 = fir.unboxchar [[B]] : (!fir.boxchar<1>) ->
+  // (!fir.ref<!fir.char<1, ?>>, i32)
+  // INT64: [[B:%[0-9A-Za-z]+]] = fir.emboxchar {{.*}} : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
+  // INT64: [[U:%[0-9A-Za-z]+]]:2 = fir.unboxchar [[B]] : (!fir.boxchar<1>) ->
+  // (!fir.ref<!fir.char<1, ?>>, i64)
+  %4 = fir.emboxchar %3, %2 : (!fir.ref<!fir.char<1,?>>, i64) -> !fir.boxchar<1>
+  // INT32: fir.call @boxcharcallee([[U]]#0, [[U]]#1) : (!fir.ref<!fir.char<1,?>>, i32) -> ()
+  // INT64: fir.call @boxcharcallee([[U]]#0, [[U]]#1) : (!fir.ref<!fir.char<1,?>>, i64) -> ()
+  fir.call @boxcharcallee(%4) : (!fir.boxchar<1>) -> ()
+  return
+}
+
+fir.global @name constant : !fir.char<1,9> {
+  %str = fir.string_lit "Your name"(9) : !fir.char<1,9>
+  //constant 1
+  fir.has_value %str : !fir.char<1,9>
+}

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/Support/FIRContext.h"
 #include "flang/Optimizer/Support/InitFIR.h"
 #include "flang/Optimizer/Support/KindMapping.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"
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"));
+
 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 =
if (mlir::failed(owningRef->verify())) {
     return mlir::failure();
   }
 
   std::error_code ec;
   ToolOutputFile out(outputFilename, ec, sys::fs::OF_None);
 
   // run passes
   mlir::PassManager pm{&context};
+  fir::setTargetTriple(*owningRef, targetTriple);
   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()) {
+    // FIXME: handle result
+    (void)passPipeline.addToPipeline(pm, [&](const Twine &msg) {
+      mlir::emitError(mlir::UnknownLoc::get(&context)) << msg;
+      return mlir::failure();
+    });
   } else {
     // TODO: Actually add passes when added to FIR code base
     // add all the passes
     // the user can disable them individually
   }
 
   // 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::registerOptCodeGenPasses();
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
   cl::ParseCommandLineOptions(argc, argv, "Tilikum Crossing Optimizer\n");
   return mlir::failed(compileFIR(passPipe));
 }