[mlir] Add Cpp emitter

[marbre]

Summary

This upstreams the Cpp emitter, initially presented with [1], from [2]
to MLIR core. Together with the previously upstreamed EmitC dialect [3],
the target allows to translate MLIR to C/C++.

[1] https://reviews.llvm.org/D76571
[2] https://github.com/iml130/mlir-emitc
[3] https://reviews.llvm.org/D103969

Co-authored-by: Jacques Pienaar <[e-mail]>
Co-authored-by: Simon Camphausen <[e-mail]>
Co-authored-by: Oliver Scherf <[e-mail]>

[marbre]

Take care of clang-tidy warnings

[marbre]

Take care of clang-tidy warnings

[rriddle]

Thanks! Starting to piece through, but have some high level questions:

Can you add proper .md documentation? We should give the user an idea of what is being generated from a high level, and understand the rationale/tradeoff behind our decisions.

What version of C/C++ are you targeting here? (Part of the previous question) Users should have an idea of the minimum toolchain requirements of the generated code.

mlir/include/mlir/Target/Cpp/CppEmitter.h

26

Can you document this class and API?

66

Is this API intended to be exposed to users? Or is this emitted simply an implementation detail?

[rriddle]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

809–841

If you use overloading, you can reduce this by a lot with TypeSwitch:

https://github.com/llvm/llvm-project/blob/4867641f3041f7b2530336edfaf6655f98d2dca2/mlir/lib/Rewrite/ByteCode.cpp#L630

862

nit: Please drop trivial braces here. (and elsewhere in the commit)

[marbre]

In D104632#2839176, @rriddle wrote:

Thanks! Starting to piece through, but have some high level questions:

Thanks River, I appreciate this! Trying to answer some of your questions prior to sending the next revision.

Can you add proper .md documentation? We should give the user an idea of what is being generated from a high level, and understand the rationale/tradeoff behind our decisions.

Sure! Do you have a suggestion where to place it? I think the other MLIR targets are not documented in a single place like e.g. all dialects are.

What version of C/C++ are you targeting here? (Part of the previous question) Users should have an idea of the minimum toolchain requirements of the generated code.

Well it depends on the conversions one writes. For ops with multiple return values the code emitted requires C++11 as those got emitted as std::tuple. Further, one can write conversions to emitc::CallOps that have floating-point type template argument, making C++20 mandatory. Such code can be emitted, but it doesn't has to. We intended to not limit this in the emitter, but I absolutely agree that we need to document this!

mlir/include/mlir/Target/Cpp/CppEmitter.h

26

Even simpler, I will delete the struct which the next revision as it is an unused leftover. Sorry for this.

66

Well I think it depends on how we define the user level. E.g. in IREE the emitter is initialized in the translateModuleToC() function of the CModuleTarget. So one can use the API outside the MLIR core repo. Would you call this user level?

mlir/lib/Target/Cpp/TranslateToCpp.cpp

862

Uh, I was following the Google style guide too closely and assumed dropping trivial braces is only allowed when you don't have an else block. Will go over all those places with the next revision. Thanks!

[mehdi_amini]

The handling of C/C++ isn't clear to me, I looked at restrictedToC uses and it seems that ForOp and ConstOp are doing something special but it isn't clear to me. It likely deserves more docs.

Otherwise I'm not convinced that erroring out on constructs that aren't valid in C is really worth the complexity, nor that this belongs to the emitter itself (it is also incomplete, for example the return op can do std::make_tuple without error right now).

mlir/include/mlir/Target/Cpp/CppEmitter.h

66

To me that looks like a very large C++ surface API for this. Would it be possible to start smaller, keep more things private until this gets mileage and carefully expose more APIs later?

We could start with only translateToCpp exposed for example.

156

Can you use verbs for API when it makes sense? getForwardDeclaredVariabled isRestrictedToC

192

Please document the options, I don't know what trailingSemicolon means for example.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

289

Can you document what's happening here?

434

Why these hardcoded includes?

443

This won't respect the interleaving of includes and other operations in the module.

mlir/test/Target/Cpp/common-cpp.mlir

7

Can we change the custom syntax to be emit.include <myheader.h> for standard include? (or emit.include <"myheader.h"> if we can't parse the former)?

[mehdi_amini]

mlir/include/mlir/Target/Cpp/CppEmitter.h

172

ValueMapper valueMapper : there is really no need to skip on two characters here.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

474

I don't know what "forward declare" really means for variables: this seems to imply a difference between declaration and definition like for functions.

It also is the kind of things that makes the IR definition incompatible with some emission mode, it'd be best to avoid this and remove the option and just do the right thing: do we need to move all variable to the top when there are multiple blocks or only for the SSA value that are defined in a block and used in another one?

[marbre]

Thanks for your review Mehdi! Trying to answer some of your questions below and inline prior to sending the next revision. I will address those I did not respond to with the updated patch.

In D104632#2839410, @mehdi_amini wrote:

The handling of C/C++ isn't clear to me, I looked at restrictedToC uses and it seems that ForOp and ConstOp are doing something special but it isn't clear to me. It likely deserves more docs.

I agree that this clearly deserves more documentation. The one difference here is that the emitted code contains curly-brace-delimited initializer lists when generating C++ code. When emiting C code, the initialization is expressed with =.

Otherwise I'm not convinced that erroring out on constructs that aren't valid in C is really worth the complexity, nor that this belongs to the emitter itself (it is also incomplete, for example the return op can do std::make_tuple without error right now).

We started with emitting C++ code and added the ability to restrict the emitter to C code later, as this was needed for IREE. We internally discussed to split into two separate emitters, but decided against it as we assumed that it would probably result in to much code duplication. Designing a single emitter, for the initialization discussed above the alternative would have been to always use an = to express it. As we need to error out some types (anything not a fundamental type in C) we thought differentiating for the initialization would be fine.
For std::make_tupe your are absolutely right, this is bug and we need to return an error in that case.

mlir/include/mlir/Target/Cpp/CppEmitter.h

66

That was what we had with the initial proposal https://reviews.llvm.org/D76571. However, for IREE we need an emitter that is able to translate e.g. IREE::VM::ModuleOp, IREE::VM::FuncOp and others to C. There we reuse e.g. emitType() which we have to duplicate otherwise. So I would prefer to not make all things private, but for sure we can go over and carefully go over and see if there is something we can make private easily. Hope this might be acceptable?

mlir/lib/Target/Cpp/TranslateToCpp.cpp

434

The #include <cmath> can indeed be dropped. The ones emitted when emitting C are required for the types, but we can also drop those as they can be expressed via emitc::IncludeOps.

443

This is true. Do you propose to emit includes wherever they are in the IR file?

474

We introduced this when support for emitting code that contains branches was added. Probably Simon, who implemented this, can comment best (will ping him).

mlir/test/Target/Cpp/common-cpp.mlir

7

Just to make sure I got you right, you suggest
emitc.include <myheader>
for standard includes and
emitc.include "myheader"
for non-standard includes?

I can give it a try, but would send a separate patch as it's already landed this way and is not directly related to this patch.

[marbre]

In D104632#2839410, @mehdi_amini wrote:

[..]
Otherwise I'm not convinced that erroring out on constructs that aren't valid in C is really worth the complexity, nor that this belongs to the emitter itself (it is also incomplete, for example the return op can do std::make_tuple without error right now).

Indeed hard to test. At least I cant create an IR snippet that hits an error when trying to create std::make_tuple while restricted to C. The snippet

func @func_tuple(%arg0: i32,  %arg1 : i32) -> (i32, i32) {
  return %arg0, %arg1 : i32, i32
}

is translated to C++ as

std::tuple<int32_t, int32_t> func_tuple(int32_t v1, int32_t v2) {
return std::make_tuple(v1, v2);
}

Even if restricted to C, one does not hit an error trying to emit the std::make_tuple in printReturnOp(). This is because emitTupleType() already returns an error when trying to create the function's return type std::tuple. Nevertheless, I will add a check taking care of std::make_tuple as well as additional C specific test snippets.

[mehdi_amini]

. We internally discussed to split into two separate emitters,

I wouldn't suggest this, I would suggest a single emitter, and a single mode, capturing the difference in the IR. If the only thing is the curly brace default initialization, can we always use = in the C++ emitter so that we have C-compatible output from the C++ emitter (assuming the absence of C++ features like returning multiple values from a function or templates).

As we need to error out some types (anything not a fundamental type in C) we thought differentiating for the initialization would be fine.

This does not need to be part of the emitter, it can be a validation on the module itself that you can run ahead of time for example.

[mehdi_amini]

mlir/include/mlir/Target/Cpp/CppEmitter.h

66

Your use-case indicates to me a problem with the design of the emitter itself.
It seems that the user may want to have custom emitter for their operations instead of targeting what is supported by the emitter.
But the design you're taking is exposing the internal of the emitter allowing the user to extend it in a standalone way, which unfortunately isn't composable.

It also seems to partially defeat the original point of having a dialect, since the motivation was to be able to always use dialect conversion to bottom out into a representation that can be emitted to C/C++.
If this isn't possible then we're back to adding a mechanism where operations could define an interface or something like this to plug into the emitter. But this is weirdly going against the motivation for the dialect as I understood it, since it was trying to avoid this.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

443

I would do this, as it provide the control back to the IR. Any downside to do this?

We can also imagine that some include requires to have some other construct defined before the inclusion.

[stellaraccident]

mlir/include/mlir/Target/Cpp/CppEmitter.h

66

That was what we had with the initial proposal https://reviews.llvm.org/D76571. However, for IREE we need an emitter that is able to translate e.g. IREE::VM::ModuleOp, IREE::VM::FuncOp and others to C. There we reuse e.g. emitType() which we have to duplicate otherwise. So I would prefer to not make all things private, but for sure we can go over and carefully go over and see if there is something we can make private easily. Hope this might be acceptable?

I generally agree with River/Mehdi's critique of the API surface area here and think we should land this with a limited API surface area.

Considering IREE::VM::ModuleOp and IREE::VM::FuncOp, it feels to me like your ConvertVMToEmitC pass just stopped to soon and should have also converted those ops (I know they are tricky to convert, and it may be easier to have a subsequent pass that finalizes the module and function conversion). Looking at that code a bit, it appears to me as if this point alone accounts for no small amount of the divergence and need to expose API surface area, with some more being accounted for by the correlated IREE::VM::ReturnOp.

This alone brings up a design question for EmitC: namely does it *have* to be tied to builtin ModuleOp and FuncOp? In this upstream version, you've basically encoded this assumption. I feel like you could relax the assumption that the top-level is ModuleOp (just let it be an Operation* -- although it is unfortunate that the Translation API declares this as ModuleOp and it should probably be generalized in a followon) and you could key off of FunctionLike instead, if you wanted to be a bit more friendly to users who are bringing their own module/function ops.

However, even with the above, there are further design points: you will need to model somehow some of the header/trailer things that you are currently doing ad-hoc in the IREE-side translation function. We should probably discuss more, but I would tend to want to introduce something like emitc.ModuleMetaAttr and emitc.FuncMetaAttr to let such things be encoded. (I'd tend that way because it would likely reduce the conversion burden for users, but the alternatives are to bring your own ModuleOp/FuncOp that carries this stuff, define additional operations to model this, etc).

On the IREE side, it appears that you are using the chance to control the overall emission to cover for some things that really should be modeled in EmitC itself (ie. headers/trailers/etc). This isn't so bad for a single use in IREE, but widening this to common infra means that we should really start in the pure form and then iterate to implement the needed features to fully represent what you are doing on the IREE side (as opposed to relying on some backdoors that look to me largely there to cover for features that just haven't been implemented yet). I'm looking at some of those items and finishing it doesn't seem insurmountable -- not really big design issues there, just work.

I haven't done a complete detailed review of everything in this diff, but I think that if, in this patch, we made the emitter private, it would hold together as a pretty good initial submission. I realize this doesn't get you to carving out the IREE VM->EmitC translation in one step, but it looks like there are important points to work out to finish the features and it would be better to do so incrementally. We can always carry a copy of this code in IREE during the conversion (i.e. use the upstream dialect and progressively finish the emitter until it is complete enough to swap entirely).

I know this can feel a bit slow, but starting restricted and expanding will help us deal with (I'm guessing) the 3-6 additional features and landing them well so that the feature has a better chance of working for everyone in a non ad-hoc fashion.

Thank you for working with us on it!

[marbre]

mlir/include/mlir/Target/Cpp/CppEmitter.h

66

Thanks for all the feedback and the comments. Unfortunately, I only have time for a rather short reply.

First of all, I got the point and agree that we should rather start with only exposing translateToCpp. It's fine for me if we cant use the upstreamed emitter 1:1 in IREE. I mainly intended to give background information on why it is the way it is, although we could have done better. As proposed, I would refactor to only expose translateToCpp with the next revision. I hope we can build upon this, without having something which is contrary to the actual motivation. It already came to my mind that we might need our own EmitC ModuleOpand FuncOp, but the alternative Stella mentioned is quite interesting. I would be glad if we could continue this discussion. Is discourse preferred to do so?

[simon-camp]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

474

We could technically declare variables for "block local" SSA values in their corresponding blocks. (Or more generally move them to the dominating Block if we iterate over blocks in dominance order I think).

We would still need to split the variable initialization into a declaration followed by an assignment because jumping over variables with initializers is ill-formed in C++. (cppreference)

I tried different variants for the SSA value %b here.

[marbre]

mlir/test/Target/Cpp/common-cpp.mlir

7

@mehdi_amini please see https://reviews.llvm.org/D105281 which Simon has sent and which addresses the parsing and printing of the custom format.

[marbre]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

443

I think we need the capability to emit include directives at the top level of source file and thus prior to any forward declared function. Types used in the forward declared functions can rely on those top level includes, for example when using tensors.
However, I agree that giving control back to the IR is better . Would you mind if we add an attribute like emit_at_top to the include op?

[jpienaar]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

443

I think lets start there: why is forward declaration needed? Is there a way to represent fwd declaration as an op? An alternative I could see here would be to go in order (so you can still have have interleaving, still things at the top with no changes to the ops), once you encounter a function you can fwd declare all functions until the next include (which couldn't rely on an include below them anyway) and continue. The alternative seems more opaque though/could easily be implemented as a "prepare for export" pass on emitc dialect. This function becomes dead simple if all are explicit.

[mehdi_amini]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

443

Would you mind if we add an attribute like emit_at_top to the include op?

Why add such an attribute instead of relying on the IR ordering?

443

I mean: if I am in a position to add this include with the emit_at_top attribute, I can just as well add the op at the top of the module directly?

[marbre]

Thanks for all review comments. Most comments should be addressed with the next revision. As discussed, the emitter's API is now significantly closed (only translateToCpp is accessible). The revision also drops the emitter's restriction to only generate C code. This is of course still possible and depends (as before) on the implemented conversions, but isn't checked in the emitter itself anymore. What the revision lacks is a dedicated markdown documentation. Suggestion to where to place such docs in the docs/ folder are welcome. So far the other targets don't have separate docs or should those live side-by-side to the EmitC dialect?

mlir/include/mlir/Target/Cpp/CppEmitter.h

156

restrictedToC is dropped and forwardDeclaredVariables is renamed to shouldDeclareVariablesAtTop with the next revision.

192

With the next revision, trailingSemicolon is removed from translateToC and it is documented were appropriate.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

289

This is refactored with dropping emitting braced initializers.

443

I think lets start there: why is forward declaration needed? Is there a way to represent fwd declaration as an op? An alternative I could see here would be to go in order (so you can still have have interleaving, still things at the top with no changes to the ops), once you encounter a function you can fwd declare all functions until the next include (which couldn't rely on an include below them anyway) and continue. The alternative seems more opaque though/could easily be implemented as a "prepare for export" pass on emitc dialect. This function becomes dead simple if all are explicit.

443

I think lets start there: why is forward declaration needed? Is there a way to represent fwd declaration as an op? An alternative I could see here would be to go in order (so you can still have have interleaving, still things at the top with no changes to the ops), once you encounter a function you can fwd declare all functions until the next include (which couldn't rely on an include below them anyway) and continue. The alternative seems more opaque though/could easily be implemented as a "prepare for export" pass on emitc dialect. This function becomes dead simple if all are explicit.

Thanks for your suggestion. I really like the idea of adding an operation that explicitly allows to indicate that a declaration should be forward declared. This could look like emitc.forwarddeclare @func. The alternative, going in order and to declare all functions forward till hitting the next include op seems even more implicit than what we already have.
For now, I simply removed forward declaring functions at all. I am aware that you, Jacques, probably had good reasons to add it to the original proposal. However, I have refactored our MHLO/TOSA to EmitC conversion passes in a way that we don't need any forward declarations for now. I think best would to re-enable this by adding an explicit op as you proposed as soon as we have a use case.

443

I am fine with relying on the IR ordering and thus I removed to code that forward declared the functions + implemented include op handling as for any other op. Just relying on the IR ordering for include ops wouldn't have been enough as function were always forward at the top of an module. That was probably the root issue, but that's now resolved and we'll follow Jacques suggestion of adding a new op if we really want to get this ability back.

474

I have renamed forwardDeclaredVariables to shouldDeclareVariablesAtTop. Hopefully that makes it clearer. We further improved the comments to make it clearer what's happening.

809–841

Thanks for the suggestion. Done with the next revision.

[marbre]

Updating D104632: [mlir] Add Cpp emitter

[mehdi_amini]

For the doc, what about adding a section in the dialect doc? It'll show up on this page then: https://mlir.llvm.org/docs/Dialects/EmitC/

See how other dialect have a fairly large doc as well: https://mlir.llvm.org/docs/Dialects/TOSA/ or https://mlir.llvm.org/docs/Dialects/Linalg/

[marbre]

Add markdown documentation and dialect description

[marbre]

With https://github.com/llvm/mlir-www/pull/83 merged (allowing to include custom docs in auto-generated ones) and me having finally had some time to write a first markdown documentation (we can still iterate and improve that one!) I would kindly ask @rriddle, @mehdi_amini and @jpienaar to re-review the patch :)

[jpienaar]

Nice, thanks for all the changes

mlir/docs/Dialects/emitc.md

5

Could the version required of the generated code perhaps be printed? This seems like an easy gotcha (generate code use it in X, it works until you make one change and suddenly end up requiring different version of C++ and the user doesn't know why).

6

Could we make this more "active"? E.g.,

The following convention is followed:

• If multiple ..., C++11 is required
• If floating ..., C++20 is required
• Else the generated code is compatible with C99 ?

[also could we test these?]

10

C++20 is a bit unfortunate as most consumers here incl MLIR core can't use it.

23

This doesn't seem like documenting the dialect, but the Cpp emitter and so should be documented along with it,

31

Why the gap? If to signify different dialects, why not indented list? (I'm not sure what markdown generated will show with space, but feels like making the structure explicit is nicer)

mlir/include/mlir/Target/Cpp/CppEmitter.h

30

Operation *op would result in nicer implicit conversions AFAIK, e.g., should be able to just do translateToCpp(module, os, false) below and ModuleOp would get converted.

mlir/lib/Target/Cpp/TranslateRegistration.cpp

42

I would have expected something like

--mlir-to-cpp --cpp-declare-variables-at-top

as that is how the other translates work (SavedModel one having a lot of args)

mlir/lib/Target/Cpp/TranslateToCpp.cpp

32

Nit: STLExtras , to not confuse with C++ STL

72

Why do you need to pass in an Operation when emitting an Attribute?

162

I would have used raw_indented_ostream here, especially as it would work well with Scope helper to do indentation

177

Why is this not in the Scope construct too?

244

Errors emitted are sentence fragments that start with lower case and don't end with punctuation

626

Is this as it is redundant for these? I believe for CondBranchOp it is required due to goto, but not sure

703

So this requires cmath header?

775

Seems like you are using op here only to get a Location. Could we rather just pass a Location?

908

Mmm, I'd almost prefer this to be shouldMapToUnsigned: signed and signless are both mapped to intX_t, while unsigned is mapped to uintX_t.

[simon-camp]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

177

Wouldn't we need a stack<Scope> then? ScopedHashTableScope is not copy/move constructible.

Is there a way to directly calculate the size of a ScopedHashTable? Then we wouldn't need the stack at allI think.

[marbre]

Address review comments

[marbre]

Thanks for the review @jpienaar! I have updated our patch accordingly.

mlir/docs/Dialects/emitc.md

5

Initially we had mlir-to-cpp and mlir-to-c. We have removed all checks in the emitter, as Mehdi proposed to rather add a verifier pass. So yes, we could just print if a feature requiring C++XX is used of we implement a verifier pass. Anyway, I would like to do so in a follow up if acceptable.

6

Done.

[also could we test these?]

I think this is related to the verifier pass isn't it?

10

It is, but that's a decision to be made by the user. If somebody really wants to generate code that contains floating-point type template arguments, the user can do so.

23

Yes, this documents the emitter. Mehdi proposed so before:

In D104632#2867746, @mehdi_amini wrote:

For the doc, what about adding a section in the dialect doc? It'll show up on this page then: https://mlir.llvm.org/docs/Dialects/EmitC/

See how other dialect have a fairly large doc as well: https://mlir.llvm.org/docs/Dialects/TOSA/ or https://mlir.llvm.org/docs/Dialects/Linalg/

31

It's now explicit.

mlir/include/mlir/Target/Cpp/CppEmitter.h

30

Good point, have refactored this.

mlir/lib/Target/Cpp/TranslateRegistration.cpp

42

This is what we had in iml130/mlir-emitc before commit #1a87d97. However, with add_flag_if_supported("-Werror=global-constructors" WERROR_GLOBAL_CONSTRUCTOR) set in mlir/lib/CMakeLists.txt this solution cannot be taken over 1:1. Instead one would need to touch mlir/lib/Translation/Translation.cpp, adding static llvm::cl::opt parameters there. However, these options would be always present, even if the Cpp emitter isn't build. I assumed that this would therefore be undesired and decided to go with the current implementation.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

72

This was used to make use of op.emitError(). I have refactored this and now a location is passed to the functions emitAttribute, emitType, emitTypes and emitTupleType.

162

Thanks for the suggestion, I wasn't aware of raw_indented_ostream. Have refactored accordingly and we now emit indented code!

626

We've updated to comment to better describe why this is needed.

703

It does. This can be emitted via an emitc.include. However, this has to be done in the conversion pass and we do not emit any includes by default as suggested in the first rounds of the review.

775

As commented above, this was refactored as proposed.

[mehdi_amini]

mlir/lib/Target/Cpp/TranslateRegistration.cpp

42

You could just create a static cl::opt in this function (registerToCppTranslation) and use it inside the lambda:

static cl::opt<bool> declareVariablesAtTop("mlir-to-cpp-declare-variables-at-top");
TranslateFromMLIRRegistration reg(
     "mlir-to-cpp",
     [&](ModuleOp module, raw_ostream &output) {
       return emitc::translateToCpp(module, output, declareVariablesAtTop);
     },
     [](DialectRegistry &registry) {
       // clang-format off
       registry.insert<emitc::EmitCDialect,
                       StandardOpsDialect,
                       scf::SCFDialect>();
       // clang-format on
     });

[marbre]

mlir/lib/Target/Cpp/TranslateRegistration.cpp

42

You could just create a static cl::opt in this function (registerToCppTranslation) and use it inside the lambda: [..]

Thanks for the suggestion, I really appreciate the support. Unfortunately, the also this approach fails due to add_flag_if_supported("-Werror=global-constructors" WERROR_GLOBAL_CONSTRUCTOR) in mlir/lib/CMakeLists.txt:

[build] mlir/lib/Target/Cpp/TranslateRegistration.cpp:26:28: error: declaration requires a global destructor [-Werror,-Wglobal-constructors]
[build] static llvm::cl::opt<bool> declareVariablesAtTop("declare-variables-at-top");
[build]                            ^

[mehdi_amini]

mlir/lib/Target/Cpp/TranslateRegistration.cpp

42

There is something fishy, this is a technique we're already using in a few places:

https://github.com/llvm/llvm-project/blob/main/mlir/lib/Translation/Translation.cpp#L132-L137
https://github.com/llvm/llvm-project/blob/main/mlir/lib/Support/MlirOptMain.cpp#L162-L168

[marbre]

mlir/lib/Target/Cpp/TranslateRegistration.cpp

42

You're right! I accidentally placed the cl::opt<bool> outside the function scope and not within the scope of void registerToCppTranslation(). Will update our patch asap. Thanks again for your help with this!

[marbre]

Refactor translation cmdline arguments

[mehdi_amini]

I'll leave approval to @jpienaar, the current version is fine with me, thanks!

[marbre]

In D104632#2972448, @mehdi_amini wrote:

I'll leave approval to @jpienaar, the current version is fine with me, thanks!

Thanks a lot for the feedback! Beside @jpienaar's opinion, which of course is important, would the current version also be fine for @rriddle?

[jpienaar]

Nice, thanks, LG

[rriddle]

Did a scan, looks good thanks!

mlir/docs/Dialects/emitc.md

+The EmitC dialect allows to convert operations from other MLIR dialects to
+EmitC ops. Those can be translated to C/C++ via the Cpp emitter.
+
+The following convention is followed:
+
+* If template arguments are passed to an `emitc.call` operation,
+  C++ is generated.
+* If tensors are used, C++ is generated.
+* If multiple return values are used within in a functions or an
+  `emitc.call` operation, C++11 is required.
+* If floating-point type template arguments are passed to an `emitc.call`
+  operation, C++20 is required.
+* Else the generated code is compatible with C99.
+
+These restrictions are neither inherent to the EmitC dialect itself nor to the
+Cpp emitter and therefore need to be considered while implementing conversions.
+
+After the conversion, C/C++ code can be emitted with `mlir-translate`. The tool
+support translating MLIR to C/C++ by passing `-mlir-to-cpp`.
+Furthermore, code with variables declared at top can be generated by passing 
+`-mlir-to-cpp-with-variable-declarations-at-top`.
+
+Besides operations part of the EmitC dialect, the Cpp targets supports
+translating the following operations:
+
+* 'std' Dialect
+  * `std.br`
+  * `std.call`
+  * `std.cond_br`
+  * `std.constant`
+  * `std.return`
+* 'scf' Dialect
+  * `scf.for`
+  * `scf.yield`

mlir/include/mlir/Dialect/EmitC/IR/EmitCBase.td

 
 //===----------------------------------------------------------------------===//
 // EmitC dialect definition
 //===----------------------------------------------------------------------===//
 
 def EmitC_Dialect : Dialect {
   let name = "emitc";
   let cppNamespace = "::mlir::emitc";
+
+  let summary = "Dialect to generate C/C++ from MLIR.";
+  let description = [{
+    [include "Dialects/emitc.md"]
+  }];
+
   let hasConstantMaterializer = 1;
 }
 
 #endif // MLIR_DIALECT_EMITC_IR_EMITCBASE

mlir/include/mlir/InitAllTranslations.h

 
 #ifndef MLIR_INITALLTRANSLATIONS_H
 #define MLIR_INITALLTRANSLATIONS_H
 
 namespace mlir {
 
 void registerFromLLVMIRTranslation();
 void registerFromSPIRVTranslation();
+void registerToCppTranslation();
 void registerToLLVMIRTranslation();
 void registerToSPIRVTranslation();
 
 // This function should be called before creating any MLIRContext if one
 // expects all the possible translations to be made available to the context
 // automatically.
 inline void registerAllTranslations() {
   static bool initOnce = []() {
     registerFromLLVMIRTranslation();
     registerFromSPIRVTranslation();
+    registerToCppTranslation();
     registerToLLVMIRTranslation();
     registerToSPIRVTranslation();
     return true;
   }();
   (void)initOnce;
 }
 } // namespace mlir
 
 #endif // MLIR_INITALLTRANSLATIONS_H

mlir/include/mlir/Target/Cpp/CppEmitter.h

+//===- CppEmitter.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 defines helpers to emit C++ code using the EmitC dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TARGET_CPP_CPPEMITTER_H
+#define MLIR_TARGET_CPP_CPPEMITTER_H
+
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/Value.h"
+#include "llvm/ADT/ScopedHashTable.h"
+#include "llvm/Support/raw_ostream.h"
+#include <stack>
+
+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. The parameter
+/// 'declareVariablesAtTop' enforces that all variables for op results and block
+/// arguments are declared at the beginning of the function.
+LogicalResult translateToCpp(Operation *op, raw_ostream &os,
+                             bool declareVariablesAtTop = false);
+} // namespace emitc
+} // namespace mlir
+
+#endif // MLIR_TARGET_CPP_CPPEMITTER_H

mlir/lib/Target/CMakeLists.txt

+add_subdirectory(Cpp)
 add_subdirectory(SPIRV)
 add_subdirectory(LLVMIR)

mlir/lib/Target/Cpp/CMakeLists.txt

+add_mlir_translation_library(MLIRTargetCpp
+  TranslateRegistration.cpp
+  TranslateToCpp.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${EMITC_MAIN_INCLUDE_DIR}/emitc/Target/Cpp
+
+  LINK_LIBS PUBLIC
+  MLIREmitC
+  MLIRIR
+  MLIRSCF
+  MLIRStandard
+  MLIRSupport
+  )

mlir/lib/Target/Cpp/TranslateRegistration.cpp

+//===- TranslateRegistration.cpp - Register translation -------------------===//
+//
+// 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/IR/EmitC.h"
+#include "mlir/Dialect/SCF/SCF.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/Target/Cpp/CppEmitter.h"
+#include "mlir/Translation.h"
+#include "llvm/Support/CommandLine.h"
+
+using namespace mlir;
+
+namespace mlir {
+
+//===----------------------------------------------------------------------===//
+// Cpp registration
+//===----------------------------------------------------------------------===//
+
+void registerToCppTranslation() {
+  static llvm::cl::opt<bool> declareVariablesAtTop(
+      "declare-variables-at-top",
+      llvm::cl::desc("Declare variables at top when emitting C/C++"),
+      llvm::cl::init(false));
+
+  TranslateFromMLIRRegistration reg(
+      "mlir-to-cpp",
+      [](ModuleOp module, raw_ostream &output) {
+        return emitc::translateToCpp(
+            module, output,
+            /*declareVariablesAtTop=*/declareVariablesAtTop);
+      },
+      [](DialectRegistry &registry) {
+        // clang-format off
+        registry.insert<emitc::EmitCDialect,
+                        StandardOpsDialect,
+                        scf::SCFDialect>();
+        // clang-format on
+      });
+}
+
+} // namespace mlir

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/IR/EmitC.h"
+#include "mlir/Dialect/SCF/SCF.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/Support/IndentedOstream.h"
+#include "mlir/Target/Cpp/CppEmitter.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/TypeSwitch.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FormatVariadic.h"
+
+#define DEBUG_TYPE "translate-to-cpp"
+
+using namespace mlir;
+using namespace mlir::emitc;
+using llvm::formatv;
+
+/// Convenience functions to produce interleaved output with functions returning
+/// a LogicalResult. This is different than those in STLExtras 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 eachFn, NullaryFunctor betweenFn) {
+  if (begin == end)
+    return success();
+  if (failed(eachFn(*begin)))
+    return failure();
+  ++begin;
+  for (; begin != end; ++begin) {
+    betweenFn();
+    if (failed(eachFn(*begin)))
+      return failure();
+  }
+  return success();
+}
+
+template <typename Container, typename UnaryFunctor, typename NullaryFunctor>
+inline LogicalResult interleaveWithError(const Container &c,
+                                         UnaryFunctor eachFn,
+                                         NullaryFunctor betweenFn) {
+  return interleaveWithError(c.begin(), c.end(), eachFn, betweenFn);
+}
+
+template <typename Container, typename UnaryFunctor>
+inline LogicalResult interleaveCommaWithError(const Container &c,
+                                              raw_ostream &os,
+                                              UnaryFunctor eachFn) {
+  return interleaveWithError(c.begin(), c.end(), eachFn, [&]() { os << ", "; });
+}
+
+namespace {
+/// Emitter that uses dialect specific emitters to emit C++ code.
+struct CppEmitter {
+  explicit CppEmitter(raw_ostream &os, bool declareVariablesAtTop);
+
+  /// Emits attribute or returns failure.
+  LogicalResult emitAttribute(Location loc, Attribute attr);
+
+  /// Emits operation 'op' with/without training semicolon or returns failure.
+  LogicalResult emitOperation(Operation &op, bool trailingSemicolon);
+
+  /// Emits type 'type' or returns failure.
+  LogicalResult emitType(Location loc, Type type);
+
+  /// Emits array of types as a std::tuple of the emitted types.
+  /// - emits void for an empty array;
+  /// - emits the type of the only element for arrays of size one;
+  /// - emits a std::tuple otherwise;
+  LogicalResult emitTypes(Location loc, ArrayRef<Type> types);
+
+  /// Emits array of types as a std::tuple of the emitted types independently of
+  /// the array size.
+  LogicalResult emitTupleType(Location loc, ArrayRef<Type> types);
+
+  /// Emits an assignment for a variable which has been declared previously.
+  LogicalResult emitVariableAssignment(OpResult result);
+
+  /// Emits a variable declaration for a result of an operation.
+  LogicalResult emitVariableDeclaration(OpResult result,
+                                        bool trailingSemicolon);
+
+  /// 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 a label for the block.
+  LogicalResult emitLabel(Block &block);
+
+  /// 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);
+
+  /// Return the existing or a new label of a Block.
+  StringRef getOrCreateName(Block &block);
+
+  /// Whether to map an mlir integer to a unsigned integer in C++.
+  bool shouldMapToUnsigned(IntegerType::SignednessSemantics val);
+
+  /// RAII helper function to manage entering/exiting C++ scopes.
+  struct Scope {
+    Scope(CppEmitter &emitter)
+        : valueMapperScope(emitter.valueMapper),
+          blockMapperScope(emitter.blockMapper), emitter(emitter) {
+      emitter.valueInScopeCount.push(emitter.valueInScopeCount.top());
+      emitter.labelInScopeCount.push(emitter.labelInScopeCount.top());
+    }
+    ~Scope() {
+      emitter.valueInScopeCount.pop();
+      emitter.labelInScopeCount.pop();
+    }
+
+  private:
+    llvm::ScopedHashTableScope<Value, std::string> valueMapperScope;
+    llvm::ScopedHashTableScope<Block *, std::string> blockMapperScope;
+    CppEmitter &emitter;
+  };
+
+  /// Returns wether the Value is assigned to a C++ variable in the scope.
+  bool hasValueInScope(Value val);
+
+  // Returns whether a label is assigned to the block.
+  bool hasBlockLabel(Block &block);
+
+  /// Returns the output stream.
+  raw_indented_ostream &ostream() { return os; };
+
+  /// Returns if all variables for op results and basic block arguments need to
+  /// be declared at the beginning of a function.
+  bool shouldDeclareVariablesAtTop() { return declareVariablesAtTop; };
+
+private:
+  using ValueMapper = llvm::ScopedHashTable<Value, std::string>;
+  using BlockMapper = llvm::ScopedHashTable<Block *, std::string>;
+
+  /// Output stream to emit to.
+  raw_indented_ostream os;
+
+  /// Boolean to enforce that all variables for op results and block
+  /// arguments are declared at the beginning of the function. This also
+  /// includes results from ops located in nested regions.
+  bool declareVariablesAtTop;
+
+  /// Map from value to name of C++ variable that contain the name.
+  ValueMapper valueMapper;
+
+  /// Map from block to name of C++ label.
+  BlockMapper blockMapper;
+
+  /// 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;
+  std::stack<int64_t> labelInScopeCount;
+};
+} // namespace
+
+static LogicalResult printConstantOp(CppEmitter &emitter, Operation *operation,
+                                     Attribute value) {
+  OpResult result = operation->getResult(0);
+
+  // Only emit an assignment as the variable was already declared when printing
+  // the FuncOp.
+  if (emitter.shouldDeclareVariablesAtTop()) {
+    // Skip the assignment if the emitc.constant has no value.
+    if (auto oAttr = value.dyn_cast<emitc::OpaqueAttr>()) {
+      if (oAttr.getValue().empty())
+        return success();
+    }
+
+    if (failed(emitter.emitVariableAssignment(result)))
+      return failure();
+    return emitter.emitAttribute(operation->getLoc(), value);
+  }
+
+  // Emit a variable declaration for an emitc.constant op without value.
+  if (auto oAttr = value.dyn_cast<emitc::OpaqueAttr>()) {
+    if (oAttr.getValue().empty())
+      // The semicolon gets printed by the emitOperation function.
+      return emitter.emitVariableDeclaration(result,
+                                             /*trailingSemicolon=*/false);
+  }
+
+  // Emit a variable declaration.
+  if (failed(emitter.emitAssignPrefix(*operation)))
+    return failure();
+  return emitter.emitAttribute(operation->getLoc(), value);
+}
+
+static LogicalResult printOperation(CppEmitter &emitter,
+                                    emitc::ConstantOp constantOp) {
+  Operation *operation = constantOp.getOperation();
+  Attribute value = constantOp.value();
+
+  return printConstantOp(emitter, operation, value);
+}
+
+static LogicalResult printOperation(CppEmitter &emitter,
+                                    mlir::ConstantOp constantOp) {
+  Operation *operation = constantOp.getOperation();
+  Attribute value = constantOp.value();
+
+  return printConstantOp(emitter, operation, value);
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, BranchOp branchOp) {
+  raw_ostream &os = emitter.ostream();
+  Block &successor = *branchOp.getSuccessor();
+
+  for (auto pair :
+       llvm::zip(branchOp.getOperands(), successor.getArguments())) {
+    Value &operand = std::get<0>(pair);
+    BlockArgument &argument = std::get<1>(pair);
+    os << emitter.getOrCreateName(argument) << " = "
+       << emitter.getOrCreateName(operand) << ";\n";
+  }
+
+  os << "goto ";
+  if (!(emitter.hasBlockLabel(successor)))
+    return branchOp.emitOpError("unable to find label for successor block");
+  os << emitter.getOrCreateName(successor);
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter,
+                                    CondBranchOp condBranchOp) {
+  raw_ostream &os = emitter.ostream();
+  Block &trueSuccessor = *condBranchOp.getTrueDest();
+  Block &falseSuccessor = *condBranchOp.getFalseDest();
+
+  os << "if (" << emitter.getOrCreateName(condBranchOp.getCondition())
+     << ") {\n";
+
+  // If condition is true.
+  for (auto pair : llvm::zip(condBranchOp.getTrueOperands(),
+                             trueSuccessor.getArguments())) {
+    Value &operand = std::get<0>(pair);
+    BlockArgument &argument = std::get<1>(pair);
+    os << emitter.getOrCreateName(argument) << " = "
+       << emitter.getOrCreateName(operand) << ";\n";
+  }
+
+  os << "goto ";
+  if (!(emitter.hasBlockLabel(trueSuccessor))) {
+    return condBranchOp.emitOpError("unable to find label for successor block");
+  }
+  os << emitter.getOrCreateName(trueSuccessor) << ";\n";
+  os << "} else {\n";
+  // If condition is false.
+  for (auto pair : llvm::zip(condBranchOp.getFalseOperands(),
+                             falseSuccessor.getArguments())) {
+    Value &operand = std::get<0>(pair);
+    BlockArgument &argument = std::get<1>(pair);
+    os << emitter.getOrCreateName(argument) << " = "
+       << emitter.getOrCreateName(operand) << ";\n";
+  }
+
+  os << "goto ";
+  if (!(emitter.hasBlockLabel(falseSuccessor))) {
+    return condBranchOp.emitOpError()
+           << "unable to find label for successor block";
+  }
+  os << emitter.getOrCreateName(falseSuccessor) << ";\n";
+  os << "}";
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, mlir::CallOp callOp) {
+  if (failed(emitter.emitAssignPrefix(*callOp.getOperation())))
+    return failure();
+
+  raw_ostream &os = emitter.ostream();
+  os << callOp.getCallee() << "(";
+  if (failed(emitter.emitOperands(*callOp.getOperation())))
+    return failure();
+  os << ")";
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, emitc::CallOp callOp) {
+  raw_ostream &os = emitter.ostream();
+  Operation &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()) {
+        int64_t 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();
+      }
+    }
+    if (failed(emitter.emitAttribute(op.getLoc(), attr)))
+      return failure();
+
+    return success();
+  };
+
+  if (callOp.template_args()) {
+    os << "<";
+    if (failed(interleaveCommaWithError(*callOp.template_args(), os, emitArgs)))
+      return failure();
+    os << ">";
+  }
+
+  os << "(";
+
+  LogicalResult emittedArgs =
+      callOp.args() ? interleaveCommaWithError(*callOp.args(), os, emitArgs)
+                    : emitter.emitOperands(op);
+  if (failed(emittedArgs))
+    return failure();
+  os << ")";
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter,
+                                    emitc::ApplyOp applyOp) {
+  raw_ostream &os = emitter.ostream();
+  Operation &op = *applyOp.getOperation();
+
+  if (failed(emitter.emitAssignPrefix(op)))
+    return failure();
+  os << applyOp.applicableOperator();
+  os << emitter.getOrCreateName(applyOp.getOperand());
+
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter,
+                                    emitc::IncludeOp includeOp) {
+  raw_ostream &os = emitter.ostream();
+
+  os << "#include ";
+  if (includeOp.is_standard_include())
+    os << "<" << includeOp.include() << ">";
+  else
+    os << "\"" << includeOp.include() << "\"";
+
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, scf::ForOp forOp) {
+
+  raw_indented_ostream &os = emitter.ostream();
+
+  OperandRange operands = forOp.getIterOperands();
+  Block::BlockArgListType iterArgs = forOp.getRegionIterArgs();
+  Operation::result_range results = forOp.getResults();
+
+  if (!emitter.shouldDeclareVariablesAtTop()) {
+    for (OpResult result : results) {
+      if (failed(emitter.emitVariableDeclaration(result,
+                                                 /*trailingSemicolon=*/true)))
+        return failure();
+    }
+  }
+
+  for (auto pair : llvm::zip(iterArgs, operands)) {
+    if (failed(emitter.emitType(forOp.getLoc(), std::get<0>(pair).getType())))
+      return failure();
+    os << " " << emitter.getOrCreateName(std::get<0>(pair)) << " = ";
+    os << emitter.getOrCreateName(std::get<1>(pair)) << ";";
+    os << "\n";
+  }
+
+  os << "for (";
+  if (failed(
+          emitter.emitType(forOp.getLoc(), forOp.getInductionVar().getType())))
+    return failure();
+  os << " ";
+  os << emitter.getOrCreateName(forOp.getInductionVar());
+  os << " = ";
+  os << emitter.getOrCreateName(forOp.lowerBound());
+  os << "; ";
+  os << emitter.getOrCreateName(forOp.getInductionVar());
+  os << " < ";
+  os << emitter.getOrCreateName(forOp.upperBound());
+  os << "; ";
+  os << emitter.getOrCreateName(forOp.getInductionVar());
+  os << " += ";
+  os << emitter.getOrCreateName(forOp.step());
+  os << ") {\n";
+  os.indent();
+
+  Region &forRegion = forOp.region();
+  auto regionOps = forRegion.getOps();
+
+  // We skip the trailing yield op because this updates the result variables
+  // of the for op in the generated code. Instead we update the iterArgs at
+  // the end of a loop iteration and set the result variables after the for
+  // loop.
+  for (auto it = regionOps.begin(); std::next(it) != regionOps.end(); ++it) {
+    if (failed(emitter.emitOperation(*it, /*trailingSemicolon=*/true)))
+      return failure();
+  }
+
+  Operation *yieldOp = forRegion.getBlocks().front().getTerminator();
+  // Copy yield operands into iterArgs at the end of a loop iteration.
+  for (auto pair : llvm::zip(iterArgs, yieldOp->getOperands())) {
+    BlockArgument iterArg = std::get<0>(pair);
+    Value operand = std::get<1>(pair);
+    os << emitter.getOrCreateName(iterArg) << " = "
+       << emitter.getOrCreateName(operand) << ";\n";
+  }
+
+  os.unindent() << "}";
+
+  // Copy iterArgs into results after the for loop.
+  for (auto pair : llvm::zip(results, iterArgs)) {
+    OpResult result = std::get<0>(pair);
+    BlockArgument iterArg = std::get<1>(pair);
+    os << "\n"
+       << emitter.getOrCreateName(result) << " = "
+       << emitter.getOrCreateName(iterArg) << ";";
+  }
+
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, scf::IfOp ifOp) {
+  raw_indented_ostream &os = emitter.ostream();
+
+  if (!emitter.shouldDeclareVariablesAtTop()) {
+    for (OpResult result : ifOp.getResults()) {
+      if (failed(emitter.emitVariableDeclaration(result,
+                                                 /*trailingSemicolon=*/true)))
+        return failure();
+    }
+  }
+
+  os << "if (";
+  if (failed(emitter.emitOperands(*ifOp.getOperation())))
+    return failure();
+  os << ") {\n";
+  os.indent();
+
+  Region &thenRegion = ifOp.thenRegion();
+  for (Operation &op : thenRegion.getOps()) {
+    // Note: This prints a superfluous semicolon if the terminating yield op has
+    // zero results.
+    if (failed(emitter.emitOperation(op, /*trailingSemicolon=*/true)))
+      return failure();
+  }
+
+  os.unindent() << "}";
+
+  Region &elseRegion = ifOp.elseRegion();
+  if (!elseRegion.empty()) {
+    os << " else {\n";
+    os.indent();
+
+    for (Operation &op : elseRegion.getOps()) {
+      // Note: This prints a superfluous semicolon if the terminating yield op
+      // has zero results.
+      if (failed(emitter.emitOperation(op, /*trailingSemicolon=*/true)))
+        return failure();
+    }
+
+    os.unindent() << "}";
+  }
+
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, scf::YieldOp yieldOp) {
+  raw_ostream &os = emitter.ostream();
+  Operation &parentOp = *yieldOp.getOperation()->getParentOp();
+
+  if (yieldOp.getNumOperands() != parentOp.getNumResults()) {
+    return yieldOp.emitError("number of operands does not to match the number "
+                             "of the parent op's results");
+  }
+
+  if (failed(interleaveWithError(
+          llvm::zip(parentOp.getResults(), yieldOp.getOperands()),
+          [&](auto pair) -> LogicalResult {
+            auto result = std::get<0>(pair);
+            auto operand = std::get<1>(pair);
+            os << emitter.getOrCreateName(result) << " = ";
+
+            if (!emitter.hasValueInScope(operand))
+              return yieldOp.emitError("operand value not in scope");
+            os << emitter.getOrCreateName(operand);
+            return success();
+          },
+          [&]() { os << ";\n"; })))
+    return failure();
+
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, ReturnOp returnOp) {
+  raw_ostream &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 printOperation(CppEmitter &emitter, ModuleOp moduleOp) {
+  CppEmitter::Scope scope(emitter);
+
+  for (Operation &op : moduleOp) {
+    if (failed(emitter.emitOperation(op, /*trailingSemicolon=*/false)))
+      return failure();
+  }
+  return success();
+}
+
+static LogicalResult printOperation(CppEmitter &emitter, FuncOp functionOp) {
+  // We need to declare variables at top if the function has multiple blocks.
+  if (!emitter.shouldDeclareVariablesAtTop() &&
+      functionOp.getBlocks().size() > 1) {
+    return functionOp.emitOpError(
+        "with multiple blocks needs variables declared at top");
+  }
+
+  CppEmitter::Scope scope(emitter);
+  raw_indented_ostream &os = emitter.ostream();
+  if (failed(emitter.emitTypes(functionOp.getLoc(),
+                               functionOp.getType().getResults())))
+    return failure();
+  os << " " << functionOp.getName();
+
+  os << "(";
+  if (failed(interleaveCommaWithError(
+          functionOp.getArguments(), os,
+          [&](BlockArgument arg) -> LogicalResult {
+            if (failed(emitter.emitType(functionOp.getLoc(), arg.getType())))
+              return failure();
+            os << " " << emitter.getOrCreateName(arg);
+            return success();
+          })))
+    return failure();
+  os << ") {\n";
+  os.indent();
+  if (emitter.shouldDeclareVariablesAtTop()) {
+    // Declare all variables that hold op results including those from nested
+    // regions.
+    WalkResult result =
+        functionOp.walk<WalkOrder::PreOrder>([&](Operation *op) -> WalkResult {
+          for (OpResult result : op->getResults()) {
+            if (failed(emitter.emitVariableDeclaration(
+                    result, /*trailingSemicolon=*/true))) {
+              return WalkResult(
+                  op->emitError("unable to declare result variable for op"));
+            }
+          }
+          return WalkResult::advance();
+        });
+    if (result.wasInterrupted())
+      return failure();
+  }
+
+  Region::BlockListType &blocks = functionOp.getBlocks();
+  // Create label names for basic blocks.
+  for (Block &block : blocks) {
+    emitter.getOrCreateName(block);
+  }
+
+  // Declare variables for basic block arguments.
+  for (auto it = std::next(blocks.begin()); it != blocks.end(); ++it) {
+    Block &block = *it;
+    for (BlockArgument &arg : block.getArguments()) {
+      if (emitter.hasValueInScope(arg))
+        return functionOp.emitOpError(" block argument #")
+               << arg.getArgNumber() << " is out of scope";
+      if (failed(
+              emitter.emitType(block.getParentOp()->getLoc(), arg.getType()))) {
+        return failure();
+      }
+      os << " " << emitter.getOrCreateName(arg) << ";\n";
+    }
+  }
+
+  for (Block &block : blocks) {
+    // Only print a label if there is more than one block.
+    if (blocks.size() > 1) {
+      if (failed(emitter.emitLabel(block)))
+        return failure();
+    }
+    for (Operation &op : block.getOperations()) {
+      // When generating code for an scf.if or std.cond_br op no semicolon needs
+      // to be printed after the closing brace.
+      // When generating code for an scf.for op, printing a trailing semicolon
+      // is handled within the printOperation function.
+      bool trailingSemicolon = !isa<scf::IfOp, scf::ForOp, CondBranchOp>(op);
+
+      if (failed(emitter.emitOperation(
+              op, /*trailingSemicolon=*/trailingSemicolon)))
+        return failure();
+    }
+  }
+  os.unindent() << "}\n";
+  return success();
+}
+
+CppEmitter::CppEmitter(raw_ostream &os, bool declareVariablesAtTop)
+    : os(os), declareVariablesAtTop(declareVariablesAtTop) {
+  valueInScopeCount.push(0);
+  labelInScopeCount.push(0);
+}
+
+/// Return the existing or a new name for a Value.
+StringRef CppEmitter::getOrCreateName(Value val) {
+  if (!valueMapper.count(val))
+    valueMapper.insert(val, formatv("v{0}", ++valueInScopeCount.top()));
+  return *valueMapper.begin(val);
+}
+
+/// Return the existing or a new label for a Block.
+StringRef CppEmitter::getOrCreateName(Block &block) {
+  if (!blockMapper.count(&block))
+    blockMapper.insert(&block, formatv("label{0}", ++labelInScopeCount.top()));
+  return *blockMapper.begin(&block);
+}
+
+bool CppEmitter::shouldMapToUnsigned(IntegerType::SignednessSemantics val) {
+  switch (val) {
+  case IntegerType::Signless:
+    return false;
+  case IntegerType::Signed:
+    return false;
+  case IntegerType::Unsigned:
+    return true;
+  }
+}
+
+bool CppEmitter::hasValueInScope(Value val) { return valueMapper.count(val); }
+
+bool CppEmitter::hasBlockLabel(Block &block) {
+  return blockMapper.count(&block);
+}
+
+LogicalResult CppEmitter::emitAttribute(Location loc, Attribute attr) {
+  auto printInt = [&](APInt val, bool isSigned) {
+    if (val.getBitWidth() == 1) {
+      if (val.getBoolValue())
+        os << "true";
+      else
+        os << "false";
+    } else {
+      val.print(os, isSigned);
+    }
+  };
+
+  auto printFloat = [&](APFloat val) {
+    if (val.isFinite()) {
+      SmallString<128> strValue;
+      // Use default values of toString except don't truncate zeros.
+      val.toString(strValue, 0, 0, false);
+      switch (llvm::APFloatBase::SemanticsToEnum(val.getSemantics())) {
+      case llvm::APFloatBase::S_IEEEsingle:
+        os << "(float)";
+        break;
+      case llvm::APFloatBase::S_IEEEdouble:
+        os << "(double)";
+        break;
+      default:
+        break;
+      };
+      os << strValue;
+    } else if (val.isNaN()) {
+      os << "NAN";
+    } else if (val.isInfinity()) {
+      if (val.isNegative())
+        os << "-";
+      os << "INFINITY";
+    }
+  };
+
+  // Print floating point attributes.
+  if (auto fAttr = attr.dyn_cast<FloatAttr>()) {
+    printFloat(fAttr.getValue());
+    return success();
+  }
+  if (auto dense = attr.dyn_cast<DenseFPElementsAttr>()) {
+    os << '{';
+    interleaveComma(dense, os, [&](APFloat val) { printFloat(val); });
+    os << '}';
+    return success();
+  }
+
+  // Print integer attributes.
+  if (auto iAttr = attr.dyn_cast<IntegerAttr>()) {
+    if (auto iType = iAttr.getType().dyn_cast<IntegerType>()) {
+      printInt(iAttr.getValue(), shouldMapToUnsigned(iType.getSignedness()));
+      return success();
+    }
+    if (auto iType = iAttr.getType().dyn_cast<IndexType>()) {
+      printInt(iAttr.getValue(), false);
+      return success();
+    }
+  }
+  if (auto dense = attr.dyn_cast<DenseIntElementsAttr>()) {
+    if (auto iType = dense.getType()
+                         .cast<TensorType>()
+                         .getElementType()
+                         .dyn_cast<IntegerType>()) {
+      os << '{';
+      interleaveComma(dense, os, [&](APInt val) {
+        printInt(val, shouldMapToUnsigned(iType.getSignedness()));
+      });
+      os << '}';
+      return success();
+    }
+    if (auto iType = dense.getType()
+                         .cast<TensorType>()
+                         .getElementType()
+                         .dyn_cast<IndexType>()) {
+      os << '{';
+      interleaveComma(dense, os, [&](APInt val) { printInt(val, false); });
+      os << '}';
+      return success();
+    }
+  }
+
+  // Print opaque attributes.
+  if (auto oAttr = attr.dyn_cast<emitc::OpaqueAttr>()) {
+    os << oAttr.getValue();
+    return success();
+  }
+
+  // Print symbolic reference attributes.
+  if (auto sAttr = attr.dyn_cast<SymbolRefAttr>()) {
+    if (sAttr.getNestedReferences().size() > 1)
+      return emitError(loc, "attribute has more than 1 nested reference");
+    os << sAttr.getRootReference().getValue();
+    return success();
+  }
+
+  // Print type attributes.
+  if (auto type = attr.dyn_cast<TypeAttr>())
+    return emitType(loc, type.getValue());
+
+  return emitError(loc, "cannot emit attribute of type ") << attr.getType();
+}
+
+LogicalResult CppEmitter::emitOperands(Operation &op) {
+  auto emitOperandName = [&](Value result) -> LogicalResult {
+    if (!hasValueInScope(result))
+      return op.emitOpError() << "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 (NamedAttribute 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(op.getLoc(), attr.second)))
+      return failure();
+    return success();
+  };
+  return interleaveCommaWithError(op.getAttrs(), os, emitNamedAttribute);
+}
+
+LogicalResult CppEmitter::emitVariableAssignment(OpResult result) {
+  if (!hasValueInScope(result)) {
+    return result.getDefiningOp()->emitOpError(
+        "result variable for the operation has not been declared");
+  }
+  os << getOrCreateName(result) << " = ";
+  return success();
+}
+
+LogicalResult CppEmitter::emitVariableDeclaration(OpResult result,
+                                                  bool trailingSemicolon) {
+  if (hasValueInScope(result)) {
+    return result.getDefiningOp()->emitError(
+        "result variable for the operation already declared");
+  }
+  if (failed(emitType(result.getOwner()->getLoc(), result.getType())))
+    return failure();
+  os << " " << getOrCreateName(result);
+  if (trailingSemicolon)
+    os << ";\n";
+  return success();
+}
+
+LogicalResult CppEmitter::emitAssignPrefix(Operation &op) {
+  switch (op.getNumResults()) {
+  case 0:
+    break;
+  case 1: {
+    OpResult result = op.getResult(0);
+    if (shouldDeclareVariablesAtTop()) {
+      if (failed(emitVariableAssignment(result)))
+        return failure();
+    } else {
+      if (failed(emitVariableDeclaration(result, /*trailingSemicolon=*/false)))
+        return failure();
+      os << " = ";
+    }
+    break;
+  }
+  default:
+    if (!shouldDeclareVariablesAtTop()) {
+      for (OpResult result : op.getResults()) {
+        if (failed(emitVariableDeclaration(result, /*trailingSemicolon=*/true)))
+          return failure();
+      }
+    }
+    os << "std::tie(";
+    interleaveComma(op.getResults(), os,
+                    [&](Value result) { os << getOrCreateName(result); });
+    os << ") = ";
+  }
+  return success();
+}
+
+LogicalResult CppEmitter::emitLabel(Block &block) {
+  if (!hasBlockLabel(block))
+    return block.getParentOp()->emitError("label for block not found");
+  os << getOrCreateName(block) << ":\n";
+  return success();
+}
+
+LogicalResult CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
+  LogicalResult status =
+      llvm::TypeSwitch<Operation *, LogicalResult>(&op)
+          // EmitC ops.
+          .Case<emitc::ApplyOp, emitc::CallOp, emitc::ConstantOp,
+                emitc::IncludeOp>(
+              [&](auto op) { return printOperation(*this, op); })
+          // SCF ops.
+          .Case<scf::ForOp, scf::IfOp, scf::YieldOp>(
+              [&](auto op) { return printOperation(*this, op); })
+          // Standard ops.
+          .Case<BranchOp, mlir::CallOp, CondBranchOp, mlir::ConstantOp, FuncOp,
+                ModuleOp, ReturnOp>(
+              [&](auto op) { return printOperation(*this, op); })
+          .Default([&](Operation *) {
+            return op.emitOpError("unable to find printer for op");
+          });
+
+  if (failed(status))
+    return failure();
+  os << (trailingSemicolon ? ";\n" : "\n");
+  return success();
+}
+
+LogicalResult CppEmitter::emitType(Location loc, Type type) {
+  if (auto iType = type.dyn_cast<IntegerType>()) {
+    switch (iType.getWidth()) {
+    case 1:
+      return (os << "bool"), success();
+    case 8:
+    case 16:
+    case 32:
+    case 64:
+      if (shouldMapToUnsigned(iType.getSignedness()))
+        return (os << "uint" << iType.getWidth() << "_t"), success();
+      else
+        return (os << "int" << iType.getWidth() << "_t"), success();
+    default:
+      return emitError(loc, "cannot emit integer type ") << type;
+    }
+  }
+  if (auto fType = type.dyn_cast<FloatType>()) {
+    switch (fType.getWidth()) {
+    case 32:
+      return (os << "float"), success();
+    case 64:
+      return (os << "double"), success();
+    default:
+      return emitError(loc, "cannot emit float type ") << type;
+    }
+  }
+  if (auto iType = type.dyn_cast<IndexType>())
+    return (os << "size_t"), success();
+  if (auto tType = type.dyn_cast<TensorType>()) {
+    if (!tType.hasRank())
+      return emitError(loc, "cannot emit unranked tensor type");
+    if (!tType.hasStaticShape())
+      return emitError(loc, "cannot emit tensor type with non static shape");
+    os << "Tensor<";
+    if (failed(emitType(loc, tType.getElementType())))
+      return failure();
+    auto shape = tType.getShape();
+    for (auto dimSize : shape) {
+      os << ", ";
+      os << dimSize;
+    }
+    os << ">";
+    return success();
+  }
+  if (auto tType = type.dyn_cast<TupleType>())
+    return emitTupleType(loc, tType.getTypes());
+  if (auto oType = type.dyn_cast<emitc::OpaqueType>()) {
+    os << oType.getValue();
+    return success();
+  }
+  return emitError(loc, "cannot emit type ") << type;
+}
+
+LogicalResult CppEmitter::emitTypes(Location loc, ArrayRef<Type> types) {
+  switch (types.size()) {
+  case 0:
+    os << "void";
+    return success();
+  case 1:
+    return emitType(loc, types.front());
+  default:
+    return emitTupleType(loc, types);
+  }
+}
+
+LogicalResult CppEmitter::emitTupleType(Location loc, ArrayRef<Type> types) {
+  os << "std::tuple<";
+  if (failed(interleaveCommaWithError(
+          types, os, [&](Type type) { return emitType(loc, type); })))
+    return failure();
+  os << ">";
+  return success();
+}
+
+LogicalResult emitc::translateToCpp(Operation *op, raw_ostream &os,
+                                    bool declareVariablesAtTop) {
+  CppEmitter emitter(os, declareVariablesAtTop);
+  return emitter.emitOperation(*op, /*trailingSemicolon=*/false);
+}

mlir/test/Target/Cpp/call.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s -check-prefix=CPP-DEFAULT
+// RUN: mlir-translate -mlir-to-cpp -declare-variables-at-top %s | FileCheck %s -check-prefix=CPP-DECLTOP
+
+func @emitc_call() {
+  %0 = emitc.call "func_a" () : () -> i32
+  %1 = emitc.call "func_b" () : () -> i32
+  return
+}
+// CPP-DEFAULT: void emitc_call() {
+// CPP-DEFAULT-NEXT: int32_t [[V0:[^ ]*]] = func_a();
+// CPP-DEFAULT-NEXT: int32_t [[V1:[^ ]*]] = func_b();
+
+// CPP-DECLTOP: void emitc_call() {
+// CPP-DECLTOP-NEXT: int32_t [[V0:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V1:[^ ]*]];
+// CPP-DECLTOP-NEXT: [[V0:]] = func_a();
+// CPP-DECLTOP-NEXT: [[V1:]] = func_b();
+
+
+func @emitc_call_two_results() {
+  %0 = constant 0 : index
+  %1:2 = emitc.call "two_results" () : () -> (i32, i32)
+  return
+}
+// CPP-DEFAULT: void emitc_call_two_results() {
+// CPP-DEFAULT-NEXT: size_t [[V1:[^ ]*]] = 0;
+// CPP-DEFAULT-NEXT: int32_t [[V2:[^ ]*]];
+// CPP-DEFAULT-NEXT: int32_t [[V3:[^ ]*]];
+// CPP-DEFAULT-NEXT: std::tie([[V2]], [[V3]]) = two_results();
+
+// CPP-DECLTOP: void emitc_call_two_results() {
+// CPP-DECLTOP-NEXT: size_t [[V1:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V2:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V3:[^ ]*]];
+// CPP-DECLTOP-NEXT: [[V1]] = 0;
+// CPP-DECLTOP-NEXT: std::tie([[V2]], [[V3]]) = two_results();

mlir/test/Target/Cpp/common-cpp.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s
+
+// CHECK: #include "myheader.h"
+emitc.include "myheader.h"
+// CHECK: #include <myheader.h>
+emitc.include <"myheader.h">
+
+// 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
+}
+
+// CHECK: test_float
+func @test_float() {
+  // CHECK: foo::constant({(float)0.0e+00, (float)1.000000000e+00})
+  %0 = emitc.call "foo::constant"() {args = [dense<[0.000000e+00, 1.000000e+00]> : tensor<2xf32>]} : () -> f32
+  return
+}
+
+// CHECK: test_uint
+func @test_uint() {
+  // CHECK: uint32_t
+  %0 = emitc.call "foo::constant"() {args = [dense<[0, 1]> : tensor<2xui32>]} : () -> ui32
+  // CHECK: uint64_t
+  %1 = emitc.call "foo::constant"() {args = [dense<[0, 1]> : tensor<2xui64>]} : () -> ui64
+  return
+}
+
+// CHECK: int64_t test_plus_int(int64_t [[V1]])
+func @test_plus_int(%arg0 : i64) -> i64 {
+  // CHECK: mhlo::add([[V1]], [[V1]])
+  %0 = emitc.call "mhlo::add"(%arg0, %arg0) {args = [0 : index, 1 : index]} : (i64, i64) -> i64
+  return %0 : i64
+}
+
+// CHECK: Tensor<float, 2> mixed_types(Tensor<double, 2> [[V1]])
+func @mixed_types(%arg0: tensor<2xf64>) -> tensor<2xf32> {
+  // CHECK: foo::mixed_types([[V1]]);
+  %0 = emitc.call "foo::mixed_types"(%arg0) {args = [0 : index]} : (tensor<2xf64>) -> tensor<2xf32>
+  return %0 : tensor<2xf32>
+}
+
+// CHECK: Tensor<uint64_t> mhlo_convert(Tensor<uint32_t> [[V1]])
+func @mhlo_convert(%arg0: tensor<ui32>) -> tensor<ui64> {
+  // CHECK: mhlo::convert([[V1]]);
+  %0 = emitc.call "mhlo::convert"(%arg0) {args = [0 : index]} : (tensor<ui32>) -> tensor<ui64>
+  return %0 : tensor<ui64>
+}
+
+// CHECK: status_t opaque_types(bool [[V1:[^ ]*]], char [[V2:[^ ]*]]) {
+func @opaque_types(%arg0: !emitc.opaque<"bool">, %arg1: !emitc.opaque<"char">) -> !emitc.opaque<"status_t"> {
+  // CHECK: int [[V3:[^ ]*]] = a([[V1]], [[V2]]);
+  %0 = emitc.call "a"(%arg0, %arg1) : (!emitc.opaque<"bool">, !emitc.opaque<"char">) -> (!emitc.opaque<"int">)
+  // CHECK: char [[V4:[^ ]*]] = b([[V3]]);
+  %1 = emitc.call "b"(%0): (!emitc.opaque<"int">) -> (!emitc.opaque<"char">)
+  // CHECK: status_t [[V5:[^ ]*]] = c([[V3]], [[V4]]);
+  %2 = emitc.call "c"(%0, %1): (!emitc.opaque<"int">, !emitc.opaque<"char">) -> (!emitc.opaque<"status_t">)
+  return %2 : !emitc.opaque<"status_t">
+}
+
+func @apply(%arg0: i32) -> !emitc.opaque<"int32_t*"> {
+  // CHECK: int32_t* [[V2]] = &[[V1]];
+  %0 = emitc.apply "&"(%arg0) : (i32) -> !emitc.opaque<"int32_t*">
+  // CHECK: int32_t [[V3]] = *[[V2]];
+  %1 = emitc.apply "*"(%0) : (!emitc.opaque<"int32_t*">) -> (i32)
+  return %0 : !emitc.opaque<"int32_t*">
+}

mlir/test/Target/Cpp/const.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s -check-prefix=CPP-DEFAULT
+// RUN: mlir-translate -mlir-to-cpp -declare-variables-at-top %s | FileCheck %s -check-prefix=CPP-DECLTOP
+
+
+func @emitc_constant() {
+  %c0 = "emitc.constant"(){value = #emitc.opaque<""> : i32} : () -> i32
+  %c1 = "emitc.constant"(){value = 42 : i32} : () -> i32
+  %c2 = "emitc.constant"(){value = #emitc.opaque<""> : !emitc.opaque<"int32_t*">} : () -> !emitc.opaque<"int32_t*">
+  %c3 = "emitc.constant"(){value = #emitc.opaque<"NULL"> : !emitc.opaque<"int32_t*">} : () -> !emitc.opaque<"int32_t*">
+  return
+}
+// CPP-DEFAULT: void emitc_constant() {
+// CPP-DEFAULT-NEXT: int32_t [[V0:[^ ]*]];
+// CPP-DEFAULT-NEXT: int32_t [[V1:[^ ]*]] = 42;
+// CPP-DEFAULT-NEXT: int32_t* [[V2:[^ ]*]];
+// CPP-DEFAULT-NEXT: int32_t* [[V3:[^ ]*]] = NULL;
+
+// CPP-DECLTOP: void emitc_constant() {
+// CPP-DECLTOP-NEXT: int32_t [[V0:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V1:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t* [[V2:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t* [[V3:[^ ]*]];
+// CPP-DECLTOP-NEXT: ;
+// CPP-DECLTOP-NEXT: [[V1]] = 42;
+// CPP-DECLTOP-NEXT: ;
+// CPP-DECLTOP-NEXT: [[V3]] = NULL;

mlir/test/Target/Cpp/control_flow.mlir

+// RUN: mlir-translate -mlir-to-cpp -declare-variables-at-top %s | FileCheck %s -check-prefix=CPP-DECLTOP
+
+// simple(10, true)  -> 20
+// simple(10, false) -> 30
+func @simple(i64, i1) -> i64 {
+^bb0(%a: i64, %cond: i1):
+  cond_br %cond, ^bb1, ^bb2
+^bb1:
+  br ^bb3(%a: i64)
+^bb2:
+  %b = emitc.call "add"(%a, %a) : (i64, i64) -> i64
+  br ^bb3(%b: i64)
+^bb3(%c: i64):
+  br ^bb4(%c, %a : i64, i64)
+^bb4(%d : i64, %e : i64):
+  %0 = emitc.call "add"(%d, %e) : (i64, i64) -> i64
+  return %0 : i64
+}
+  // CPP-DECLTOP: int64_t simple(int64_t [[A:[^ ]*]], bool [[COND:[^ ]*]]) {
+    // CPP-DECLTOP-NEXT: int64_t [[B:[^ ]*]];
+    // CPP-DECLTOP-NEXT: int64_t [[V0:[^ ]*]];
+    // CPP-DECLTOP-NEXT: int64_t [[C:[^ ]*]];
+    // CPP-DECLTOP-NEXT: int64_t [[D:[^ ]*]];
+    // CPP-DECLTOP-NEXT: int64_t [[E:[^ ]*]];
+    // CPP-DECLTOP-NEXT: [[BB0:[^ ]*]]:
+    // CPP-DECLTOP-NEXT: if ([[COND]]) {
+    // CPP-DECLTOP-NEXT: goto [[BB1:[^ ]*]];
+    // CPP-DECLTOP-NEXT: } else {
+    // CPP-DECLTOP-NEXT: goto [[BB2:[^ ]*]];
+    // CPP-DECLTOP-NEXT: }
+    // CPP-DECLTOP-NEXT: [[BB1]]:
+    // CPP-DECLTOP-NEXT: [[C]] = [[A]];
+    // CPP-DECLTOP-NEXT: goto [[BB3:[^ ]*]];
+    // CPP-DECLTOP-NEXT: [[BB2]]:
+    // CPP-DECLTOP-NEXT: [[B]] = add([[A]], [[A]]);
+    // CPP-DECLTOP-NEXT: [[C]] = [[B]];
+    // CPP-DECLTOP-NEXT: goto [[BB3]];
+    // CPP-DECLTOP-NEXT: [[BB3]]:
+    // CPP-DECLTOP-NEXT: [[D]] = [[C]];
+    // CPP-DECLTOP-NEXT: [[E]] = [[A]];
+    // CPP-DECLTOP-NEXT: goto [[BB4:[^ ]*]];
+    // CPP-DECLTOP-NEXT: [[BB4]]:
+    // CPP-DECLTOP-NEXT: [[V0]] = add([[D]], [[E]]);
+    // CPP-DECLTOP-NEXT: return [[V0]];
+
+
+func @block_labels0() {
+^bb1:
+    br ^bb2
+^bb2:
+    return
+}
+// CPP-DECLTOP: void block_labels0() {
+  // CPP-DECLTOP-NEXT: label1:
+  // CPP-DECLTOP-NEXT: goto label2;
+  // CPP-DECLTOP-NEXT: label2:
+  // CPP-DECLTOP-NEXT: return;
+  // CPP-DECLTOP-NEXT: }
+
+
+// Repeat the same function to make sure the names of the block labels get reset.
+func @block_labels1() {
+^bb1:
+    br ^bb2
+^bb2:
+    return
+}
+// CPP-DECLTOP: void block_labels1() {
+  // CPP-DECLTOP-NEXT: label1:
+  // CPP-DECLTOP-NEXT: goto label2;
+  // CPP-DECLTOP-NEXT: label2:
+  // CPP-DECLTOP-NEXT: return;
+  // CPP-DECLTOP-NEXT: }

mlir/test/Target/Cpp/for.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s -check-prefix=CPP-DEFAULT
+// RUN: mlir-translate -mlir-to-cpp -declare-variables-at-top %s | FileCheck %s -check-prefix=CPP-DECLTOP
+
+func @test_for(%arg0 : index, %arg1 : index, %arg2 : index) {
+  scf.for %i0 = %arg0 to %arg1 step %arg2 {
+    %0 = emitc.call "f"() : () -> i32
+  }
+  return
+}
+// CPP-DEFAULT: void test_for(size_t [[START:[^ ]*]], size_t [[STOP:[^ ]*]], size_t [[STEP:[^ ]*]]) {
+// CPP-DEFAULT-NEXT: for (size_t [[ITER:[^ ]*]] = [[START]]; [[ITER]] < [[STOP]]; [[ITER]] += [[STEP]]) {
+// CPP-DEFAULT-NEXT: int32_t [[V4:[^ ]*]] = f();
+// CPP-DEFAULT-NEXT: }
+// CPP-DEFAULT-NEXT: return;
+
+// CPP-DECLTOP: void test_for(size_t [[START:[^ ]*]], size_t [[STOP:[^ ]*]], size_t [[STEP:[^ ]*]]) {
+// CPP-DECLTOP-NEXT: int32_t [[V4:[^ ]*]];
+// CPP-DECLTOP-NEXT: for (size_t [[ITER:[^ ]*]] = [[START]]; [[ITER]] < [[STOP]]; [[ITER]] += [[STEP]]) {
+// CPP-DECLTOP-NEXT: [[V4]] = f();
+// CPP-DECLTOP-NEXT: }
+// CPP-DECLTOP-NEXT: return;
+
+func @test_for_yield() {
+  %start = constant 0 : index
+  %stop = constant 10 : index
+  %step = constant 1 : index
+
+  %s0 = constant 0 : i32
+  %p0 = constant 1.0 : f32
+  
+  %result:2 = scf.for %iter = %start to %stop step %step iter_args(%si = %s0, %pi = %p0) -> (i32, f32) {
+    %sn = emitc.call "add"(%si, %iter) : (i32, index) -> i32
+    %pn = emitc.call "mul"(%pi, %iter) : (f32, index) -> f32
+    scf.yield %sn, %pn : i32, f32
+  }
+
+  return
+}
+// CPP-DEFAULT: void test_for_yield() {
+// CPP-DEFAULT-NEXT: size_t [[START:[^ ]*]] = 0;
+// CPP-DEFAULT-NEXT: size_t [[STOP:[^ ]*]] = 10;
+// CPP-DEFAULT-NEXT: size_t [[STEP:[^ ]*]] = 1;
+// CPP-DEFAULT-NEXT: int32_t [[S0:[^ ]*]] = 0;
+// CPP-DEFAULT-NEXT: float [[P0:[^ ]*]] = (float)1.000000000e+00;
+// CPP-DEFAULT-NEXT: int32_t [[SE:[^ ]*]];
+// CPP-DEFAULT-NEXT: float [[PE:[^ ]*]];
+// CPP-DEFAULT-NEXT: int32_t [[SI:[^ ]*]] = [[S0]];
+// CPP-DEFAULT-NEXT: float [[PI:[^ ]*]] = [[P0]];
+// CPP-DEFAULT-NEXT: for (size_t [[ITER:[^ ]*]] = [[START]]; [[ITER]] < [[STOP]]; [[ITER]] += [[STEP]]) {
+// CPP-DEFAULT-NEXT: int32_t [[SN:[^ ]*]] = add([[SI]], [[ITER]]);
+// CPP-DEFAULT-NEXT: float [[PN:[^ ]*]] = mul([[PI]], [[ITER]]);
+// CPP-DEFAULT-NEXT: [[SI]] = [[SN]];
+// CPP-DEFAULT-NEXT: [[PI]] = [[PN]];
+// CPP-DEFAULT-NEXT: }
+// CPP-DEFAULT-NEXT: [[SE]] = [[SI]];
+// CPP-DEFAULT-NEXT: [[PE]] = [[PI]];
+// CPP-DEFAULT-NEXT: return;
+
+// CPP-DECLTOP: void test_for_yield() {
+// CPP-DECLTOP-NEXT: size_t [[START:[^ ]*]];
+// CPP-DECLTOP-NEXT: size_t [[STOP:[^ ]*]];
+// CPP-DECLTOP-NEXT: size_t [[STEP:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[S0:[^ ]*]];
+// CPP-DECLTOP-NEXT: float [[P0:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[SE:[^ ]*]];
+// CPP-DECLTOP-NEXT: float [[PE:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[SN:[^ ]*]];
+// CPP-DECLTOP-NEXT: float [[PN:[^ ]*]];
+// CPP-DECLTOP-NEXT: [[START]] = 0;
+// CPP-DECLTOP-NEXT: [[STOP]] = 10;
+// CPP-DECLTOP-NEXT: [[STEP]] = 1;
+// CPP-DECLTOP-NEXT: [[S0]] = 0;
+// CPP-DECLTOP-NEXT: [[P0]] = (float)1.000000000e+00;
+// CPP-DECLTOP-NEXT: int32_t [[SI:[^ ]*]] = [[S0]];
+// CPP-DECLTOP-NEXT: float [[PI:[^ ]*]] = [[P0]];
+// CPP-DECLTOP-NEXT: for (size_t [[ITER:[^ ]*]] = [[START]]; [[ITER]] < [[STOP]]; [[ITER]] += [[STEP]]) {
+// CPP-DECLTOP-NEXT: [[SN]] = add([[SI]], [[ITER]]);
+// CPP-DECLTOP-NEXT: [[PN]] = mul([[PI]], [[ITER]]);
+// CPP-DECLTOP-NEXT: [[SI]] = [[SN]];
+// CPP-DECLTOP-NEXT: [[PI]] = [[PN]];
+// CPP-DECLTOP-NEXT: }
+// CPP-DECLTOP-NEXT: [[SE]] = [[SI]];
+// CPP-DECLTOP-NEXT: [[PE]] = [[PI]];
+// CPP-DECLTOP-NEXT: return;

mlir/test/Target/Cpp/if.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s -check-prefix=CPP-DEFAULT
+// RUN: mlir-translate -mlir-to-cpp -declare-variables-at-top %s | FileCheck %s -check-prefix=CPP-DECLTOP
+
+func @test_if(%arg0: i1, %arg1: f32) {
+  scf.if %arg0 {
+     %0 = emitc.call "func_const"(%arg1) : (f32) -> i32
+  }
+  return
+}
+// CPP-DEFAULT: void test_if(bool [[V0:[^ ]*]], float [[V1:[^ ]*]]) {
+// CPP-DEFAULT-NEXT: if ([[V0]]) {
+// CPP-DEFAULT-NEXT: int32_t [[V2:[^ ]*]] = func_const([[V1]]);
+// CPP-DEFAULT-NEXT: ;
+// CPP-DEFAULT-NEXT: }
+// CPP-DEFAULT-NEXT: return;
+
+// CPP-DECLTOP: void test_if(bool [[V0:[^ ]*]], float [[V1:[^ ]*]]) {
+// CPP-DECLTOP-NEXT: int32_t [[V2:[^ ]*]];
+// CPP-DECLTOP-NEXT: if ([[V0]]) {
+// CPP-DECLTOP-NEXT: [[V2]] = func_const([[V1]]);
+// CPP-DECLTOP-NEXT: ;
+// CPP-DECLTOP-NEXT: }
+// CPP-DECLTOP-NEXT: return;
+
+
+func @test_if_else(%arg0: i1, %arg1: f32) {
+  scf.if %arg0 {
+    %0 = emitc.call "func_true"(%arg1) : (f32) -> i32
+  } else {
+    %0 = emitc.call "func_false"(%arg1) : (f32) -> i32
+  }
+  return
+}
+// CPP-DEFAULT: void test_if_else(bool [[V0:[^ ]*]], float [[V1:[^ ]*]]) {
+// CPP-DEFAULT-NEXT: if ([[V0]]) {
+// CPP-DEFAULT-NEXT: int32_t [[V2:[^ ]*]] = func_true([[V1]]);
+// CPP-DEFAULT-NEXT: ;
+// CPP-DEFAULT-NEXT: } else {
+// CPP-DEFAULT-NEXT: int32_t [[V3:[^ ]*]] = func_false([[V1]]);
+// CPP-DEFAULT-NEXT: ;
+// CPP-DEFAULT-NEXT: }
+// CPP-DEFAULT-NEXT: return;
+
+// CPP-DECLTOP: void test_if_else(bool [[V0:[^ ]*]], float [[V1:[^ ]*]]) {
+// CPP-DECLTOP-NEXT: int32_t [[V2:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V3:[^ ]*]];
+// CPP-DECLTOP-NEXT: if ([[V0]]) {
+// CPP-DECLTOP-NEXT: [[V2]] = func_true([[V1]]);
+// CPP-DECLTOP-NEXT: ;
+// CPP-DECLTOP-NEXT: } else {
+// CPP-DECLTOP-NEXT: [[V3]] = func_false([[V1]]);
+// CPP-DECLTOP-NEXT: ;
+// CPP-DECLTOP-NEXT: }
+// CPP-DECLTOP-NEXT: return;
+
+
+func @test_if_yield(%arg0: i1, %arg1: f32) {
+  %0 = constant 0 : i8
+  %x, %y = scf.if %arg0 -> (i32, f64) {
+    %1 = emitc.call "func_true_1"(%arg1) : (f32) -> i32
+    %2 = emitc.call "func_true_2"(%arg1) : (f32) -> f64
+    scf.yield %1, %2 : i32, f64
+  } else {
+    %1 = emitc.call "func_false_1"(%arg1) : (f32) -> i32
+    %2 = emitc.call "func_false_2"(%arg1) : (f32) -> f64
+    scf.yield %1, %2 : i32, f64
+  }
+  return
+}
+// CPP-DEFAULT: void test_if_yield(bool [[V0:[^ ]*]], float [[V1:[^ ]*]]) {
+// CPP-DEFAULT-NEXT: int8_t [[V2:[^ ]*]] = 0;
+// CPP-DEFAULT-NEXT: int32_t [[V3:[^ ]*]];
+// CPP-DEFAULT-NEXT: double [[V4:[^ ]*]];
+// CPP-DEFAULT-NEXT: if ([[V0]]) {
+// CPP-DEFAULT-NEXT: int32_t [[V5:[^ ]*]] = func_true_1([[V1]]);
+// CPP-DEFAULT-NEXT: double [[V6:[^ ]*]] = func_true_2([[V1]]);
+// CPP-DEFAULT-NEXT: [[V3]] = [[V5]];
+// CPP-DEFAULT-NEXT: [[V4]] = [[V6]];
+// CPP-DEFAULT-NEXT: } else {
+// CPP-DEFAULT-NEXT: int32_t [[V7:[^ ]*]] = func_false_1([[V1]]);
+// CPP-DEFAULT-NEXT: double [[V8:[^ ]*]] = func_false_2([[V1]]);
+// CPP-DEFAULT-NEXT: [[V3]] = [[V7]];
+// CPP-DEFAULT-NEXT: [[V4]] = [[V8]];
+// CPP-DEFAULT-NEXT: }
+// CPP-DEFAULT-NEXT: return;
+
+// CPP-DECLTOP: void test_if_yield(bool [[V0:[^ ]*]], float [[V1:[^ ]*]]) {
+// CPP-DECLTOP-NEXT: int8_t [[V2:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V3:[^ ]*]];
+// CPP-DECLTOP-NEXT: double [[V4:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V5:[^ ]*]];
+// CPP-DECLTOP-NEXT: double [[V6:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V7:[^ ]*]];
+// CPP-DECLTOP-NEXT: double [[V8:[^ ]*]];
+// CPP-DECLTOP-NEXT: [[V2]] = 0;
+// CPP-DECLTOP-NEXT: if ([[V0]]) {
+// CPP-DECLTOP-NEXT: [[V5]] = func_true_1([[V1]]);
+// CPP-DECLTOP-NEXT: [[V6]] = func_true_2([[V1]]);
+// CPP-DECLTOP-NEXT: [[V3]] = [[V5]];
+// CPP-DECLTOP-NEXT: [[V4]] = [[V6]];
+// CPP-DECLTOP-NEXT: } else {
+// CPP-DECLTOP-NEXT: [[V7]] = func_false_1([[V1]]);
+// CPP-DECLTOP-NEXT: [[V8]] = func_false_2([[V1]]);
+// CPP-DECLTOP-NEXT: [[V3]] = [[V7]];
+// CPP-DECLTOP-NEXT: [[V4]] = [[V8]];
+// CPP-DECLTOP-NEXT: }
+// CPP-DECLTOP-NEXT: return;

mlir/test/Target/Cpp/invalid.mlir

+// RUN: mlir-translate -split-input-file -mlir-to-cpp -verify-diagnostics %s
+
+// expected-error@+1 {{'builtin.func' op with multiple blocks needs variables declared at top}}
+func @multiple_blocks() {
+^bb1:
+    br ^bb2
+^bb2:
+    return
+}
+
+// -----
+
+func @unsupported_std_op(%arg0: f64) -> f64 {
+  // expected-error@+1 {{'std.absf' op unable to find printer for op}}
+  %0 = absf %arg0 : f64
+  return %0 : f64
+}
+
+// -----
+
+// expected-error@+1 {{cannot emit integer type 'i80'}}
+func @unsupported_integer_type(%arg0 : i80) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{cannot emit float type 'f80'}}
+func @unsupported_float_type(%arg0 : f80) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{cannot emit type 'memref<100xf32>'}}
+func @memref_type(%arg0 : memref<100xf32>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{cannot emit type 'vector<100xf32>'}}
+func @vector_type(%arg0 : vector<100xf32>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{cannot emit tensor type with non static shape}}
+func @non_static_shape(%arg0 : tensor<?xf32>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{cannot emit unranked tensor type}}
+func @unranked_tensor(%arg0 : tensor<*xf32>) {
+  return
+}

mlir/test/Target/Cpp/stdops.mlir

+// RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s -check-prefix=CPP-DEFAULT
+// RUN: mlir-translate -mlir-to-cpp -declare-variables-at-top %s | FileCheck %s -check-prefix=CPP-DECLTOP
+
+func @std_constant() {
+  %c0 = constant 0 : i32
+  %c1 = constant 2 : index
+  %c2 = constant 2.0 : f32
+  %c3 = constant dense<0> : tensor<i32>
+  %c4 = constant dense<[0, 1]> : tensor<2xindex>
+  %c5 = constant dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>
+  return
+}
+// CPP-DEFAULT: void std_constant() {
+// CPP-DEFAULT-NEXT: int32_t [[V0:[^ ]*]] = 0;
+// CPP-DEFAULT-NEXT: size_t [[V1:[^ ]*]] = 2;
+// CPP-DEFAULT-NEXT: float [[V2:[^ ]*]] = (float)2.000000000e+00;
+// CPP-DEFAULT-NEXT: Tensor<int32_t> [[V3:[^ ]*]] = {0};
+// CPP-DEFAULT-NEXT: Tensor<size_t, 2> [[V4:[^ ]*]] = {0, 1};
+// CPP-DEFAULT-NEXT: Tensor<float, 2, 2> [[V5:[^ ]*]] = {(float)0.0e+00, (float)1.000000000e+00, (float)2.000000000e+00, (float)3.000000000e+00};
+
+// CPP-DECLTOP: void std_constant() {
+// CPP-DECLTOP-NEXT: int32_t [[V0:[^ ]*]];
+// CPP-DECLTOP-NEXT: size_t [[V1:[^ ]*]];
+// CPP-DECLTOP-NEXT: float [[V2:[^ ]*]];
+// CPP-DECLTOP-NEXT: Tensor<int32_t> [[V3:[^ ]*]];
+// CPP-DECLTOP-NEXT: Tensor<size_t, 2> [[V4:[^ ]*]];
+// CPP-DECLTOP-NEXT: Tensor<float, 2, 2> [[V5:[^ ]*]];
+// CPP-DECLTOP-NEXT: [[V0]] = 0;
+// CPP-DECLTOP-NEXT: [[V1]] = 2;
+// CPP-DECLTOP-NEXT: [[V2]] = (float)2.000000000e+00;
+// CPP-DECLTOP-NEXT: [[V3]] = {0};
+// CPP-DECLTOP-NEXT: [[V4]] = {0, 1};
+// CPP-DECLTOP-NEXT: [[V5]] = {(float)0.0e+00, (float)1.000000000e+00, (float)2.000000000e+00, (float)3.000000000e+00};
+
+func @std_call() {
+  %0 = call @one_result () : () -> i32
+  %1 = call @one_result () : () -> i32
+  return
+}
+// CPP-DEFAULT: void std_call() {
+// CPP-DEFAULT-NEXT: int32_t [[V0:[^ ]*]] = one_result();
+// CPP-DEFAULT-NEXT: int32_t [[V1:[^ ]*]] = one_result();
+
+// CPP-DECLTOP: void std_call() {
+// CPP-DECLTOP-NEXT: int32_t [[V0:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V1:[^ ]*]];
+// CPP-DECLTOP-NEXT: [[V0]] = one_result();
+// CPP-DECLTOP-NEXT: [[V1]] = one_result();
+
+
+func @std_call_two_results() {
+  %c = constant 0 : i8
+  %0:2 = call @two_results () : () -> (i32, f32)
+  %1:2 = call @two_results () : () -> (i32, f32)
+  return
+}
+// CPP-DEFAULT: void std_call_two_results() {
+// CPP-DEFAULT-NEXT: int8_t  [[V0:[^ ]*]] = 0;
+// CPP-DEFAULT-NEXT: int32_t [[V1:[^ ]*]];
+// CPP-DEFAULT-NEXT: float [[V2:[^ ]*]];
+// CPP-DEFAULT-NEXT: std::tie([[V1]], [[V2]]) = two_results();
+// CPP-DEFAULT-NEXT: int32_t [[V3:[^ ]*]];
+// CPP-DEFAULT-NEXT: float [[V4:[^ ]*]];
+// CPP-DEFAULT-NEXT: std::tie([[V3]], [[V4]]) = two_results();
+
+// CPP-DECLTOP: void std_call_two_results() {
+// CPP-DECLTOP-NEXT: int8_t [[V0:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V1:[^ ]*]];
+// CPP-DECLTOP-NEXT: float [[V2:[^ ]*]];
+// CPP-DECLTOP-NEXT: int32_t [[V3:[^ ]*]];
+// CPP-DECLTOP-NEXT: float [[V4:[^ ]*]];
+// CPP-DECLTOP-NEXT: [[V0]] = 0;
+// CPP-DECLTOP-NEXT: std::tie([[V1]], [[V2]]) = two_results();
+// CPP-DECLTOP-NEXT: std::tie([[V3]], [[V4]]) = two_results();
+
+
+func @one_result() -> i32 {
+  %0 = constant 0 : i32
+  return %0 : i32
+}
+// CPP-DEFAULT: int32_t one_result() {
+// CPP-DEFAULT-NEXT: int32_t [[V0:[^ ]*]] = 0;
+// CPP-DEFAULT-NEXT: return [[V0]];
+
+// CPP-DECLTOP: int32_t one_result() {
+// CPP-DECLTOP-NEXT: int32_t [[V0:[^ ]*]];
+// CPP-DECLTOP-NEXT: [[V0]] = 0;
+// CPP-DECLTOP-NEXT: return [[V0]];
+
+
+func @two_results() -> (i32, f32) {
+  %0 = constant 0 : i32
+  %1 = constant 1.0 : f32
+  return %0, %1 : i32, f32
+}
+// CPP-DEFAULT: std::tuple<int32_t, float> two_results() {
+// CPP-DEFAULT: int32_t [[V0:[^ ]*]] = 0;
+// CPP-DEFAULT: float [[V1:[^ ]*]] = (float)1.000000000e+00;
+// CPP-DEFAULT: return std::make_tuple([[V0]], [[V1]]);
+
+// CPP-DECLTOP: std::tuple<int32_t, float> two_results() {
+// CPP-DECLTOP: int32_t [[V0:[^ ]*]];
+// CPP-DECLTOP: float [[V1:[^ ]*]];
+// CPP-DECLTOP: [[V0]] = 0;
+// CPP-DECLTOP: [[V1]] = (float)1.000000000e+00;
+// CPP-DECLTOP: return std::make_tuple([[V0]], [[V1]]);
+
+
+func @single_return_statement(%arg0 : i32) -> i32 {
+  return %arg0 : i32
+}
+// CPP-DEFAULT: int32_t single_return_statement(int32_t [[V0:[^ ]*]]) {
+// CPP-DEFAULT-NEXT: return [[V0]];
+
+// CPP-DECLTOP: int32_t single_return_statement(int32_t [[V0:[^ ]*]]) {
+// CPP-DECLTOP-NEXT: return [[V0]];