[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

40

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

198–208

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

40

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

198–208

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

17

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

17

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

355–366

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/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(AVX512)
+add_subdirectory(EmitC)
 add_subdirectory(FxpMathOps)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(LoopOps)
 add_subdirectory(OpenMP)
 add_subdirectory(Quant)
 add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(StandardOps)
 add_subdirectory(Vector)

mlir/include/mlir/Dialect/EmitC/CMakeLists.txt

+add_mlir_dialect(EmitC emitc EmitC)

mlir/include/mlir/Dialect/EmitC/EmitC.td

+//===- EmitC.td - EmitC operation definitions --------------*- tablegen -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines some operations with trivial mapping to C/C++ constructs.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef EMITC_OPS
+#define EMITC_OPS
+
+include "mlir/Interfaces/SideEffects.td"
+
+def EmitC_Dialect : Dialect {
+  let name = "emitc";
+  let cppNamespace = "emitc";
+}
+
+// Base class for EmitC dialect ops.
+class EmitC_Op<string mnemonic, list<OpTrait> traits = []> :
+    Op<EmitC_Dialect, mnemonic, traits>;
+
+def EmitC_CallOp : EmitC_Op<"call", []> {
+  let summary = "call operation";
+  let description = [{
+    The "call" operation represents a C++ function call. The call allows
+    specifying order of operands and attributes in the call as follows:
+
+    - integer value of index type refers to an operand;
+    - attribute which will get lowered to constant value in call;
+  }];
+  let arguments = (ins
+    Arg<StrAttr, "the C++ function to call">:$callee,
+    Arg<OptionalAttr<ArrayAttr>, "the order of operands and attributes">:$args,
+    Variadic<AnyType>:$operands);
+  let results = (outs Variadic<AnyType>);
+  let assemblyFormat = [{
+    $callee `(` $operands `)` attr-dict `:` functional-type($operands, results)
+  }];
+}
+
+#endif // EMITC_OPS

mlir/include/mlir/Dialect/EmitC/EmitCDialect.h

+//===- AVX512Dialect.h - MLIR Dialect for AVX512 ----------------*- 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 declares the Target dialect for AVX512 in MLIR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_EMITC_EMITCDIALECT_H_
+#define MLIR_DIALECT_EMITC_EMITCDIALECT_H_
+
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/SideEffects.h"
+
+namespace mlir {
+namespace emitc {
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/EmitC/EmitC.h.inc"
+
+#include "mlir/Dialect/EmitC/EmitCDialect.h.inc"
+
+} // namespace emitc
+} // namespace mlir
+
+#endif // MLIR_DIALECT_EMITC_EMITCDIALECT_H_

mlir/include/mlir/InitAllDialects.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INITALLDIALECTS_H_
 #define MLIR_INITALLDIALECTS_H_
 
 #include "mlir/Dialect/AVX512/AVX512Dialect.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/EmitC/EmitCDialect.h"
 #include "mlir/Dialect/FxpMathOps/FxpMathOps.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"

 namespace mlir {
 
 // This function should be called before creating any MLIRContext if one expect
 // all the possible dialects to be made available to the context automatically.
 inline void registerAllDialects() {
   static bool init_once = []() {
     registerDialect<AffineDialect>();
     registerDialect<avx512::AVX512Dialect>();
+    registerDialect<emitc::EmitCDialect>();
     registerDialect<fxpmath::FxpMathOpsDialect>();
     registerDialect<gpu::GPUDialect>();
     registerDialect<LLVM::LLVMAVX512Dialect>();
     registerDialect<LLVM::LLVMDialect>();
     registerDialect<linalg::LinalgDialect>();
     registerDialect<loop::LoopOpsDialect>();
     registerDialect<omp::OpenMPDialect>();
     registerDialect<quant::QuantizationDialect>();

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 helpers to emit C++ code using the EmitC dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TARGET_CPP_H
+#define MLIR_TARGET_CPP_H
+
+#include "mlir/IR/Value.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace mlir {
+namespace emitc {
+
+/// Translates the given operation to C++ code. The operation or operations in
+/// the region of 'op' need almost all be in EmitC dialect.
+LogicalResult TranslateToCpp(Operation &op, raw_ostream &os,
+                             bool trailingSemicolon = false);
+
+} // namespace emitc
+} // namespace mlir
+
+#endif // MLIR_TARGET_CPP_H

mlir/lib/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(AVX512)
+add_subdirectory(EmitC)
 add_subdirectory(FxpMathOps)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(LoopOps)
 add_subdirectory(OpenMP)
 add_subdirectory(Quant)
 add_subdirectory(SDBM)

mlir/lib/Dialect/EmitC/CMakeLists.txt

+add_mlir_dialect_library(MLIREmitC
+  IR/EmitCDialect.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/EmitC
+
+  DEPENDS
+  MLIREmitCIncGen
+  )
+target_link_libraries(MLIREmitC
+  PUBLIC
+  MLIRIR
+  MLIRSideEffects
+  LLVMSupport
+  )

mlir/lib/Dialect/EmitC/IR/EmitCDialect.cpp

+//===- EmitCOps.cpp - MLIR EmitC ops implementation -----------------------===//
+//
+// 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 implements the EmitC dialect and its operations.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/EmitC/EmitCDialect.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/TypeUtilities.h"
+
+using namespace mlir;
+
+emitc::EmitCDialect::EmitCDialect(MLIRContext *context)
+    : Dialect(getDialectNamespace(), context) {
+  addOperations<
+#define GET_OP_LIST
+#include "mlir/Dialect/EmitC/EmitC.cpp.inc"
+      >();
+  allowUnknownTypes();
+  allowUnknownOperations();
+}
+
+namespace mlir {
+namespace emitc {
+#define GET_OP_CLASSES
+#include "mlir/Dialect/EmitC/EmitC.cpp.inc"
+} // namespace emitc
+} // namespace mlir

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
+  MLIREmitC
+  MLIRIR
+  MLIRStandardOps
+  LLVMSupport
+  )
+add_mlir_library(MLIRTargetCppRegistration
+  Cpp/TranslateToCppRegistration.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/Cpp
+  )
+target_link_libraries(MLIRTargetCppRegistration
+  PUBLIC
+  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/Dialect/EmitC/EmitCDialect.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/Function.h"
+#include "mlir/IR/Module.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/Target/Cpp.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/ScopedHashTable.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FormatVariadic.h"
+#include <stack>
+
+#define DEBUG_TYPE "translate-to-cpp"
+
+using namespace mlir;
+using llvm::formatv;
+
+/// 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 << ", "; });
+}
+
+namespace {
+/// Emitter that uses dialect specific emitters to emit C++ code.
+struct CppEmitter {
+  explicit CppEmitter(raw_ostream &os);
+
+  /// Emits attribute or returns failure.
+  LogicalResult emitAttribute(Attribute attr);
+
+  /// 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 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 = {});
+
+  /// Emits the operands of the operation. All operands are emitted in order.
+  LogicalResult emitOperands(Operation &op);
+
+  /// 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>;
+
+  /// 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;
+};
+} // namespace
+
+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.emitOperands(*callOp.getOperation())))
+    return failure();
+  os << ")";
+  return success();
+}
+
+static LogicalResult printCallOp(CppEmitter &emitter, emitc::CallOp callOp) {
+  auto &os = emitter.ostream();
+  auto &op = *callOp.getOperation();
+  if (failed(emitter.emitAssignPrefix(op)))
+    return failure();
+  os << callOp.callee() << "(";
+
+  auto emitArgs = [&](Attribute attr) -> LogicalResult {
+    if (auto t = attr.dyn_cast<IntegerAttr>()) {
+      // Index attributes are treated specially as operand index.
+      if (t.getType().isIndex()) {
+        auto idx = t.getInt();
+        if ((idx < 0) || (idx >= op.getNumOperands()))
+          return op.emitOpError() << "invalid operand index";
+        if (!emitter.hasValueInScope(op.getOperand(idx)))
+          return op.emitOpError()
+                 << "operand " << idx << "'s value not defined in scope";
+        os << emitter.getOrCreateName(op.getOperand(idx));
+        return success();
+      }
+    }
+    return emitter.emitAttribute(attr);
+  };
+
+  if (callOp.argsAttr()) {
+    callOp.dump();
+  }
+  auto emittedArgs =
+      callOp.args() ? interleaveCommaWithError(*callOp.args(), os, emitArgs)
+                    : emitter.emitOperands(op);
+  if (failed(emittedArgs))
+    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();
+  }
+}
+
+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>()) {
+    if (failed(emitter.emitTypes(funcOp.getType().getResults())))
+      return funcOp.emitError() << "failed to convert operand type";
+    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();
+  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();
+}
+
+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); }
+
+LogicalResult CppEmitter::emitAttribute(Attribute attr) {
+  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();
+}
+
+LogicalResult CppEmitter::emitOperands(Operation &op) {
+  auto emitOperandName = [&](Value result) -> LogicalResult {
+    if (!hasValueInScope(result))
+      return op.emitError() << "operand value not in scope";
+    os << getOrCreateName(result);
+    return success();
+  };
+  return interleaveCommaWithError(op.getOperands(), os, emitOperandName);
+}
+
+LogicalResult
+CppEmitter::emitOperandsAndAttributes(Operation &op,
+                                      ArrayRef<StringRef> exclude) {
+  if (failed(emitOperands(op)))
+    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();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, Operation &op) {
+  if (auto callOp = dyn_cast<CallOp>(op))
+    return printCallOp(emitter, callOp);
+  if (auto callOp = dyn_cast<emitc::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);
+  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 CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
+  if (failed(printOperation(*this, op)))
+    return failure();
+  os << (trailingSemicolon ? ";\n" : "\n");
+  return success();
+}
+
+LogicalResult CppEmitter::emitType(Type type) {
+  if (auto itype = type.dyn_cast<IntegerType>()) {
+    switch (itype.getWidth()) {
+    case 1:
+      return (os << "bool"), success();
+    case 32:
+      return (os << "int32_t"), success();
+    case 64:
+      return (os << "int64_t"), success();
+    default:
+      return failure();
+    }
+  }
+  // TODO: Change to be EmitC specific.
+  if (auto ot = type.dyn_cast<OpaqueType>()) {
+    os << ot.getTypeData();
+    return success();
+  }
+  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();
+  }
+}
+
+LogicalResult emitc::TranslateToCpp(Operation &op, raw_ostream &os,
+                                    bool trailingSemicolon) {
+  CppEmitter emitter(os);
+  return emitter.emitOperation(op, trailingSemicolon);
+}

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"
+
+using namespace mlir;
+
+static LogicalResult MlirToCppTranslateFunction(ModuleOp module,
+                                                llvm::raw_ostream &output) {
+  return emitc::TranslateToCpp(*module.getOperation(), output,
+                               /*trailingSemiColon=*/false);
+}
+
+static TranslateFromMLIRRegistration reg("mlir-to-cpp",
+                                         MlirToCppTranslateFunction);

mlir/test/Dialect/EmitC/ops.mlir

+// RUN: mlir-opt -verify-diagnostics %s | FileCheck %s
+
+// CHECK-LABEL: func @f(%{{.*}}: i32, %{{.*}}: !emitc.int32_t) -> i1 {
+func @f(%arg0: i32, %f: !emitc<"int32_t">) -> i1 {
+  %1 = "emitc.call"() {callee = "blah"} : () -> i64
+  emitc.call "foo" (%1) {args = [
+    0 : index, dense<[0, 1]> : tensor<2xi32>, 0 : index
+  ]} : (i64) -> ()
+  %2:3 = "bar"(%1) : (i64) -> (i1,i1,i1)
+  return %2#1 : i1
+}

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({0, 1});
+  %0 = emitc.call "foo::constant"() {args = [dense<[0, 1]> : tensor<2xi32>]} : () -> (i32)
+  // CHECK: [[V2:[^ ]*]] = foo::op_and_attr({0, 1}, [[V1]]);
+  %1 = emitc.call "foo::op_and_attr"(%0) {args = [dense<[0, 1]> : tensor<2xi32>, 0 : index]} : (i32) -> (i32)
+  // CHECK: [[V3:[^ ]*]] = foo::op_and_attr([[V2]], {0, 1});
+  %2 = emitc.call "foo::op_and_attr"(%1) {args = [0 : index, dense<[0, 1]> : tensor<2xi32>]} : (i32) -> (i32)
+  // CHECK: foo::print([[V3]]);
+  emitc.call "foo::print"(%2): (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 = emitc.call "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

set(LIBS
   MLIRTargetNVVMIR
   MLIRTargetROCDLIR
   MLIRTranslation
   MLIRSupport
 )
 set(FULL_LIBS
   MLIRSPIRVSerialization
   MLIRTargetAVX512
+  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)