[mlir] Start simple EmitC dialect.

[jpienaar]

Summary

Add EmitC dialect that has trivial mapping to C++. This dialect does not attempt
to model C++ semantics but just syntax to make it easy to translate out (e.g., it
attempts to make emitting simple textual code simpler). EmitC is used to add
simple C++ target that can currently only emit functions and function calls as
C++ code. This is useful for cases where you have a C++ compiler but no
access to the codegen (e.g., for using MLIR optimizations along with legacy or
proprietary systems) and for prototyping/debugging (e.g., found this useful to
play with shape functions). The emitter mostly defers to EmitC ops with the
exception of supporting FuncOp, some standard attributes and lowers
multi-result functions/ops are lowered using std::tuple.

Only test to verify emit happens, not that emitted code can be compiled, will
follow up with an integration test.

Previous discussions:
https://groups.google.com/a/tensorflow.org/d/msg/mlir/iOAB10Us6uo/wJ_pVQ_qBwAJ
https://llvm.discourse.group/t/simple-c-emitter-rev/773/4

[rriddle]

mlir/include/mlir/Target/Cpp.h

94

StringRef

104

nit: Why not just inline this type? It has one use.

116

I don't think this friend declaration is necessary.

125

nit: Can we get comments on these variables?

131

nit: Can you add documentation to this class?

156

The description mentions multiple emitters per dialect, but here you are keying on the dialect namespace.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

11

I think several of these can be trimmed, as they are already included transitively.

32

op.emitError() for all of these?

45

This seems like debug output.

59

nit: Remove trivial braces.

62

nit: Just return *mapper.begin()

70

nit: return emitters.lookup(dialect);

89

nit: Can you hoist the functor out of the call for readability?

97

nit: llvm::is_contained()

100

This seems incorrect to have inside of the loop.

130

Remove the extraneous semi-colon.

168

I don't understand why this is a failure case, can you add comments?

212

Do we really need to expose this? Seems like this provided by an overload of 'emit' that doesn't have an 'emitters' argument.

mlir/lib/Target/Cpp/TranslateToCppRegistration.cpp

11

Some of these includes are unnecessary.

25

Please wrap these in anonymous namespaces.

35

These methods should be marked static.

[jpienaar]

Addressed review comments

[jpienaar]

Updated, thanks

mlir/include/mlir/Target/Cpp.h

116

It is required for valueInScopeCount access (which honestly is more to enable making it simple to reuse variable numbers).

156

Updated comment above register function.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

168

Just changed to propagate to fallback behavior.

212

Mostly exposed as I don't want to privilege it, I want the registry to be more a convenience for mlir-translate usage. It is easier to use though, but sort of torn as I was thinking about moving the registry completely out of here and so the static registration being optional is more explicit.

[rriddle]

mlir/include/mlir/Target/Cpp.h

116

What I mean is, the elements of a class already visible to nested classes(i.e. implicitly friend):
https://stackoverflow.com/questions/14758881/access-of-nested-classes-which-behave-like-friends-but-arent/14759027#14759027

[jpienaar]

Removing unneeded friend declaration

[stephenneuendorffer]

mlir/include/mlir/Target/Cpp.h

39

What do you think about introducing an "EmitC" dialect, rather than doing string catenation here, isolate it somewhere else?

mlir/lib/Target/Cpp/TranslateToCpp.cpp

197–207

Maybe an Interface would work well here, instead of having a separate registry? I've used this to build a simulator for some dialects and it seems to scale reasonably well.

[mehdi_amini]

Can you discuss this on Discourse?

[jpienaar]

In D76571#1937625, @mehdi_amini wrote:

Can you discuss this on Discourse?

Sure

mlir/include/mlir/Target/Cpp.h

39

That would be very nice, but would be much larger effort, you'd need to be able to handle lambdas, templates and many different things that a dialect would want to emit.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

197–207

That is discussed in the rev description, making it an interface is a bit more invasive and requires one lowering for a given op, while one could have multiple completely different emissions for the same op, which is why I went for a separate registry.

[jpienaar]

Try example with simple dialect with 1:1 mapping to translation output. It doesn't model the language, only emitting to it.

[mehdi_amini]

mlir/test/Target/cpp-calls.mlir

18

I am a bit confused by the design of this dialect. I don't really get why we need a dialect for expressing this instead of... just emitting the C++ code directly for example.

What other ops would go into the "emitc" dialect?

[jpienaar]

mlir/test/Target/cpp-calls.mlir

18

This would correspond mostly to the syntax, to make the emission of the ops independent of the syntax. I think it is open to me how much value this dialect adds compared to jsut emitting + helper functions (previous version). So this is more an example, if folks don't see value then we can go back to the previous version.

[• pyprogrammer]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

356–367

Seems like a reasonable location to use mlir::TypeSwitch instead of having a long chain of if / typechecks.

[jpienaar]

Follow up work has superseded this :)

mlir/include/mlir/Target/Cpp.h

+//===- Cpp.h - Helpers to create C++ emitter --------------------*- 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 define a emitter class to translate between an MLIR function with
+// ops and C++.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TARGET_CPP_H
+#define MLIR_TARGET_CPP_H
+
+#include "mlir/IR/Value.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/ScopedHashTable.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/raw_ostream.h"
+#include <stack>
+
+namespace mlir {
+
+class DialectCppEmitter;
+
+/// Emitter that uses dialect specific emitters to emit C++ code.
+///
+/// This emitter only does some trivial checks for valid C++ code emitted and
+/// relies on the dialect emitters to produce valid C++ code. It does provide
+/// some common utility functions that the DialectCppEmitters could use.
+///
+/// All dialects are required to be registered for dialect specific C++
+/// emission. There is very little hardcoded and dialect emitters have freedom
+/// to do arbitrary lowerings (this is also a weakness).
+///
+/// Known limitations:
+/// - Doesn't understand C++ semantics and so may emit invalid code;
+/// - Doesn't attempt to ensure the function names are valid C++ names;
+/// - Doesn't insert includes etc.
+struct CppEmitter {
+  /// Map from dialect to DialectCppEmitter.
+  using DialectCppEmitters =
+      llvm::StringMap<std::unique_ptr<DialectCppEmitter>>;
+  /// A registry function that adds emitter to the given emitters map.
+  using EmitterRegistryFunction =
+      std::function<LogicalResult(DialectCppEmitters &)>;
+
+  CppEmitter() = delete;
+
+  /// Emits the given operation with provided dialect emitters on 'os'.
+  /// Optionally emit a trailing semicolon.
+  static LogicalResult emit(DialectCppEmitters &emitters, Operation &op,
+                            raw_ostream &os, bool trailingSemicolon = false);
+  static LogicalResult
+  emit(const llvm::StringMap<EmitterRegistryFunction> &emitters, Operation &op,
+       raw_ostream &os, bool trailingSemicolon = false);
+
+  /// Emits attribute or returns failure.
+  LogicalResult emitAttribute(Attribute attribute);
+
+  /// Emits operation 'op' with/without training semicolon or returns failure.
+  LogicalResult emitOperation(Operation &op, bool trailingSemicolon = true);
+
+  /// Emits type 'type' or returns failure.
+  LogicalResult emitType(Type type);
+
+  /// Emits array of types as a std::tuple of the emitted types.
+  LogicalResult emitTypes(ArrayRef<Type> types);
+
+  /// Emits a simple operation (one without regions) by
+  /// - emitting assign prefix (see below)
+  /// - splitting op name into dialect :: remainder (where it is an error if
+  /// remainder has a period);
+  /// - followed by all operands and attributes (see below).
+  LogicalResult emitOperationFallback(Operation &op,
+                                      bool trailingSemicolon = true);
+
+  /// Emits the variable declaration and assignment prefix for 'op'.
+  /// - emits separate variable followed by std::tie for multi-valued operation;
+  /// - emits single type followed by variable for single result;
+  /// - emits nothing if no value produced by op;
+  /// Emits final '=' operator where a type is produced. Returns failure if
+  /// any result type could not be converted.
+  LogicalResult emitAssignPrefix(Operation &op);
+
+  /// Emits the operands and atttributes of the operation. All operands are
+  /// emitted first and then all attributes in alphabetical order.
+  LogicalResult emitOperandsAndAttributes(Operation &op,
+                                          ArrayRef<StringRef> exclude = {});
+
+  /// Return the existing or a new name for a Value.
+  StringRef getOrCreateName(Value val);
+
+  /// RAII helper function to manage entering/exiting C++ scopes.
+  struct Scope {
+    Scope(CppEmitter &emitter) : mapperScope(emitter.mapper), emitter(emitter) {
+      emitter.valueInScopeCount.push(emitter.valueInScopeCount.top());
+    }
+    ~Scope() { emitter.valueInScopeCount.pop(); }
+
+  private:
+    llvm::ScopedHashTableScope<Value, std::string> mapperScope;
+    CppEmitter &emitter;
+  };
+
+  /// Returns wether the Value is assigned to a C++ variable in the scope.
+  bool hasValueInScope(Value val);
+
+  /// Returns the output stream.
+  raw_ostream &ostream() { return os; };
+
+private:
+  using ValMapper = llvm::ScopedHashTable<Value, std::string>;
+
+  /// Private constructor, the static emit function is entry point for use.
+  explicit CppEmitter(raw_ostream &os);
+
+  /// Returns dialect emitter for the given dialect.
+  DialectCppEmitter *getDialectEmitter(Dialect *dialect);
+
+  /// Map from dialect to DialectCppEmitter.
+  llvm::DenseMap<Dialect *, DialectCppEmitter *> emitters;
+
+  /// Output stream to emit to.
+  raw_ostream &os;
+
+  /// Map from value to name of C++ variable that contain the name.
+  ValMapper mapper;
+
+  /// The number of values in the current scope. This is used to declare the
+  /// names of values in a scope.
+  std::stack<int64_t> valueInScopeCount;
+};
+
+/// Interface for C++ emitter for a dialect. This interface can be implemented
+/// by a dialect to define behavior specific to a dialect (e.g., how a dialect
+/// attribute should be emitted to C++/if it can).
+class DialectCppEmitter {
+public:
+  DialectCppEmitter() = default;
+  virtual ~DialectCppEmitter() = default;
+
+  virtual LogicalResult printAttribute(CppEmitter &emitter, Attribute val) = 0;
+  virtual LogicalResult printOperation(CppEmitter &emitter, Operation &op) = 0;
+  virtual LogicalResult printType(CppEmitter &emitter, Type type) = 0;
+};
+
+/// Register a EmitterRegistryFunction function for a dialect. Typically used
+/// via DialectCppRegistration.
+/// Note: the registry is used for testing along with mlir-translate and while
+/// this registry's dialect emitters are registered at link time, the
+/// CppEmitter need not use the registry.
+void registerCppEmitter(StringRef dialect,
+                        const CppEmitter::EmitterRegistryFunction &function);
+
+/// DialectCppRegistration provides a global initializer that registers a
+/// DialectCppEmitter allocation routine for a concrete emitter instance.
+///
+/// Usage:
+///
+///   // At namespace scope.
+///   static DialectCppEmitterRegistration<MyEmitter> reg("mydialect");
+template <typename Emitter> struct DialectCppEmitterRegistration {
+  DialectCppEmitterRegistration(StringRef dialect) {
+    registerCppEmitter(dialect, [=](CppEmitter::DialectCppEmitters &registry) {
+      if (registry.find(dialect) != registry.end())
+        return failure();
+      registry[dialect] = std::make_unique<Emitter>();
+      return success();
+    });
+  }
+};
+
+/// Returns all the EmitterRegistryFunctions registered via
+/// DialectCppEmitterRegistration.
+const llvm::StringMap<CppEmitter::EmitterRegistryFunction> &
+getCppEmitterRegistry();
+
+/// Convenience functions to produce interleaved output with functions returning
+/// a LogicalResult. This is different than those in STL as functions used on
+/// each element doesn't return a string.
+template <typename ForwardIterator, typename UnaryFunctor,
+          typename NullaryFunctor>
+inline LogicalResult
+interleaveWithError(ForwardIterator begin, ForwardIterator end,
+                    UnaryFunctor each_fn, NullaryFunctor between_fn) {
+  if (begin == end)
+    return success();
+  if (failed(each_fn(*begin)))
+    return failure();
+  ++begin;
+  for (; begin != end; ++begin) {
+    between_fn();
+    if (failed(each_fn(*begin)))
+      return failure();
+  }
+  return success();
+}
+
+template <typename Container, typename UnaryFunctor, typename NullaryFunctor>
+inline LogicalResult interleaveWithError(const Container &c,
+                                         UnaryFunctor each_fn,
+                                         NullaryFunctor between_fn) {
+  return interleaveWithError(c.begin(), c.end(), each_fn, between_fn);
+}
+
+template <typename Container, typename UnaryFunctor>
+inline LogicalResult interleaveCommaWithError(const Container &c,
+                                              raw_ostream &os,
+                                              UnaryFunctor each_fn) {
+  return interleaveWithError(c.begin(), c.end(), each_fn,
+                             [&]() { os << ", "; });
+}
+
+} // end namespace mlir
+
+#endif // MLIR_TARGET_CPP_H

mlir/lib/Target/CMakeLists.txt

+add_mlir_library(MLIRTargetCpp
+  Cpp/TranslateToCpp.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/Cpp
+  )
+target_link_libraries(MLIRTargetCpp
+  PUBLIC
+  MLIRIR
+  LLVMSupport
+  )
+add_mlir_library(MLIRTargetCppRegistration
+  Cpp/TranslateToCppRegistration.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/Cpp
+  )
+target_link_libraries(MLIRTargetCppRegistration
+  PUBLIC
+  MLIRStandardOps
+  MLIRTargetCpp
+  )
 add_mlir_library(MLIRTargetLLVMIRModuleTranslation
   LLVMIR/DebugTranslation.cpp
   LLVMIR/ModuleTranslation.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
   DEPENDS
   intrinsics_gen

mlir/lib/Target/Cpp/TranslateToCpp.cpp

+//===- TranslateToCpp.cpp - Translating to C++ calls ----------------------===//
+//
+// 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 "mlir/IR/Dialect.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/Target/Cpp.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FormatVariadic.h"
+
+#define DEBUG_TYPE "translate-to-cpp"
+
+using namespace mlir;
+using llvm::formatv;
+
+LogicalResult CppEmitter::emit(DialectCppEmitters &emitters, Operation &op,
+                               raw_ostream &os, bool trailingSemicolon) {
+  CppEmitter emitter(os);
+  auto *context = op.getContext();
+  for (auto &it : emitters) {
+    auto *regDialect = context->getRegisteredDialect(it.first());
+    if (regDialect == nullptr)
+      return op.emitError()
+             << "dialect '" << it.first() << "' is not registered";
+    emitter.emitters[regDialect] = it.second.get();
+  }
+  return emitter.emitOperation(op, trailingSemicolon);
+}
+
+LogicalResult
+CppEmitter::emit(const llvm::StringMap<EmitterRegistryFunction> &emitters,
+                 Operation &op, raw_ostream &os, bool trailingSemicolon) {
+  DialectCppEmitters allocatedEmitters;
+  for (auto &it : emitters) {
+    if (failed(it.second(allocatedEmitters)))
+      return op.emitError() << "dialect '" << it.first()
+                            << "'s dialect emitter failed to construct\n";
+  }
+  return emit(allocatedEmitters, op, os, trailingSemicolon);
+}
+
+CppEmitter::CppEmitter(raw_ostream &os) : os(os) { valueInScopeCount.push(0); }
+
+/// Return the existing or a new name for a Value*.
+StringRef CppEmitter::getOrCreateName(Value val) {
+  if (!mapper.count(val))
+    mapper.insert(val, formatv("v{0}", ++valueInScopeCount.top()));
+  return *mapper.begin(val);
+}
+
+bool CppEmitter::hasValueInScope(Value val) { return mapper.count(val); }
+
+DialectCppEmitter *CppEmitter::getDialectEmitter(Dialect *dialect) {
+  return emitters.lookup(dialect);
+}
+
+LogicalResult CppEmitter::emitAttribute(Attribute attribute) {
+  if (auto *dialectEmitter = getDialectEmitter(&attribute.getDialect()))
+    return dialectEmitter->printAttribute(*this, attribute);
+  LLVM_DEBUG(llvm::dbgs() << "no dialect emitter found for " << attribute
+                          << " of dialect '"
+                          << attribute.getDialect().getNamespace()
+                          << "' trying fallback\n");
+  return failure();
+}
+
+LogicalResult
+CppEmitter::emitOperandsAndAttributes(Operation &op,
+                                      ArrayRef<StringRef> exclude) {
+  // Emit operands.
+  auto emitOperandName = [&](Value result) -> LogicalResult {
+    if (!hasValueInScope(result))
+      return op.emitError() << "operand value not in scope";
+    os << getOrCreateName(result);
+    return success();
+  };
+  if (failed(interleaveCommaWithError(op.getOperands(), os, emitOperandName)))
+    return failure();
+  // Insert comma in between operands and non-filtered attributes if needed.
+  if (op.getNumOperands() > 0) {
+    for (auto attr : op.getAttrs()) {
+      if (!llvm::is_contained(exclude, attr.first.strref())) {
+        os << ", ";
+        break;
+      }
+    }
+  }
+  // Emit attributes.
+  auto emitNamedAttribute = [&](NamedAttribute attr) -> LogicalResult {
+    if (llvm::is_contained(exclude, attr.first.strref()))
+      return success();
+    os << "/* " << attr.first << " */";
+    if (failed(emitAttribute(attr.second)))
+      return op.emitError() << "unable to emit attribute " << attr.second;
+    return success();
+  };
+  return interleaveCommaWithError(op.getAttrs(), os, emitNamedAttribute);
+}
+
+LogicalResult CppEmitter::emitAssignPrefix(Operation &op) {
+  switch (op.getNumResults()) {
+  case 0:
+    break;
+  case 1: {
+    auto result = op.getResult(0);
+    if (failed(emitType(result.getType())))
+      return failure();
+    os << " " << getOrCreateName(result) << " = ";
+    break;
+  }
+  default:
+    for (auto result : op.getResults()) {
+      if (failed(emitType(result.getType())))
+        return failure();
+      os << " " << getOrCreateName(result) << ";\n";
+    }
+    os << "std::tie(";
+    interleaveComma(op.getResults(), os,
+                    [&](Value result) { os << getOrCreateName(result); });
+    os << ") = ";
+  }
+  return success();
+}
+
+LogicalResult CppEmitter::emitOperationFallback(Operation &op,
+                                                bool trailingSemicolon) {
+  if (op.getNumRegions() != 0)
+    return op.emitOpError()
+           << "only simple ops supported by fallback op emitter";
+  if (failed(emitAssignPrefix(op)))
+    return failure();
+
+  auto dialectAndName = op.getName().getStringRef().split('.');
+  if (dialectAndName.second.count('.') != 0)
+    return op.emitOpError() << "unable to convert to C++ call";
+  os << dialectAndName.first << "::" << dialectAndName.second << "(";
+
+  if (failed(emitOperandsAndAttributes(op)))
+    return failure();
+  if (trailingSemicolon)
+    os << ");\n";
+  else
+    os << ")\n";
+  return success();
+}
+
+LogicalResult CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
+  if (auto *dialectEmitter = getDialectEmitter(op.getDialect())) {
+    if (succeeded(dialectEmitter->printOperation(*this, op))) {
+      os << (trailingSemicolon ? ";\n" : "\n");
+      return success();
+    }
+    return failure();
+  }
+  LLVM_DEBUG({
+    llvm::dbgs() << "no dialect emitter found for " << op << " of dialect ";
+    if (auto *dialect = op.getDialect())
+      llvm::dbgs() << "'" << dialect->getNamespace() << "'";
+    else
+      llvm::dbgs() << "<unknown>";
+    llvm::dbgs() << " trying fallback\n";
+  });
+  return emitOperationFallback(op, trailingSemicolon);
+}
+
+LogicalResult CppEmitter::emitType(Type type) {
+  if (auto *dialectEmitter = getDialectEmitter(&type.getDialect()))
+    return dialectEmitter->printType(*this, type);
+  LLVM_DEBUG(llvm::dbgs() << "no dialect emitter found for " << type
+                          << " of dialect '" << type.getDialect().getNamespace()
+                          << "' trying fallback\n");
+  return failure();
+}
+
+LogicalResult CppEmitter::emitTypes(ArrayRef<Type> types) {
+  switch (types.size()) {
+  case 0:
+    os << "void";
+    return success();
+  case 1:
+    return emitType(types.front());
+  default:
+    os << "std::tuple<";
+    if (failed(interleaveCommaWithError(
+            types, os, [&](Type type) { return emitType(type); })))
+      return failure();
+    os << ">";
+    return success();
+  }
+}
+
+llvm::StringMap<CppEmitter::EmitterRegistryFunction> &
+getMutableCppEmitterRegistry() {
+  static llvm::StringMap<CppEmitter::EmitterRegistryFunction> registry;
+  return registry;
+}
+
+void mlir::registerCppEmitter(
+    StringRef dialect, const CppEmitter::EmitterRegistryFunction &function) {
+  assert(function && "Attempting to register empty emitter function");
+  getMutableCppEmitterRegistry()[dialect] = function;
+}
+
+const llvm::StringMap<CppEmitter::EmitterRegistryFunction> &
+mlir::getCppEmitterRegistry() {
+  return getMutableCppEmitterRegistry();
+}

mlir/lib/Target/Cpp/TranslateToCppRegistration.cpp

+//===- TranslateToCppRegistration.cpp - Register for mlir-translate  ------===//
+//
+// 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 "mlir/IR/Module.h"
+#include "mlir/Target/Cpp.h"
+#include "mlir/Translation.h"
+// Headers only here due to example emitter registration.
+// TODO: Remove once the registrations are moved closer to their dialects.
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/Function.h"
+#include "mlir/IR/StandardTypes.h"
+
+using namespace mlir;
+
+// TODO: Move out of registration here and closer to dialect. This is just here
+// locally as an example for the initial development.
+namespace {
+class StdEmitter : public DialectCppEmitter {
+public:
+  LogicalResult printAttribute(CppEmitter &emitter, Attribute attr) override;
+  LogicalResult printOperation(CppEmitter &emitter, Operation &op) override;
+  LogicalResult printType(CppEmitter &emitter, Type type) override;
+};
+} // namespace
+
+LogicalResult StdEmitter::printAttribute(CppEmitter &emitter, Attribute attr) {
+  return failure();
+}
+
+static LogicalResult printConstantOp(CppEmitter &emitter,
+                                     ConstantOp constantOp) {
+  auto &os = emitter.ostream();
+  emitter.emitType(constantOp.getType());
+  os << " " << emitter.getOrCreateName(constantOp.getResult()) << '{';
+  if (failed(emitter.emitAttribute(constantOp.getValue())))
+    return constantOp.emitError("unable to emit constant value");
+  os << '}';
+  return success();
+}
+
+static LogicalResult printCallOp(CppEmitter &emitter, CallOp callOp) {
+  if (failed(emitter.emitAssignPrefix(*callOp.getOperation())))
+    return failure();
+
+  auto &os = emitter.ostream();
+  os << callOp.getCallee() << "(";
+  if (failed(emitter.emitOperandsAndAttributes(*callOp.getOperation(),
+                                               /*exclude=*/{"callee"})))
+    return failure();
+  os << ")";
+  return success();
+}
+
+static LogicalResult printReturnOp(CppEmitter &emitter, ReturnOp returnOp) {
+  auto &os = emitter.ostream();
+  os << "return ";
+  switch (returnOp.getNumOperands()) {
+  case 0:
+    return success();
+  case 1:
+    os << emitter.getOrCreateName(returnOp.getOperand(0));
+    return success(emitter.hasValueInScope(returnOp.getOperand(0)));
+  default:
+    os << "std::make_tuple(";
+    if (failed(emitter.emitOperandsAndAttributes(*returnOp.getOperation())))
+      return failure();
+    os << ")";
+    return success();
+  }
+}
+
+LogicalResult StdEmitter::printOperation(CppEmitter &emitter, Operation &op) {
+  if (auto callOp = dyn_cast<CallOp>(op))
+    return printCallOp(emitter, callOp);
+  if (auto constantOp = dyn_cast<ConstantOp>(op))
+    return printConstantOp(emitter, constantOp);
+  if (auto returnOp = dyn_cast<ReturnOp>(op))
+    return printReturnOp(emitter, returnOp);
+
+  return op.emitOpError() << "unable to find printer for op";
+}
+
+LogicalResult StdEmitter::printType(CppEmitter &emitter, Type type) {
+  emitter.ostream() << type;
+  return success();
+}
+static DialectCppEmitterRegistration<StdEmitter> stdReg("std");
+
+namespace {
+class BuiltinEmitter : public DialectCppEmitter {
+public:
+  LogicalResult printAttribute(CppEmitter &emitter, Attribute attr) override;
+  LogicalResult printOperation(CppEmitter &emitter, Operation &op) override;
+  LogicalResult printType(CppEmitter &emitter, Type type) override;
+};
+} // namespace
+
+LogicalResult BuiltinEmitter::printAttribute(CppEmitter &emitter,
+                                             Attribute attr) {
+  auto &os = emitter.ostream();
+  if (auto iAttr = attr.dyn_cast<IntegerAttr>()) {
+    os << iAttr.getValue();
+    return success();
+  }
+  if (auto dense = attr.dyn_cast<DenseIntElementsAttr>()) {
+    os << '{';
+    interleaveComma(dense.getIntValues(), os);
+    os << '}';
+    return success();
+  }
+  return failure();
+}
+
+static void printFunctionVisibility(FuncOp funcOp, raw_ostream &os) {
+  if (funcOp.getVisibility() == SymbolTable::Visibility::Private)
+    os << "static ";
+}
+
+static LogicalResult printModule(CppEmitter &emitter, ModuleOp moduleOp) {
+  CppEmitter::Scope scope(emitter);
+  auto &os = emitter.ostream();
+  os << "// Forward declare functions.\n";
+  for (FuncOp funcOp : moduleOp.getOps<FuncOp>()) {
+    printFunctionVisibility(funcOp, os);
+    if (failed(emitter.emitTypes(funcOp.getType().getResults())))
+      return failure();
+    os << " " << funcOp.getName() << "(";
+    if (failed(interleaveCommaWithError(
+            funcOp.getArguments(), os, [&](BlockArgument arg) {
+              return emitter.emitType(arg.getType());
+            })))
+      return failure();
+    os << ");\n";
+  }
+  os << "\n";
+
+  for (Operation &op : moduleOp) {
+    if (failed(emitter.emitOperation(op, /*trailingSemiColon=*/false)))
+      return failure();
+  }
+  return success();
+}
+
+static LogicalResult printFunction(CppEmitter &emitter, FuncOp functionOp) {
+  auto &blocks = functionOp.getBlocks();
+  if (blocks.size() != 1)
+    return functionOp.emitOpError() << "only single block functions supported";
+
+  CppEmitter::Scope scope(emitter);
+  auto &os = emitter.ostream();
+  printFunctionVisibility(functionOp, os);
+  if (failed(emitter.emitTypes(functionOp.getType().getResults())))
+    return functionOp.emitError() << "unable to emit all types";
+  os << " " << functionOp.getName();
+
+  os << "(";
+  if (failed(interleaveCommaWithError(
+          functionOp.getArguments(), os,
+          [&](BlockArgument arg) -> LogicalResult {
+            if (failed(emitter.emitType(arg.getType())))
+              return functionOp.emitError() << "unable to emit arg "
+                                            << arg.getArgNumber() << "'s type";
+            os << " " << emitter.getOrCreateName(arg);
+            return success();
+          })))
+    return failure();
+  os << ") {\n";
+
+  for (Operation &op : functionOp.front()) {
+    if (failed(emitter.emitOperation(op)))
+      return failure();
+  }
+  os << "}\n";
+  return success();
+}
+
+LogicalResult BuiltinEmitter::printOperation(CppEmitter &emitter,
+                                             Operation &op) {
+  if (auto moduleOp = dyn_cast<ModuleOp>(op))
+    return printModule(emitter, moduleOp);
+  if (auto funcOp = dyn_cast<FuncOp>(op))
+    return printFunction(emitter, funcOp);
+  if (isa<ModuleTerminatorOp>(op))
+    return success();
+
+  return op.emitOpError() << "unable to find printer for op";
+}
+
+LogicalResult BuiltinEmitter::printType(CppEmitter &emitter, Type type) {
+  auto &os = emitter.ostream();
+  if (auto itype = type.dyn_cast<IntegerType>()) {
+    switch (itype.getWidth()) {
+    case 32:
+      return (os << "int32_t"), success();
+    case 64:
+      return (os << "int64_t"), success();
+    default:
+      return failure();
+    }
+  }
+  return failure();
+}
+static DialectCppEmitterRegistration<BuiltinEmitter> builtinReg("");
+
+static LogicalResult MlirToCppTranslateFunction(ModuleOp module,
+                                                llvm::raw_ostream &output) {
+  return CppEmitter::emit(getCppEmitterRegistry(), *module.getOperation(),
+                          output,
+                          /*trailingSemiColon=*/false);
+}
+
+static TranslateFromMLIRRegistration reg("mlir-to-cpp",
+                                         MlirToCppTranslateFunction);

mlir/test/Target/cpp-calls.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s --dump-input-on-failure
+
+// CHECK: // Forward declare functions.
+// CHECK: void test_foo_print();
+// CHECK: int32_t test_single_return(int32_t);
+// CHECK: std::tuple<int32_t, int32_t> test_multiple_return();
+
+// CHECK: void test_foo_print()
+func @test_foo_print() {
+  // CHECK: [[V1:[^ ]*]] = foo::constant(/* value */{0, 1});
+  %0 = "foo.constant"() {value = dense<[0, 1]> : tensor<2xi32>} : () -> (i32)
+  // CHECK: foo::print([[V1]]);
+  "foo.print"(%0) : (i32) -> ()
+  return
+}
+
+// CHECK: int32_t test_single_return(int32_t [[V2:.*]])
+func @test_single_return(%arg0 : i32) -> i32 {
+  // CHECK: return [[V2]]
+  return %arg0 : i32
+}
+
+// CHECK: std::tuple<int32_t, int32_t> test_multiple_return()
+func @test_multiple_return() -> (i32, i32) {
+  // CHECK: std::tie([[V3:.*]], [[V4:.*]]) = foo::blah();
+  %0:2 = "foo.blah"() : () -> (i32, i32)
+  // CHECK: [[V5:[^ ]*]] = test_single_return([[V3]]);
+  %1 = call @test_single_return(%0#0) : (i32) -> i32
+  // CHECK: return std::make_tuple([[V5]], [[V4]]);
+  return %1, %0#1 : i32, i32
+}

mlir/tools/mlir-translate/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 set(LIBS
   ${dialect_libs}
   MLIRParser
   MLIRPass
   MLIRSPIRV
   MLIRSPIRVSerialization
   MLIRTargetLLVMIR
   MLIRTargetNVVMIR
   MLIRTargetROCDLIR
   MLIRTranslation
   MLIRSupport
 )
 set(FULL_LIBS
   MLIRSPIRVSerialization
+  MLIRTargetCppRegistration
+  MLIRTargetCpp
   MLIRTargetLLVMIR
   MLIRTargetNVVMIR
   MLIRTargetROCDLIR
 )
 add_llvm_tool(mlir-translate
   mlir-translate.cpp
 )
 llvm_update_compile_flags(mlir-translate)
 whole_archive_link(mlir-translate ${FULL_LIBS})
 target_link_libraries(mlir-translate PRIVATE MLIRIR MLIRTranslateClParser ${LIBS} LLVMSupport)