[flang] Use CMake to determine endianness.

[Meinersbur]

Summary

The preprocessor definitions __BYTE_ORDER__, __ORDER_BIG_ENDIAN__, and __ORDER_LITTLE_ENDIAN__ are gcc extensions (also supported by clang), but msvc (and maybe others) do not define them. As a result BYTE_ORDER and ORDER_BIG_ENDIAN both evaluate to 0 by the prepreprocess, and __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ , the first #if condition to 1, assuming the wrong byte order in x86(_64).

This patch instead uses CMake's TestBigEndian module to determine target architecture's endianness at configure time.

Note this also uses the same mechanism for the runtime. If compiling flang as a cross-compiler, the runtime for the compile-target must be built separately (Flang does not support the LLVM_ENABLE_RUNTIMES mechanism).

Fixes llvm.org/PR51597

[Leporacanthicus]

Ah, this definitely would make "random" values for floating point values - in weird ways that are hard to understand!

Looks good to me!

[ijan1]

This fixed the issue, I checked and none of the tests fail now. Thanks a ton.
LGTM.

[sscalpone]

Time to upgrade to C++20?
https://en.cppreference.com/w/cpp/types/endian

This change conflates the endianness of the compile-time host with the endianness of the target. Perhaps it better for now to hard-code WIN32 as little endian?

[Meinersbur]

This change conflates the endianness of the compile-time host with the endianness of the target. Perhaps it better for now to hard-code WIN32 as little endian?

The current build system uses the same compiler for host and runtime. As mentioned in the summary, LLVM has the LLVM_ENABLE_RUNTIMES system to build runtimes for multiple targets, which unfortunately is not used by flang.

[AlexisPerry]

In D109108#3027357, @sscalpone wrote:

Time to upgrade to C++20?
https://en.cppreference.com/w/cpp/types/endian

I would be loathe to adopt a newer C++ standard at the moment. Didn't the larger LLVM community initially object to Flang's usage of C++17 because the rest of the codebase only used C++11? I don't remember hearing that they have updated standards yet, and I wouldn't want to create a bigger stumbling block for integration with the larger community.

[awarzynski]

In D109108#3028006, @AlexisPerry wrote:

In D109108#3027357, @sscalpone wrote:

Time to upgrade to C++20?
https://en.cppreference.com/w/cpp/types/endian

I would be loathe to adopt a newer C++ standard at the moment. Didn't the larger LLVM community initially object to Flang's usage of C++17 because the rest of the codebase only used C++11? I don't remember hearing that they have updated standards yet, and I wouldn't want to create a bigger stumbling block for integration with the larger community.

I agree.

While LLVM has since switched to C++14, we should wait for the rest of LLVM to switch to C++17 before considering C++20.

[sscalpone]

@Meinersbur I understand.

Others: Re: C++20 :)

[tschuett]

This does not solve your problem?
https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/Endian.h

[Meinersbur]

In D109108#3029584, @tschuett wrote:

This does not solve your problem?
https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/Endian.h

This uses a manually-maintained list of compilers and with their endianness

llvm/Support/SwapByteOrder.h

#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) ||            \
    defined(__Fuchsia__) || defined(__EMSCRIPTEN__)
#include <endian.h>
#elif defined(_AIX)
#include <sys/machine.h>
#elif defined(__sun)
/* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */
#include <sys/types.h>
#define BIG_ENDIAN 4321
#define LITTLE_ENDIAN 1234
#if defined(_BIG_ENDIAN)
#define BYTE_ORDER BIG_ENDIAN
#else
#define BYTE_ORDER LITTLE_ENDIAN
#endif
#elif defined(__MVS__)
#define BIG_ENDIAN 4321
#define LITTLE_ENDIAN 1234
#define BYTE_ORDER BIG_ENDIAN
#else
#if !defined(BYTE_ORDER) && !defined(_WIN32)
#include <machine/endian.h>
#endif
#endif

I personally find asking cmake the cleaner solution (it does introspection anyway, and endianness must be consistent with the rest of build environment), but I guess the LLVM community will be committed to maintain that list with all supported compilers and would ensure consistency with the rest of LLVM, I could use that if others prefer it.

flang/CMakeLists.txt

 endif()
 
 set(FLANG_REPOSITORY_STRING "" CACHE STRING
   "Vendor-specific text for showing the repository the source is taken from.")
 if (FLANG_REPOSITORY_STRING)
   add_definitions(-DFLANG_REPOSITORY_STRING="${FLANG_REPOSITORY_STRING}")
 endif()
 
+include(TestBigEndian)
+test_big_endian(IS_BIGENDIAN)
+if (IS_BIGENDIAN)
+  add_compile_definitions(FLANG_BIG_ENDIAN=1)
+else ()
+  add_compile_definitions(FLANG_LITTLE_ENDIAN=1)
+endif ()
+
 # Configure Flang's Version.inc file.
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/include/flang/Version.inc.in
   ${CMAKE_CURRENT_BINARY_DIR}/include/flang/Version.inc)
 # Configure Flang's version info header file.
 configure_file(
   ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
   ${FLANG_BINARY_DIR}/include/flang/Config/config.h)

flang/include/flang/Evaluate/common.h

#if __x86_64__
   bool x86CompatibleBehavior{true};
 #else
   bool x86CompatibleBehavior{false};
 #endif
 };
 
 static constexpr Rounding defaultRounding;
 
-#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#if FLANG_BIG_ENDIAN
 constexpr bool isHostLittleEndian{false};
-#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#elif FLANG_LITTLE_ENDIAN
 constexpr bool isHostLittleEndian{true};
 #else
 #error host endianness is not known
 #endif
 
 // HostUnsignedInt<BITS> finds the smallest native unsigned integer type
 // whose size is >= BITS.
 template <bool LE8, bool LE16, bool LE32, bool LE64> struct SmallestUInt {};

flang/runtime/environment.h

 //===-- runtime/environment.h -----------------------------------*- 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 FORTRAN_RUNTIME_ENVIRONMENT_H_
 #define FORTRAN_RUNTIME_ENVIRONMENT_H_
 
 #include "flang/Decimal/decimal.h"
 #include <optional>
 
 namespace Fortran::runtime {
 
-#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#if FLANG_BIG_ENDIAN
 constexpr bool isHostLittleEndian{false};
-#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#elif FLANG_LITTLE_ENDIAN
 constexpr bool isHostLittleEndian{true};
 #else
 #error host endianness is not known
 #endif
 
 // External unformatted I/O data conversions
 enum class Convert { Unknown, Native, LittleEndian, BigEndian, Swap };