[mlir][NFC] Do not convert bool to int when returning from main

[kuhar]

Summary

Instead, use the asMainReturnCode utility function that uses EXIT_SUCCESS and EXIT_FAILURE.

Move asMainReturnCode to LogicalResult.h so that non-opt-based mlir tools can also use it.

[kuhar]

Ping

[mehdi_amini]

Can you clarify the motivation for this?

[kuhar]

In D125701#3537479, @mehdi_amini wrote:

Can you clarify the motivation for this?

My motivation is twofold:

1. The canonical return codes may not be 0 and 1 on some operating systems. While 0 is guaranteed to be a success value in C++, the value for unsuccessful termination (EXIT_FAILURE) is implementation-defined. I found some references about OpenVMS using different exit code values, but I'm not confident about that, nor I know if returning 1 can cause issues on platforms that LLVM actually supports.

2. This is my stylistic preference. succeeded/failed/asMainReturnCode are one of the first functions that appear in MLIR examples and I was surprised this was not used uniformly. IMO, using asMainReturnCode is much more readable/direct than relying on failed and bool-to-int conversions.

[kuhar]

Kind ping

mlir/docs/Tools/MLIRLSP.md

 
 ```c++
 #include "mlir/Tools/mlir-lsp-server/MlirLspServerMain.h"
 
 int main(int argc, char **argv) {
   mlir::DialectRegistry registry;
   registerMyDialects(registry);
   registerMyPasses();
-  return mlir::failed(mlir::MlirLspServerMain(argc, argv, registry));
+  return mlir::asMainReturnCode(mlir::MlirLspServerMain(argc, argv, registry));
 }
 ```
 
 ### Features
 
 This section details a few of the features that the MLIR language server
 provides. The screenshots are shown in [VSCode](https://code.visualstudio.com/),
 but the exact feature set available will depend on your editor client.

mlir/docs/Tools/mlir-reduce.md

 #include "mlir/Tools/mlir-reduce/MlirReduceMain.h"
 using namespace mlir;
 
 int main(int argc, char **argv) {
   DialectRegistry registry;
   registerMyDialects(registry);
   // Register the DialectReductionPatternInterface if any.
   MLIRContext context(registry);
-  return failed(mlirReduceMain(argc, argv, context));
+  return asMainReturnCode(mlirReduceMain(argc, argv, context));
 }
 
 ```
 
 ## Future works
 
 `mlir-reduce` is missing several features,
 
 *   `-reduction-tree` now only supports `Single-Path` traversal mode, extends it
 with different traversal strategies may reduce the input better.
 *   Produce the optimal result when interrupted. The reduction process may take
 a quite long time, it'll be better to get an optimal result so far while an
 interrupt is triggered.

mlir/examples/standalone/standalone-translate/standalone-translate.cpp

 
 #include "Standalone/StandaloneDialect.h"
 
 int main(int argc, char **argv) {
   mlir::registerAllTranslations();
 
   // TODO: Register standalone translations here.
 
-  return failed(
+  return mlir::asMainReturnCode(
       mlir::mlirTranslateMain(argc, argv, "MLIR Translation Testing Tool"));
 }

mlir/include/mlir/Support/LogicalResult.h

 //===- LogicalResult.h - Utilities for handling success/failure -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_SUPPORT_LOGICALRESULT_H
 #define MLIR_SUPPORT_LOGICALRESULT_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/Optional.h"
 
+#include <cstdlib>
+
 namespace mlir {
 
 /// This class represents an efficient way to signal success or failure. It
 /// should be preferred over the use of `bool` when appropriate, as it avoids
 /// all of the ambiguity that arises in interpreting a boolean result. This
 /// class is marked as NODISCARD to ensure that the result is processed. Users
 /// may explicitly discard a result by using `(void)`, e.g.
 /// `(void)functionThatReturnsALogicalResult();`. Given the intended nature of

 /// Utility function that returns true if the provided LogicalResult corresponds
 /// to a success value.
 inline bool succeeded(LogicalResult result) { return result.succeeded(); }
 
 /// Utility function that returns true if the provided LogicalResult corresponds
 /// to a failure value.
 inline bool failed(LogicalResult result) { return result.failed(); }
 
+/// Utility function that converts LogicalResult to an `int` value that can be
+/// returned directly from `main`.
+///
+/// Example:
+///   ```c++
+///   int main(int argc, char **argv) {
+///     // ...
+///     return asMainReturnCode(MlirOptMain(argc, argv, /* ... */));
+///   }
+///   ```
+///
+inline int asMainReturnCode(LogicalResult result) {
+  return result.succeeded() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
 /// This class provides support for representing a failure result, or a valid
 /// value of type `T`. This allows for integrating with LogicalResult, while
 /// also providing a value on the success path.
 template <typename T> class LLVM_NODISCARD FailureOr : public Optional<T> {
 public:
   /// Allow constructing from a LogicalResult. The result *must* be a failure.
   /// Success results should use a proper instance of type `T`.
   FailureOr(LogicalResult result) {

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

 /// - registry should contain all the dialects that can be parsed in the source.
 /// - preloadDialectsInContext will trigger the upfront loading of all
 ///   dialects from the global registry in the MLIRContext. This option is
 ///   deprecated and will be removed soon.
 LogicalResult MlirOptMain(int argc, char **argv, llvm::StringRef toolName,
                           DialectRegistry &registry,
                           bool preloadDialectsInContext = false);
 
-/// Helper wrapper to return the result of MlirOptMain directly from main.
-///
-/// Example:
-///
-///     int main(int argc, char **argv) {
-///       // ...
-///       return mlir::asMainReturnCode(mlir::MlirOptMain(
-///           argc, argv, /* ... */);
-///     }
-///
-inline int asMainReturnCode(LogicalResult r) {
-  return r.succeeded() ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
 } // namespace mlir
 
 #endif // MLIR_TOOLS_MLIROPT_MLIROPTMAIN_H

mlir/tools/mlir-lsp-server/mlir-lsp-server.cpp

 #include "mlir/InitAllDialects.h"
 #include "mlir/Tools/mlir-lsp-server/MlirLspServerMain.h"
 
 using namespace mlir;
 
 int main(int argc, char **argv) {
   DialectRegistry registry;
   registerAllDialects(registry);
-  return failed(MlirLspServerMain(argc, argv, registry));
+  return asMainReturnCode(MlirLspServerMain(argc, argv, registry));
 }

mlir/tools/mlir-pdll-lsp-server/mlir-pdll-lsp-server.cpp

 //===- mlir-pdll-lsp-server.cpp - PDLL Language Server main ---------------===//
 //
 // 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/Support/LogicalResult.h"
 #include "mlir/Tools/mlir-pdll-lsp-server/MlirPdllLspServerMain.h"
 
 using namespace mlir;
 
 int main(int argc, char **argv) {
-  return failed(MlirPdllLspServerMain(argc, argv));
+  return asMainReturnCode(MlirPdllLspServerMain(argc, argv));
 }

mlir/tools/mlir-reduce/mlir-reduce.cpp

int main(int argc, char **argv) {
 
   DialectRegistry registry;
   registerAllDialects(registry);
 #ifdef MLIR_INCLUDE_TESTS
   test::registerTestDialect(registry);
 #endif
   MLIRContext context(registry);
 
-  return failed(mlirReduceMain(argc, argv, context));
+  return asMainReturnCode(mlirReduceMain(argc, argv, context));
 }

mlir/tools/mlir-translate/mlir-translate.cpp

 static void registerTestTranslations() {
   registerTestRoundtripSPIRV();
   registerTestRoundtripDebugSPIRV();
 }
 
 int main(int argc, char **argv) {
   registerAllTranslations();
   registerTestTranslations();
-  return failed(mlirTranslateMain(argc, argv, "MLIR Translation Testing Tool"));
+  return mlir::asMainReturnCode(
+      mlirTranslateMain(argc, argv, "MLIR Translation Testing Tool"));
 }