diff --git a/libs/libxx/Kconfig b/libs/libxx/Kconfig index 866cf59d48d..44d582b2ed2 100644 --- a/libs/libxx/Kconfig +++ b/libs/libxx/Kconfig @@ -101,6 +101,11 @@ config LIBCXXABI_VERSION default LIBCXX_VERSION if LIBCXX default "17.0.6" if !LIBCXX +config LIBSTDCXX_VERSION + string "Select libstdcxx version" + depends on LIBSUPCXX + default "14.2.0" + config CXX_STANDARD string "Language standard" default "c++14" if TRICORE_TOOLCHAIN_TASKING diff --git a/libs/libxx/Makefile b/libs/libxx/Makefile index ab9521c4f9c..65d4e0e9980 100644 --- a/libs/libxx/Makefile +++ b/libs/libxx/Makefile @@ -45,17 +45,19 @@ ifeq ($(CONFIG_LIBCXXABI),y) include libcxxabi/Make.defs else ifeq ($(CONFIG_LIBMINIABI),y) include libminiabi/Make.defs +else ifeq ($(CONFIG_LIBSUPCXX),y) +include libstdc++/libsupc++.defs endif # Object Files -AOBJS = $(ASRCS:.S=$(OBJEXT)) -COBJS = $(CSRCS:.c=$(OBJEXT)) -CXXOBJS = $(CXXSRCS:.cxx=$(OBJEXT)) -CPPOBJS = $(CPPSRCS:.cpp=$(OBJEXT)) +AOBJS += $(ASRCS:.S=$(OBJEXT)) +COBJS += $(CSRCS:.c=$(OBJEXT)) +CXXOBJS += $(CXXSRCS:.cxx=$(OBJEXT)) +CPPOBJS += $(CPPSRCS:.cpp=$(OBJEXT)) -SRCS = $(ASRCS) $(CSRCS) $(CXXSRCS) $(CPPSRCS) -OBJS = $(AOBJS) $(COBJS) $(CXXOBJS) $(CPPOBJS) +SRCS += $(ASRCS) $(CSRCS) $(CXXSRCS) $(CPPSRCS) +OBJS += $(AOBJS) $(COBJS) $(CXXOBJS) $(CPPOBJS) BIN = libxx$(LIBEXT) diff --git a/libs/libxx/libstdc++/.gitignore b/libs/libxx/libstdc++/.gitignore new file mode 100644 index 00000000000..0c61f176947 --- /dev/null +++ b/libs/libxx/libstdc++/.gitignore @@ -0,0 +1 @@ +/libstdc++ diff --git a/libs/libxx/libstdc++/0001-libsupc-Add-missing-header-files.patch b/libs/libxx/libstdc++/0001-libsupc-Add-missing-header-files.patch new file mode 100644 index 00000000000..7a531fc0cef --- /dev/null +++ b/libs/libxx/libstdc++/0001-libsupc-Add-missing-header-files.patch @@ -0,0 +1,2304 @@ +From c21739879c4a444e3503c27290e733b15dba2040 Mon Sep 17 00:00:00 2001 +From: cuiziwei +Date: Tue, 7 Jan 2025 10:22:31 +0800 +Subject: [PATCH] libsupc++: Add missing header files. + +Signed-off-by: cuiziwei +--- + include/bits/c++config.h | 2284 ++++++++++++++++++++++++++++++++++++++ + 1 file changed, 2284 insertions(+) + create mode 100644 include/bits/c++config.h + +diff --git a/include/bits/c++config.h b/include/bits/c++config.h +new file mode 100644 +index 0000000000..e7dcf0307b +--- /dev/null ++++ b/include/bits/c++config.h +@@ -0,0 +1,2284 @@ ++// Predefined symbols and macros -*- C++ -*- ++ ++// Copyright (C) 1997-2023 Free Software Foundation, Inc. ++// ++// This file is part of the GNU ISO C++ Library. This library is free ++// software; you can redistribute it and/or modify it under the ++// terms of the GNU General Public License as published by the ++// Free Software Foundation; either version 3, or (at your option) ++// any later version. ++ ++// This library is distributed in the hope that it will be useful, ++// but WITHOUT ANY WARRANTY; without even the implied warranty of ++// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++// GNU General Public License for more details. ++ ++// Under Section 7 of GPL version 3, you are granted additional ++// permissions described in the GCC Runtime Library Exception, version ++// 3.1, as published by the Free Software Foundation. ++ ++// You should have received a copy of the GNU General Public License and ++// a copy of the GCC Runtime Library Exception along with this program; ++// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see ++// . ++ ++/** @file bits/c++config.h ++ * This is an internal header file, included by other library headers. ++ * Do not attempt to use it directly. @headername{version} ++ */ ++ ++#ifndef _GLIBCXX_CXX_CONFIG_H ++#define _GLIBCXX_CXX_CONFIG_H 1 ++ ++// The major release number for the GCC release the C++ library belongs to. ++#define _GLIBCXX_RELEASE 13 ++ ++// The datestamp of the C++ library in compressed ISO date format. ++#ifdef __GLIBCXX__ ++#undef __GLIBCXX__ ++#endif ++#define __GLIBCXX__ 20231009 ++ ++// Macros for various attributes. ++// _GLIBCXX_PURE ++// _GLIBCXX_CONST ++// _GLIBCXX_NORETURN ++// _GLIBCXX_NOTHROW ++// _GLIBCXX_VISIBILITY ++#ifndef _GLIBCXX_PURE ++# define _GLIBCXX_PURE __attribute__ ((__pure__)) ++#endif ++ ++#ifndef _GLIBCXX_CONST ++# define _GLIBCXX_CONST __attribute__ ((__const__)) ++#endif ++ ++#ifndef _GLIBCXX_NORETURN ++# define _GLIBCXX_NORETURN __attribute__ ((__noreturn__)) ++#endif ++ ++// See below for C++ ++#ifndef _GLIBCXX_NOTHROW ++# ifndef __cplusplus ++# define _GLIBCXX_NOTHROW __attribute__((__nothrow__)) ++# endif ++#endif ++ ++// Macros for visibility attributes. ++// _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY ++// _GLIBCXX_VISIBILITY ++# define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1 ++ ++#if _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY ++# define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V))) ++#else ++// If this is not supplied by the OS-specific or CPU-specific ++// headers included below, it will be defined to an empty default. ++# define _GLIBCXX_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY(V) ++#endif ++ ++// Macros for deprecated attributes. ++// _GLIBCXX_USE_DEPRECATED ++// _GLIBCXX_DEPRECATED ++// _GLIBCXX_DEPRECATED_SUGGEST( string-literal ) ++// _GLIBCXX11_DEPRECATED ++// _GLIBCXX11_DEPRECATED_SUGGEST( string-literal ) ++// _GLIBCXX14_DEPRECATED ++// _GLIBCXX14_DEPRECATED_SUGGEST( string-literal ) ++// _GLIBCXX17_DEPRECATED ++// _GLIBCXX17_DEPRECATED_SUGGEST( string-literal ) ++// _GLIBCXX20_DEPRECATED ++// _GLIBCXX20_DEPRECATED_SUGGEST( string-literal ) ++// _GLIBCXX23_DEPRECATED ++// _GLIBCXX23_DEPRECATED_SUGGEST( string-literal ) ++#ifndef _GLIBCXX_USE_DEPRECATED ++# define _GLIBCXX_USE_DEPRECATED 1 ++#endif ++ ++#if defined(__DEPRECATED) ++# define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__)) ++# define _GLIBCXX_DEPRECATED_SUGGEST(ALT) \ ++ __attribute__ ((__deprecated__ ("use '" ALT "' instead"))) ++#else ++# define _GLIBCXX_DEPRECATED ++# define _GLIBCXX_DEPRECATED_SUGGEST(ALT) ++#endif ++ ++#if defined(__DEPRECATED) && (__cplusplus >= 201103L) ++# define _GLIBCXX11_DEPRECATED _GLIBCXX_DEPRECATED ++# define _GLIBCXX11_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) ++#else ++# define _GLIBCXX11_DEPRECATED ++# define _GLIBCXX11_DEPRECATED_SUGGEST(ALT) ++#endif ++ ++#if defined(__DEPRECATED) && (__cplusplus >= 201402L) ++# define _GLIBCXX14_DEPRECATED _GLIBCXX_DEPRECATED ++# define _GLIBCXX14_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) ++#else ++# define _GLIBCXX14_DEPRECATED ++# define _GLIBCXX14_DEPRECATED_SUGGEST(ALT) ++#endif ++ ++#if defined(__DEPRECATED) && (__cplusplus >= 201703L) ++# define _GLIBCXX17_DEPRECATED [[__deprecated__]] ++# define _GLIBCXX17_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) ++#else ++# define _GLIBCXX17_DEPRECATED ++# define _GLIBCXX17_DEPRECATED_SUGGEST(ALT) ++#endif ++ ++#if defined(__DEPRECATED) && (__cplusplus >= 202002L) ++# define _GLIBCXX20_DEPRECATED [[__deprecated__]] ++# define _GLIBCXX20_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) ++#else ++# define _GLIBCXX20_DEPRECATED ++# define _GLIBCXX20_DEPRECATED_SUGGEST(ALT) ++#endif ++ ++#if defined(__DEPRECATED) && (__cplusplus >= 202100L) ++# define _GLIBCXX23_DEPRECATED [[__deprecated__]] ++# define _GLIBCXX23_DEPRECATED_SUGGEST(ALT) _GLIBCXX_DEPRECATED_SUGGEST(ALT) ++#else ++# define _GLIBCXX23_DEPRECATED ++# define _GLIBCXX23_DEPRECATED_SUGGEST(ALT) ++#endif ++ ++// Macros for ABI tag attributes. ++#ifndef _GLIBCXX_ABI_TAG_CXX11 ++# define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11"))) ++#endif ++ ++// Macro to warn about unused results. ++#if __cplusplus >= 201703L ++# define _GLIBCXX_NODISCARD [[__nodiscard__]] ++#else ++# define _GLIBCXX_NODISCARD ++#endif ++ ++ ++ ++#if __cplusplus ++ ++// Macro for constexpr, to support in mixed 03/0x mode. ++#ifndef _GLIBCXX_CONSTEXPR ++# if __cplusplus >= 201103L ++# define _GLIBCXX_CONSTEXPR constexpr ++# define _GLIBCXX_USE_CONSTEXPR constexpr ++# else ++# define _GLIBCXX_CONSTEXPR ++# define _GLIBCXX_USE_CONSTEXPR const ++# endif ++#endif ++ ++#ifndef _GLIBCXX14_CONSTEXPR ++# if __cplusplus >= 201402L ++# define _GLIBCXX14_CONSTEXPR constexpr ++# else ++# define _GLIBCXX14_CONSTEXPR ++# endif ++#endif ++ ++#ifndef _GLIBCXX17_CONSTEXPR ++# if __cplusplus >= 201703L ++# define _GLIBCXX17_CONSTEXPR constexpr ++# else ++# define _GLIBCXX17_CONSTEXPR ++# endif ++#endif ++ ++#ifndef _GLIBCXX20_CONSTEXPR ++# if __cplusplus >= 202002L ++# define _GLIBCXX20_CONSTEXPR constexpr ++# else ++# define _GLIBCXX20_CONSTEXPR ++# endif ++#endif ++ ++#ifndef _GLIBCXX23_CONSTEXPR ++# if __cplusplus >= 202100L ++# define _GLIBCXX23_CONSTEXPR constexpr ++# else ++# define _GLIBCXX23_CONSTEXPR ++# endif ++#endif ++ ++#ifndef _GLIBCXX17_INLINE ++# if __cplusplus >= 201703L ++# define _GLIBCXX17_INLINE inline ++# else ++# define _GLIBCXX17_INLINE ++# endif ++#endif ++ ++// Macro for noexcept, to support in mixed 03/0x mode. ++#ifndef _GLIBCXX_NOEXCEPT ++# if __cplusplus >= 201103L ++# define _GLIBCXX_NOEXCEPT noexcept ++# define _GLIBCXX_NOEXCEPT_IF(...) noexcept(__VA_ARGS__) ++# define _GLIBCXX_USE_NOEXCEPT noexcept ++# define _GLIBCXX_THROW(_EXC) ++# else ++# define _GLIBCXX_NOEXCEPT ++# define _GLIBCXX_NOEXCEPT_IF(...) ++# define _GLIBCXX_USE_NOEXCEPT throw() ++# define _GLIBCXX_THROW(_EXC) throw(_EXC) ++# endif ++#endif ++ ++#ifndef _GLIBCXX_NOTHROW ++# define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT ++#endif ++ ++#ifndef _GLIBCXX_THROW_OR_ABORT ++# if __cpp_exceptions ++# define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC)) ++# else ++# define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort()) ++# endif ++#endif ++ ++#if __cpp_noexcept_function_type ++#define _GLIBCXX_NOEXCEPT_PARM , bool _NE ++#define _GLIBCXX_NOEXCEPT_QUAL noexcept (_NE) ++#else ++#define _GLIBCXX_NOEXCEPT_PARM ++#define _GLIBCXX_NOEXCEPT_QUAL ++#endif ++ ++// Macro for extern template, ie controlling template linkage via use ++// of extern keyword on template declaration. As documented in the g++ ++// manual, it inhibits all implicit instantiations and is used ++// throughout the library to avoid multiple weak definitions for ++// required types that are already explicitly instantiated in the ++// library binary. This substantially reduces the binary size of ++// resulting executables. ++// Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern ++// templates only in basic_string, thus activating its debug-mode ++// checks even at -O0. ++# define _GLIBCXX_EXTERN_TEMPLATE 1 ++ ++/* ++ Outline of libstdc++ namespaces. ++ ++ namespace std ++ { ++ namespace __debug { } ++ namespace __parallel { } ++ namespace __cxx1998 { } ++ ++ namespace __detail { ++ namespace __variant { } // C++17 ++ } ++ ++ namespace rel_ops { } ++ ++ namespace tr1 ++ { ++ namespace placeholders { } ++ namespace regex_constants { } ++ namespace __detail { } ++ } ++ ++ namespace tr2 { } ++ ++ namespace decimal { } ++ ++ namespace chrono { } // C++11 ++ namespace placeholders { } // C++11 ++ namespace regex_constants { } // C++11 ++ namespace this_thread { } // C++11 ++ inline namespace literals { // C++14 ++ inline namespace chrono_literals { } // C++14 ++ inline namespace complex_literals { } // C++14 ++ inline namespace string_literals { } // C++14 ++ inline namespace string_view_literals { } // C++17 ++ } ++ } ++ ++ namespace abi { } ++ ++ namespace __gnu_cxx ++ { ++ namespace __detail { } ++ } ++ ++ For full details see: ++ http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html ++*/ ++namespace std ++{ ++ typedef __SIZE_TYPE__ size_t; ++ typedef __PTRDIFF_TYPE__ ptrdiff_t; ++ ++#if __cplusplus >= 201103L ++ typedef decltype(nullptr) nullptr_t; ++#endif ++ ++#pragma GCC visibility push(default) ++ // This allows the library to terminate without including all of ++ // and without making the declaration of std::terminate visible to users. ++ extern "C++" __attribute__ ((__noreturn__, __always_inline__)) ++ inline void __terminate() _GLIBCXX_USE_NOEXCEPT ++ { ++ void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__)); ++ terminate(); ++ } ++#pragma GCC visibility pop ++} ++ ++# define _GLIBCXX_USE_DUAL_ABI 1 ++ ++#if ! _GLIBCXX_USE_DUAL_ABI ++// Ignore any pre-defined value of _GLIBCXX_USE_CXX11_ABI ++# undef _GLIBCXX_USE_CXX11_ABI ++#endif ++ ++#ifndef _GLIBCXX_USE_CXX11_ABI ++# define _GLIBCXX_USE_CXX11_ABI 1 ++#endif ++ ++#if _GLIBCXX_USE_CXX11_ABI ++namespace std ++{ ++ inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } ++} ++namespace __gnu_cxx ++{ ++ inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } ++} ++# define _GLIBCXX_NAMESPACE_CXX11 __cxx11:: ++# define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 { ++# define _GLIBCXX_END_NAMESPACE_CXX11 } ++# define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11 ++#else ++# define _GLIBCXX_NAMESPACE_CXX11 ++# define _GLIBCXX_BEGIN_NAMESPACE_CXX11 ++# define _GLIBCXX_END_NAMESPACE_CXX11 ++# define _GLIBCXX_DEFAULT_ABI_TAG ++#endif ++ ++// Non-zero if inline namespaces are used for versioning the entire library. ++# define _GLIBCXX_INLINE_VERSION 0 ++ ++#if _GLIBCXX_INLINE_VERSION ++// Inline namespace for symbol versioning of (nearly) everything in std. ++# define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __8 { ++# define _GLIBCXX_END_NAMESPACE_VERSION } ++// Unused when everything in std is versioned anyway. ++# define _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(X) ++# define _GLIBCXX_END_INLINE_ABI_NAMESPACE(X) ++ ++namespace std ++{ ++inline _GLIBCXX_BEGIN_NAMESPACE_VERSION ++#if __cplusplus >= 201402L ++ inline namespace literals { ++ inline namespace chrono_literals { } ++ inline namespace complex_literals { } ++ inline namespace string_literals { } ++#if __cplusplus > 201402L ++ inline namespace string_view_literals { } ++#endif // C++17 ++ } ++#endif // C++14 ++_GLIBCXX_END_NAMESPACE_VERSION ++} ++ ++namespace __gnu_cxx ++{ ++inline _GLIBCXX_BEGIN_NAMESPACE_VERSION ++_GLIBCXX_END_NAMESPACE_VERSION ++} ++ ++#else ++// Unused. ++# define _GLIBCXX_BEGIN_NAMESPACE_VERSION ++# define _GLIBCXX_END_NAMESPACE_VERSION ++// Used to version individual components, e.g. std::_V2::error_category. ++# define _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(X) inline namespace X { ++# define _GLIBCXX_END_INLINE_ABI_NAMESPACE(X) } // inline namespace X ++#endif ++ ++// In the case that we don't have a hosted environment, we can't provide the ++// debugging mode. Instead, we do our best and downgrade to assertions. ++#if defined(_GLIBCXX_DEBUG) && !__STDC_HOSTED__ ++#undef _GLIBCXX_DEBUG ++#define _GLIBCXX_ASSERTIONS 1 ++#endif ++ ++// Inline namespaces for special modes: debug, parallel. ++#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) ++namespace std ++{ ++_GLIBCXX_BEGIN_NAMESPACE_VERSION ++ ++ // Non-inline namespace for components replaced by alternates in active mode. ++ namespace __cxx1998 ++ { ++# if _GLIBCXX_USE_CXX11_ABI ++ inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } ++# endif ++ } ++ ++_GLIBCXX_END_NAMESPACE_VERSION ++ ++ // Inline namespace for debug mode. ++# ifdef _GLIBCXX_DEBUG ++ inline namespace __debug { } ++# endif ++ ++ // Inline namespaces for parallel mode. ++# ifdef _GLIBCXX_PARALLEL ++ inline namespace __parallel { } ++# endif ++} ++ ++// Check for invalid usage and unsupported mixed-mode use. ++# if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL) ++# error illegal use of multiple inlined namespaces ++# endif ++ ++// Check for invalid use due to lack for weak symbols. ++# if __NO_INLINE__ && !__GXX_WEAK__ ++# warning currently using inlined namespace mode which may fail \ ++ without inlining due to lack of weak symbols ++# endif ++#endif ++ ++// Macros for namespace scope. Either namespace std:: or the name ++// of some nested namespace within it corresponding to the active mode. ++// _GLIBCXX_STD_A ++// _GLIBCXX_STD_C ++// ++// Macros for opening/closing conditional namespaces. ++// _GLIBCXX_BEGIN_NAMESPACE_ALGO ++// _GLIBCXX_END_NAMESPACE_ALGO ++// _GLIBCXX_BEGIN_NAMESPACE_CONTAINER ++// _GLIBCXX_END_NAMESPACE_CONTAINER ++#if defined(_GLIBCXX_DEBUG) ++# define _GLIBCXX_STD_C __cxx1998 ++# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \ ++ namespace _GLIBCXX_STD_C { ++# define _GLIBCXX_END_NAMESPACE_CONTAINER } ++#else ++# define _GLIBCXX_STD_C std ++# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER ++# define _GLIBCXX_END_NAMESPACE_CONTAINER ++#endif ++ ++#ifdef _GLIBCXX_PARALLEL ++# define _GLIBCXX_STD_A __cxx1998 ++# define _GLIBCXX_BEGIN_NAMESPACE_ALGO \ ++ namespace _GLIBCXX_STD_A { ++# define _GLIBCXX_END_NAMESPACE_ALGO } ++#else ++# define _GLIBCXX_STD_A std ++# define _GLIBCXX_BEGIN_NAMESPACE_ALGO ++# define _GLIBCXX_END_NAMESPACE_ALGO ++#endif ++ ++// GLIBCXX_ABI Deprecated ++// Define if compatibility should be provided for -mlong-double-64. ++#undef _GLIBCXX_LONG_DOUBLE_COMPAT ++ ++// Define if compatibility should be provided for alternative 128-bit long ++// double formats. Not possible for Clang until __ibm128 is supported. ++#ifndef __clang__ ++#undef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT ++#endif ++ ++// Inline namespaces for long double 128 modes. ++#if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT \ ++ && defined __LONG_DOUBLE_IEEE128__ ++namespace std ++{ ++ // Namespaces for 128-bit IEEE long double format on 64-bit POWER LE. ++ inline namespace __gnu_cxx_ieee128 { } ++ inline namespace __gnu_cxx11_ieee128 { } ++} ++# define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ieee128:: ++# define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ieee128 { ++# define _GLIBCXX_END_NAMESPACE_LDBL } ++# define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 __gnu_cxx11_ieee128:: ++# define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 namespace __gnu_cxx11_ieee128 { ++# define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 } ++ ++#else // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && IEEE128 ++ ++#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ ++namespace std ++{ ++ inline namespace __gnu_cxx_ldbl128 { } ++} ++# define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128:: ++# define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 { ++# define _GLIBCXX_END_NAMESPACE_LDBL } ++#else ++# define _GLIBCXX_NAMESPACE_LDBL ++# define _GLIBCXX_BEGIN_NAMESPACE_LDBL ++# define _GLIBCXX_END_NAMESPACE_LDBL ++#endif ++ ++#if _GLIBCXX_USE_CXX11_ABI ++# define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11 ++# define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11 ++# define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11 ++#else ++# define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_LDBL ++# define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_LDBL ++# define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL ++#endif ++ ++#endif // _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT && IEEE128 ++ ++namespace std ++{ ++#pragma GCC visibility push(default) ++ // Internal version of std::is_constant_evaluated(). ++ // This can be used without checking if the compiler supports the feature. ++ // The macro _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED can be used to check if ++ // the compiler support is present to make this function work as expected. ++ _GLIBCXX_CONSTEXPR inline bool ++ __is_constant_evaluated() _GLIBCXX_NOEXCEPT ++ { ++#if __cpp_if_consteval >= 202106L ++# define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1 ++ if consteval { return true; } else { return false; } ++#elif __cplusplus >= 201103L && __has_builtin(__builtin_is_constant_evaluated) ++# define _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 1 ++ return __builtin_is_constant_evaluated(); ++#else ++ return false; ++#endif ++ } ++#pragma GCC visibility pop ++} ++ ++// Debug Mode implies checking assertions. ++#if defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_ASSERTIONS) ++# define _GLIBCXX_ASSERTIONS 1 ++#endif ++ ++// Disable std::string explicit instantiation declarations in order to assert. ++#ifdef _GLIBCXX_ASSERTIONS ++# undef _GLIBCXX_EXTERN_TEMPLATE ++# define _GLIBCXX_EXTERN_TEMPLATE -1 ++#endif ++ ++ ++#if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED ++# define __glibcxx_constexpr_assert(cond) \ ++ if (std::__is_constant_evaluated() && !bool(cond)) \ ++ __builtin_unreachable() /* precondition violation detected! */ ++#else ++# define __glibcxx_constexpr_assert(unevaluated) ++#endif ++ ++#define _GLIBCXX_VERBOSE_ASSERT 1 ++ ++// Assert. ++#if defined(_GLIBCXX_ASSERTIONS) \ ++ || defined(_GLIBCXX_PARALLEL) || defined(_GLIBCXX_PARALLEL_ASSERTIONS) ++# ifdef _GLIBCXX_VERBOSE_ASSERT ++namespace std ++{ ++#pragma GCC visibility push(default) ++ // Avoid the use of assert, because we're trying to keep the ++ // include out of the mix. ++ extern "C++" _GLIBCXX_NORETURN ++ void ++ __glibcxx_assert_fail(const char* __file, int __line, ++ const char* __function, const char* __condition) ++ _GLIBCXX_NOEXCEPT; ++#pragma GCC visibility pop ++} ++#define __glibcxx_assert_impl(_Condition) \ ++ if (__builtin_expect(!bool(_Condition), false)) \ ++ { \ ++ __glibcxx_constexpr_assert(false); \ ++ std::__glibcxx_assert_fail(__FILE__, __LINE__, __PRETTY_FUNCTION__, \ ++ #_Condition); \ ++ } ++# else // ! VERBOSE_ASSERT ++# define __glibcxx_assert_impl(_Condition) \ ++ if (__builtin_expect(!bool(_Condition), false)) \ ++ { \ ++ __glibcxx_constexpr_assert(false); \ ++ __builtin_abort(); \ ++ } ++# endif ++#endif ++ ++#if defined(_GLIBCXX_ASSERTIONS) ++# define __glibcxx_assert(cond) \ ++ do { __glibcxx_assert_impl(cond); } while (false) ++#else ++# define __glibcxx_assert(cond) \ ++ do { __glibcxx_constexpr_assert(cond); } while (false) ++#endif ++ ++// Macro indicating that TSAN is in use. ++#if __SANITIZE_THREAD__ ++# define _GLIBCXX_TSAN 1 ++#elif defined __has_feature ++# if __has_feature(thread_sanitizer) ++# define _GLIBCXX_TSAN 1 ++# endif ++#endif ++ ++// Macros for race detectors. ++// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and ++// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain ++// atomic (lock-free) synchronization to race detectors: ++// the race detector will infer a happens-before arc from the former to the ++// latter when they share the same argument pointer. ++// ++// The most frequent use case for these macros (and the only case in the ++// current implementation of the library) is atomic reference counting: ++// void _M_remove_reference() ++// { ++// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount); ++// if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) ++// { ++// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount); ++// _M_destroy(__a); ++// } ++// } ++// The annotations in this example tell the race detector that all memory ++// accesses occurred when the refcount was positive do not race with ++// memory accesses which occurred after the refcount became zero. ++#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE ++# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) ++#endif ++#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER ++# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) ++#endif ++ ++// Macros for C linkage: define extern "C" linkage only when using C++. ++# define _GLIBCXX_BEGIN_EXTERN_C extern "C" { ++# define _GLIBCXX_END_EXTERN_C } ++ ++# define _GLIBCXX_USE_ALLOCATOR_NEW 1 ++ ++#ifdef __SIZEOF_INT128__ ++#if ! defined __GLIBCXX_TYPE_INT_N_0 && ! defined __STRICT_ANSI__ ++// If __int128 is supported, we expect __GLIBCXX_TYPE_INT_N_0 to be defined ++// unless the compiler is in strict mode. If it's not defined and the strict ++// macro is not defined, something is wrong. ++#warning "__STRICT_ANSI__ seems to have been undefined; this is not supported" ++#endif ++#endif ++ ++#else // !__cplusplus ++# define _GLIBCXX_BEGIN_EXTERN_C ++# define _GLIBCXX_END_EXTERN_C ++#endif ++ ++ ++// First includes. ++ ++// Pick up any OS-specific definitions. ++#include ++ ++// Pick up any CPU-specific definitions. ++#include ++ ++// If platform uses neither visibility nor psuedo-visibility, ++// specify empty default for namespace annotation macros. ++#ifndef _GLIBCXX_PSEUDO_VISIBILITY ++# define _GLIBCXX_PSEUDO_VISIBILITY(V) ++#endif ++ ++// Certain function definitions that are meant to be overridable from ++// user code are decorated with this macro. For some targets, this ++// macro causes these definitions to be weak. ++#ifndef _GLIBCXX_WEAK_DEFINITION ++# define _GLIBCXX_WEAK_DEFINITION ++#endif ++ ++// By default, we assume that __GXX_WEAK__ also means that there is support ++// for declaring functions as weak while not defining such functions. This ++// allows for referring to functions provided by other libraries (e.g., ++// libitm) without depending on them if the respective features are not used. ++#ifndef _GLIBCXX_USE_WEAK_REF ++# define _GLIBCXX_USE_WEAK_REF __GXX_WEAK__ ++#endif ++ ++// Conditionally enable annotations for the Transactional Memory TS on C++11. ++// Most of the following conditions are due to limitations in the current ++// implementation. ++#if __cplusplus >= 201103L && _GLIBCXX_USE_CXX11_ABI \ ++ && _GLIBCXX_USE_DUAL_ABI && __cpp_transactional_memory >= 201500L \ ++ && !_GLIBCXX_FULLY_DYNAMIC_STRING && _GLIBCXX_USE_WEAK_REF \ ++ && _GLIBCXX_USE_ALLOCATOR_NEW ++#define _GLIBCXX_TXN_SAFE transaction_safe ++#define _GLIBCXX_TXN_SAFE_DYN transaction_safe_dynamic ++#else ++#define _GLIBCXX_TXN_SAFE ++#define _GLIBCXX_TXN_SAFE_DYN ++#endif ++ ++#if __cplusplus > 201402L ++// In C++17 mathematical special functions are in namespace std. ++# define _GLIBCXX_USE_STD_SPEC_FUNCS 1 ++#elif __cplusplus >= 201103L && __STDCPP_WANT_MATH_SPEC_FUNCS__ != 0 ++// For C++11 and C++14 they are in namespace std when requested. ++# define _GLIBCXX_USE_STD_SPEC_FUNCS 1 ++#endif ++ ++// The remainder of the prewritten config is automatic; all the ++// user hooks are listed above. ++ ++// Create a boolean flag to be used to determine if --fast-math is set. ++#ifdef __FAST_MATH__ ++# define _GLIBCXX_FAST_MATH 1 ++#else ++# define _GLIBCXX_FAST_MATH 0 ++#endif ++ ++// This marks string literals in header files to be extracted for eventual ++// translation. It is primarily used for messages in thrown exceptions; see ++// src/functexcept.cc. We use __N because the more traditional _N is used ++// for something else under certain OSes (see BADNAMES). ++#define __N(msgid) (msgid) ++ ++// For example, is known to #define min and max as macros... ++#undef min ++#undef max ++ ++// N.B. these _GLIBCXX_USE_C99_XXX macros are defined unconditionally ++// so they should be tested with #if not with #ifdef. ++#if __cplusplus >= 201103L ++# ifndef _GLIBCXX_USE_C99_MATH ++# define _GLIBCXX_USE_C99_MATH _GLIBCXX11_USE_C99_MATH ++# endif ++# ifndef _GLIBCXX_USE_C99_COMPLEX ++# define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX11_USE_C99_COMPLEX ++# endif ++# ifndef _GLIBCXX_USE_C99_STDIO ++# define _GLIBCXX_USE_C99_STDIO _GLIBCXX11_USE_C99_STDIO ++# endif ++# ifndef _GLIBCXX_USE_C99_STDLIB ++# define _GLIBCXX_USE_C99_STDLIB _GLIBCXX11_USE_C99_STDLIB ++# endif ++# ifndef _GLIBCXX_USE_C99_WCHAR ++# define _GLIBCXX_USE_C99_WCHAR _GLIBCXX11_USE_C99_WCHAR ++# endif ++#else ++# ifndef _GLIBCXX_USE_C99_MATH ++# define _GLIBCXX_USE_C99_MATH _GLIBCXX98_USE_C99_MATH ++# endif ++# ifndef _GLIBCXX_USE_C99_COMPLEX ++# define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX98_USE_C99_COMPLEX ++# endif ++# ifndef _GLIBCXX_USE_C99_STDIO ++# define _GLIBCXX_USE_C99_STDIO _GLIBCXX98_USE_C99_STDIO ++# endif ++# ifndef _GLIBCXX_USE_C99_STDLIB ++# define _GLIBCXX_USE_C99_STDLIB _GLIBCXX98_USE_C99_STDLIB ++# endif ++# ifndef _GLIBCXX_USE_C99_WCHAR ++# define _GLIBCXX_USE_C99_WCHAR _GLIBCXX98_USE_C99_WCHAR ++# endif ++#endif ++ ++// Unless explicitly specified, enable char8_t extensions only if the core ++// language char8_t feature macro is defined. ++#ifndef _GLIBCXX_USE_CHAR8_T ++# ifdef __cpp_char8_t ++# define _GLIBCXX_USE_CHAR8_T 1 ++# endif ++#endif ++#ifdef _GLIBCXX_USE_CHAR8_T ++# define __cpp_lib_char8_t 201907L ++#endif ++ ++/* Define if __float128 is supported on this host. */ ++#if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__) ++/* For powerpc64 don't use __float128 when it's the same type as long double. */ ++# if !(defined(_GLIBCXX_LONG_DOUBLE_ALT128_COMPAT) && defined(__LONG_DOUBLE_IEEE128__)) ++# define _GLIBCXX_USE_FLOAT128 1 ++# endif ++#endif ++ ++// Define if float has the IEEE binary32 format. ++#if __FLT_MANT_DIG__ == 24 \ ++ && __FLT_MIN_EXP__ == -125 \ ++ && __FLT_MAX_EXP__ == 128 ++# define _GLIBCXX_FLOAT_IS_IEEE_BINARY32 1 ++#endif ++ ++// Define if double has the IEEE binary64 format. ++#if __DBL_MANT_DIG__ == 53 \ ++ && __DBL_MIN_EXP__ == -1021 \ ++ && __DBL_MAX_EXP__ == 1024 ++# define _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 1 ++#endif ++ ++// Define if long double has the IEEE binary128 format. ++#if __LDBL_MANT_DIG__ == 113 \ ++ && __LDBL_MIN_EXP__ == -16381 \ ++ && __LDBL_MAX_EXP__ == 16384 ++# define _GLIBCXX_LDOUBLE_IS_IEEE_BINARY128 1 ++#endif ++ ++#ifdef __STDCPP_BFLOAT16_T__ ++namespace __gnu_cxx ++{ ++ using __bfloat16_t = decltype(0.0bf16); ++} ++#endif ++ ++#ifdef __has_builtin ++# ifdef __is_identifier ++// Intel and older Clang require !__is_identifier for some built-ins: ++# define _GLIBCXX_HAS_BUILTIN(B) __has_builtin(B) || ! __is_identifier(B) ++# else ++# define _GLIBCXX_HAS_BUILTIN(B) __has_builtin(B) ++# endif ++#endif ++ ++#if _GLIBCXX_HAS_BUILTIN(__has_unique_object_representations) ++# define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1 ++#endif ++ ++#if _GLIBCXX_HAS_BUILTIN(__is_aggregate) ++# define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1 ++#endif ++ ++#if _GLIBCXX_HAS_BUILTIN(__is_same) ++# define _GLIBCXX_HAVE_BUILTIN_IS_SAME 1 ++#endif ++ ++#if _GLIBCXX_HAS_BUILTIN(__builtin_launder) ++# define _GLIBCXX_HAVE_BUILTIN_LAUNDER 1 ++#endif ++ ++#undef _GLIBCXX_HAS_BUILTIN ++#define _GLIBCXX_USE_BUILTIN_TRAIT(BT) 0 ++ ++// Mark code that should be ignored by the compiler, but seen by Doxygen. ++#define _GLIBCXX_DOXYGEN_ONLY(X) ++ ++// PSTL configuration ++ ++#if __cplusplus >= 201703L ++// This header is not installed for freestanding: ++#if __has_include() ++// Preserved here so we have some idea which version of upstream we've pulled in ++// #define PSTL_VERSION 9000 ++ ++// For now this defaults to being based on the presence of Thread Building Blocks ++# ifndef _GLIBCXX_USE_TBB_PAR_BACKEND ++# define _GLIBCXX_USE_TBB_PAR_BACKEND __has_include() ++# endif ++// This section will need some rework when a new (default) backend type is added ++# if _GLIBCXX_USE_TBB_PAR_BACKEND ++# define _PSTL_PAR_BACKEND_TBB ++# else ++# define _PSTL_PAR_BACKEND_SERIAL ++# endif ++ ++# define _PSTL_ASSERT(_Condition) __glibcxx_assert(_Condition) ++# define _PSTL_ASSERT_MSG(_Condition, _Message) __glibcxx_assert(_Condition) ++ ++#include ++#endif // __has_include ++#endif // C++17 ++ ++// End of prewritten config; the settings discovered at configure time follow. ++/* config.h. Generated from config.h.in by configure. */ ++/* config.h.in. Generated from configure.ac by autoheader. */ ++ ++/* Define to 1 if you have the `acosf' function. */ ++#define _GLIBCXX_HAVE_ACOSF 1 ++ ++/* Define to 1 if you have the `acosl' function. */ ++/* #undef _GLIBCXX_HAVE_ACOSL */ ++ ++/* Define to 1 if you have the `aligned_alloc' function. */ ++/* #undef _GLIBCXX_HAVE_ALIGNED_ALLOC */ ++ ++/* Define if arc4random is available in . */ ++/* #undef _GLIBCXX_HAVE_ARC4RANDOM */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_ARPA_INET_H */ ++ ++/* Define to 1 if you have the `asinf' function. */ ++#define _GLIBCXX_HAVE_ASINF 1 ++ ++/* Define to 1 if you have the `asinl' function. */ ++/* #undef _GLIBCXX_HAVE_ASINL */ ++ ++/* Define to 1 if the target assembler supports .symver directive. */ ++#define _GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE 1 ++ ++/* Define to 1 if you have the `atan2f' function. */ ++#define _GLIBCXX_HAVE_ATAN2F 1 ++ ++/* Define to 1 if you have the `atan2l' function. */ ++/* #undef _GLIBCXX_HAVE_ATAN2L */ ++ ++/* Define to 1 if you have the `atanf' function. */ ++#define _GLIBCXX_HAVE_ATANF 1 ++ ++/* Define to 1 if you have the `atanl' function. */ ++/* #undef _GLIBCXX_HAVE_ATANL */ ++ ++/* Defined if shared_ptr reference counting should use atomic operations. */ ++#define _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY 1 ++ ++/* Define to 1 if you have the `at_quick_exit' function. */ ++/* #undef _GLIBCXX_HAVE_AT_QUICK_EXIT */ ++ ++/* Define to 1 if the target assembler supports thread-local storage. */ ++/* #undef _GLIBCXX_HAVE_CC_TLS */ ++ ++/* Define to 1 if you have the `ceilf' function. */ ++#define _GLIBCXX_HAVE_CEILF 1 ++ ++/* Define to 1 if you have the `ceill' function. */ ++/* #undef _GLIBCXX_HAVE_CEILL */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_COMPLEX_H 1 ++ ++/* Define to 1 if you have the `cosf' function. */ ++#define _GLIBCXX_HAVE_COSF 1 ++ ++/* Define to 1 if you have the `coshf' function. */ ++#define _GLIBCXX_HAVE_COSHF 1 ++ ++/* Define to 1 if you have the `coshl' function. */ ++/* #undef _GLIBCXX_HAVE_COSHL */ ++ ++/* Define to 1 if you have the `cosl' function. */ ++/* #undef _GLIBCXX_HAVE_COSL */ ++ ++/* Define to 1 if you have the declaration of `strnlen', and to 0 if you ++ don't. */ ++#define _GLIBCXX_HAVE_DECL_STRNLEN 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_DIRENT_H */ ++ ++/* Define if dirfd is available in . */ ++/* #undef _GLIBCXX_HAVE_DIRFD */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_DLFCN_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_ENDIAN_H */ ++ ++/* Define to 1 if GCC 4.6 supported std::exception_ptr for the target */ ++/* #undef _GLIBCXX_HAVE_EXCEPTION_PTR_SINCE_GCC46 */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_EXECINFO_H */ ++ ++/* Define to 1 if you have the `expf' function. */ ++#define _GLIBCXX_HAVE_EXPF 1 ++ ++/* Define to 1 if you have the `expl' function. */ ++/* #undef _GLIBCXX_HAVE_EXPL */ ++ ++/* Define to 1 if you have the `fabsf' function. */ ++#define _GLIBCXX_HAVE_FABSF 1 ++ ++/* Define to 1 if you have the `fabsl' function. */ ++/* #undef _GLIBCXX_HAVE_FABSL */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_FCNTL_H 1 ++ ++/* Define if fdopendir is available in . */ ++/* #undef _GLIBCXX_HAVE_FDOPENDIR */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_FENV_H 1 ++ ++/* Define to 1 if you have the `finite' function. */ ++/* #undef _GLIBCXX_HAVE_FINITE */ ++ ++/* Define to 1 if you have the `finitef' function. */ ++/* #undef _GLIBCXX_HAVE_FINITEF */ ++ ++/* Define to 1 if you have the `finitel' function. */ ++/* #undef _GLIBCXX_HAVE_FINITEL */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_FLOAT_H 1 ++ ++/* Define to 1 if you have the `floorf' function. */ ++#define _GLIBCXX_HAVE_FLOORF 1 ++ ++/* Define to 1 if you have the `floorl' function. */ ++/* #undef _GLIBCXX_HAVE_FLOORL */ ++ ++/* Define to 1 if you have the `fmodf' function. */ ++#define _GLIBCXX_HAVE_FMODF 1 ++ ++/* Define to 1 if you have the `fmodl' function. */ ++/* #undef _GLIBCXX_HAVE_FMODL */ ++ ++/* Define to 1 if you have the `fpclass' function. */ ++/* #undef _GLIBCXX_HAVE_FPCLASS */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_FP_H */ ++ ++/* Define to 1 if you have the `frexpf' function. */ ++#define _GLIBCXX_HAVE_FREXPF 1 ++ ++/* Define to 1 if you have the `frexpl' function. */ ++/* #undef _GLIBCXX_HAVE_FREXPL */ ++ ++/* Define if getentropy is available in . */ ++/* #undef _GLIBCXX_HAVE_GETENTROPY */ ++ ++/* Define if _Unwind_GetIPInfo is available. */ ++#define _GLIBCXX_HAVE_GETIPINFO 1 ++ ++/* Define if gets is available in before C++14. */ ++#define _GLIBCXX_HAVE_GETS 1 ++ ++/* Define to 1 if you have the `hypot' function. */ ++#define _GLIBCXX_HAVE_HYPOT 1 ++ ++/* Define to 1 if you have the `hypotf' function. */ ++/* #undef _GLIBCXX_HAVE_HYPOTF */ ++ ++/* Define to 1 if you have the `hypotl' function. */ ++/* #undef _GLIBCXX_HAVE_HYPOTL */ ++ ++/* Define if you have the iconv() function. */ ++#define _GLIBCXX_HAVE_ICONV 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_IEEEFP_H */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_INTTYPES_H 1 ++ ++/* Define to 1 if you have the `isinf' function. */ ++/* #undef _GLIBCXX_HAVE_ISINF */ ++ ++/* Define to 1 if you have the `isinff' function. */ ++/* #undef _GLIBCXX_HAVE_ISINFF */ ++ ++/* Define to 1 if you have the `isinfl' function. */ ++/* #undef _GLIBCXX_HAVE_ISINFL */ ++ ++/* Define to 1 if you have the `isnan' function. */ ++/* #undef _GLIBCXX_HAVE_ISNAN */ ++ ++/* Define to 1 if you have the `isnanf' function. */ ++/* #undef _GLIBCXX_HAVE_ISNANF */ ++ ++/* Define to 1 if you have the `isnanl' function. */ ++/* #undef _GLIBCXX_HAVE_ISNANL */ ++ ++/* Defined if iswblank exists. */ ++#define _GLIBCXX_HAVE_ISWBLANK 1 ++ ++/* Define if LC_MESSAGES is available in . */ ++#define _GLIBCXX_HAVE_LC_MESSAGES 1 ++ ++/* Define to 1 if you have the `ldexpf' function. */ ++#define _GLIBCXX_HAVE_LDEXPF 1 ++ ++/* Define to 1 if you have the `ldexpl' function. */ ++/* #undef _GLIBCXX_HAVE_LDEXPL */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_LIBINTL_H */ ++ ++/* Only used in build directory testsuite_hooks.h. */ ++#define _GLIBCXX_HAVE_LIMIT_AS 0 ++ ++/* Only used in build directory testsuite_hooks.h. */ ++#define _GLIBCXX_HAVE_LIMIT_DATA 0 ++ ++/* Only used in build directory testsuite_hooks.h. */ ++#define _GLIBCXX_HAVE_LIMIT_FSIZE 0 ++ ++/* Only used in build directory testsuite_hooks.h. */ ++#define _GLIBCXX_HAVE_LIMIT_RSS 0 ++ ++/* Only used in build directory testsuite_hooks.h. */ ++#define _GLIBCXX_HAVE_LIMIT_VMEM 0 ++ ++/* Define if link is available in . */ ++#define _GLIBCXX_HAVE_LINK 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_LINK_H */ ++ ++/* Define if futex syscall is available. */ ++/* #undef _GLIBCXX_HAVE_LINUX_FUTEX */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_LINUX_RANDOM_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_LINUX_TYPES_H */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_LOCALE_H 1 ++ ++/* Define to 1 if you have the `log10f' function. */ ++#define _GLIBCXX_HAVE_LOG10F 1 ++ ++/* Define to 1 if you have the `log10l' function. */ ++/* #undef _GLIBCXX_HAVE_LOG10L */ ++ ++/* Define to 1 if you have the `logf' function. */ ++#define _GLIBCXX_HAVE_LOGF 1 ++ ++/* Define to 1 if you have the `logl' function. */ ++/* #undef _GLIBCXX_HAVE_LOGL */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_MACHINE_ENDIAN_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_MACHINE_PARAM_H */ ++ ++/* Define if mbstate_t exists in wchar.h. */ ++#define _GLIBCXX_HAVE_MBSTATE_T 1 ++ ++/* Define to 1 if you have the `memalign' function. */ ++#define _GLIBCXX_HAVE_MEMALIGN 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_MEMORY_H 1 ++ ++/* Define to 1 if you have the `modf' function. */ ++/* #undef _GLIBCXX_HAVE_MODF */ ++ ++/* Define to 1 if you have the `modff' function. */ ++#define _GLIBCXX_HAVE_MODFF 1 ++ ++/* Define to 1 if you have the `modfl' function. */ ++/* #undef _GLIBCXX_HAVE_MODFL */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_NAN_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_NETDB_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_NETINET_IN_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_NETINET_TCP_H */ ++ ++/* Define if defines obsolete isinf function. */ ++/* #undef _GLIBCXX_HAVE_OBSOLETE_ISINF */ ++ ++/* Define if defines obsolete isnan function. */ ++/* #undef _GLIBCXX_HAVE_OBSOLETE_ISNAN */ ++ ++/* Define if openat is available in . */ ++/* #undef _GLIBCXX_HAVE_OPENAT */ ++ ++/* Define if poll is available in . */ ++/* #undef _GLIBCXX_HAVE_POLL */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_POLL_H */ ++ ++/* Define to 1 if you have the `posix_memalign' function. */ ++/* #undef _GLIBCXX_HAVE_POSIX_MEMALIGN */ ++ ++/* Define to 1 if POSIX Semaphores with sem_timedwait are available in ++ . */ ++/* #undef _GLIBCXX_HAVE_POSIX_SEMAPHORE */ ++ ++/* Define to 1 if you have the `powf' function. */ ++#define _GLIBCXX_HAVE_POWF 1 ++ ++/* Define to 1 if you have the `powl' function. */ ++/* #undef _GLIBCXX_HAVE_POWL */ ++ ++/* Define to 1 if you have the `qfpclass' function. */ ++/* #undef _GLIBCXX_HAVE_QFPCLASS */ ++ ++/* Define to 1 if you have the `quick_exit' function. */ ++/* #undef _GLIBCXX_HAVE_QUICK_EXIT */ ++ ++/* Define if readlink is available in . */ ++/* #undef _GLIBCXX_HAVE_READLINK */ ++ ++/* Define to 1 if you have the `secure_getenv' function. */ ++/* #undef _GLIBCXX_HAVE_SECURE_GETENV */ ++ ++/* Define to 1 if you have the `setenv' function. */ ++/* #undef _GLIBCXX_HAVE_SETENV */ ++ ++/* Define to 1 if you have the `sincos' function. */ ++/* #undef _GLIBCXX_HAVE_SINCOS */ ++ ++/* Define to 1 if you have the `sincosf' function. */ ++/* #undef _GLIBCXX_HAVE_SINCOSF */ ++ ++/* Define to 1 if you have the `sincosl' function. */ ++/* #undef _GLIBCXX_HAVE_SINCOSL */ ++ ++/* Define to 1 if you have the `sinf' function. */ ++#define _GLIBCXX_HAVE_SINF 1 ++ ++/* Define to 1 if you have the `sinhf' function. */ ++#define _GLIBCXX_HAVE_SINHF 1 ++ ++/* Define to 1 if you have the `sinhl' function. */ ++/* #undef _GLIBCXX_HAVE_SINHL */ ++ ++/* Define to 1 if you have the `sinl' function. */ ++/* #undef _GLIBCXX_HAVE_SINL */ ++ ++/* Defined if sleep exists. */ ++/* #undef _GLIBCXX_HAVE_SLEEP */ ++ ++/* Define to 1 if you have the `sockatmark' function. */ ++/* #undef _GLIBCXX_HAVE_SOCKATMARK */ ++ ++/* Define to 1 if you have the `sqrtf' function. */ ++#define _GLIBCXX_HAVE_SQRTF 1 ++ ++/* Define to 1 if you have the `sqrtl' function. */ ++/* #undef _GLIBCXX_HAVE_SQRTL */ ++ ++/* Define if the header is supported. */ ++/* #undef _GLIBCXX_HAVE_STACKTRACE */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_STDALIGN_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_STDBOOL_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_STDINT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_STDLIB_H 1 ++ ++/* Define if strerror_l is available in . */ ++/* #undef _GLIBCXX_HAVE_STRERROR_L */ ++ ++/* Define if strerror_r is available in . */ ++#define _GLIBCXX_HAVE_STRERROR_R 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_STRINGS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_STRING_H 1 ++ ++/* Define to 1 if you have the `strtof' function. */ ++#define _GLIBCXX_HAVE_STRTOF 1 ++ ++/* Define to 1 if you have the `strtold' function. */ ++/* #undef _GLIBCXX_HAVE_STRTOLD */ ++ ++/* Define to 1 if `d_type' is a member of `struct dirent'. */ ++/* #undef _GLIBCXX_HAVE_STRUCT_DIRENT_D_TYPE */ ++ ++/* Define if strxfrm_l is available in . */ ++/* #undef _GLIBCXX_HAVE_STRXFRM_L */ ++ ++/* Define if symlink is available in . */ ++/* #undef _GLIBCXX_HAVE_SYMLINK */ ++ ++/* Define to 1 if the target runtime linker supports binding the same symbol ++ to different versions. */ ++/* #undef _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_FILIO_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_IOCTL_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_IPC_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_ISA_DEFS_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_MACHINE_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_MMAN_H */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_SYS_PARAM_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_SYS_RESOURCE_H 1 ++ ++/* Define to 1 if you have a suitable header file */ ++/* #undef _GLIBCXX_HAVE_SYS_SDT_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_SEM_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_SOCKET_H */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_STATVFS_H */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_SYS_STAT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_SYSINFO_H */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_SYS_TIME_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_SYS_TYPES_H 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_SYS_UIO_H */ ++ ++/* Define if S_IFREG is available in . */ ++/* #undef _GLIBCXX_HAVE_S_IFREG */ ++ ++/* Define if S_ISREG is available in . */ ++#define _GLIBCXX_HAVE_S_ISREG 1 ++ ++/* Define to 1 if you have the `tanf' function. */ ++#define _GLIBCXX_HAVE_TANF 1 ++ ++/* Define to 1 if you have the `tanhf' function. */ ++#define _GLIBCXX_HAVE_TANHF 1 ++ ++/* Define to 1 if you have the `tanhl' function. */ ++/* #undef _GLIBCXX_HAVE_TANHL */ ++ ++/* Define to 1 if you have the `tanl' function. */ ++/* #undef _GLIBCXX_HAVE_TANL */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_TGMATH_H 1 ++ ++/* Define to 1 if you have the `timespec_get' function. */ ++/* #undef _GLIBCXX_HAVE_TIMESPEC_GET */ ++ ++/* Define to 1 if the target supports thread-local storage. */ ++/* #undef _GLIBCXX_HAVE_TLS */ ++ ++/* Define if truncate is available in . */ ++#define _GLIBCXX_HAVE_TRUNCATE 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_UCHAR_H */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_UNISTD_H 1 ++ ++/* Define if unlinkat is available in . */ ++/* #undef _GLIBCXX_HAVE_UNLINKAT */ ++ ++/* Define to 1 if you have the `uselocale' function. */ ++/* #undef _GLIBCXX_HAVE_USELOCALE */ ++ ++/* Defined if usleep exists. */ ++/* #undef _GLIBCXX_HAVE_USLEEP */ ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_UTIME_H 1 ++ ++/* Defined if vfwscanf exists. */ ++#define _GLIBCXX_HAVE_VFWSCANF 1 ++ ++/* Defined if vswscanf exists. */ ++#define _GLIBCXX_HAVE_VSWSCANF 1 ++ ++/* Defined if vwscanf exists. */ ++#define _GLIBCXX_HAVE_VWSCANF 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_WCHAR_H 1 ++ ++/* Defined if wcstof exists. */ ++#define _GLIBCXX_HAVE_WCSTOF 1 ++ ++/* Define to 1 if you have the header file. */ ++#define _GLIBCXX_HAVE_WCTYPE_H 1 ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_WINDOWS_H */ ++ ++/* Define if writev is available in . */ ++/* #undef _GLIBCXX_HAVE_WRITEV */ ++ ++/* Define to 1 if you have the header file. */ ++/* #undef _GLIBCXX_HAVE_XLOCALE_H */ ++ ++/* Define to 1 if you have the `_acosf' function. */ ++/* #undef _GLIBCXX_HAVE__ACOSF */ ++ ++/* Define to 1 if you have the `_acosl' function. */ ++/* #undef _GLIBCXX_HAVE__ACOSL */ ++ ++/* Define to 1 if you have the `_aligned_malloc' function. */ ++/* #undef _GLIBCXX_HAVE__ALIGNED_MALLOC */ ++ ++/* Define to 1 if you have the `_asinf' function. */ ++/* #undef _GLIBCXX_HAVE__ASINF */ ++ ++/* Define to 1 if you have the `_asinl' function. */ ++/* #undef _GLIBCXX_HAVE__ASINL */ ++ ++/* Define to 1 if you have the `_atan2f' function. */ ++/* #undef _GLIBCXX_HAVE__ATAN2F */ ++ ++/* Define to 1 if you have the `_atan2l' function. */ ++/* #undef _GLIBCXX_HAVE__ATAN2L */ ++ ++/* Define to 1 if you have the `_atanf' function. */ ++/* #undef _GLIBCXX_HAVE__ATANF */ ++ ++/* Define to 1 if you have the `_atanl' function. */ ++/* #undef _GLIBCXX_HAVE__ATANL */ ++ ++/* Define to 1 if you have the `_ceilf' function. */ ++/* #undef _GLIBCXX_HAVE__CEILF */ ++ ++/* Define to 1 if you have the `_ceill' function. */ ++/* #undef _GLIBCXX_HAVE__CEILL */ ++ ++/* Define to 1 if you have the `_cosf' function. */ ++/* #undef _GLIBCXX_HAVE__COSF */ ++ ++/* Define to 1 if you have the `_coshf' function. */ ++/* #undef _GLIBCXX_HAVE__COSHF */ ++ ++/* Define to 1 if you have the `_coshl' function. */ ++/* #undef _GLIBCXX_HAVE__COSHL */ ++ ++/* Define to 1 if you have the `_cosl' function. */ ++/* #undef _GLIBCXX_HAVE__COSL */ ++ ++/* Define to 1 if you have the `_expf' function. */ ++/* #undef _GLIBCXX_HAVE__EXPF */ ++ ++/* Define to 1 if you have the `_expl' function. */ ++/* #undef _GLIBCXX_HAVE__EXPL */ ++ ++/* Define to 1 if you have the `_fabsf' function. */ ++/* #undef _GLIBCXX_HAVE__FABSF */ ++ ++/* Define to 1 if you have the `_fabsl' function. */ ++/* #undef _GLIBCXX_HAVE__FABSL */ ++ ++/* Define to 1 if you have the `_finite' function. */ ++/* #undef _GLIBCXX_HAVE__FINITE */ ++ ++/* Define to 1 if you have the `_finitef' function. */ ++/* #undef _GLIBCXX_HAVE__FINITEF */ ++ ++/* Define to 1 if you have the `_finitel' function. */ ++/* #undef _GLIBCXX_HAVE__FINITEL */ ++ ++/* Define to 1 if you have the `_floorf' function. */ ++/* #undef _GLIBCXX_HAVE__FLOORF */ ++ ++/* Define to 1 if you have the `_floorl' function. */ ++/* #undef _GLIBCXX_HAVE__FLOORL */ ++ ++/* Define to 1 if you have the `_fmodf' function. */ ++/* #undef _GLIBCXX_HAVE__FMODF */ ++ ++/* Define to 1 if you have the `_fmodl' function. */ ++/* #undef _GLIBCXX_HAVE__FMODL */ ++ ++/* Define to 1 if you have the `_fpclass' function. */ ++/* #undef _GLIBCXX_HAVE__FPCLASS */ ++ ++/* Define to 1 if you have the `_frexpf' function. */ ++/* #undef _GLIBCXX_HAVE__FREXPF */ ++ ++/* Define to 1 if you have the `_frexpl' function. */ ++/* #undef _GLIBCXX_HAVE__FREXPL */ ++ ++/* Define to 1 if you have the `_hypot' function. */ ++/* #undef _GLIBCXX_HAVE__HYPOT */ ++ ++/* Define to 1 if you have the `_hypotf' function. */ ++/* #undef _GLIBCXX_HAVE__HYPOTF */ ++ ++/* Define to 1 if you have the `_hypotl' function. */ ++/* #undef _GLIBCXX_HAVE__HYPOTL */ ++ ++/* Define to 1 if you have the `_isinf' function. */ ++/* #undef _GLIBCXX_HAVE__ISINF */ ++ ++/* Define to 1 if you have the `_isinff' function. */ ++/* #undef _GLIBCXX_HAVE__ISINFF */ ++ ++/* Define to 1 if you have the `_isinfl' function. */ ++/* #undef _GLIBCXX_HAVE__ISINFL */ ++ ++/* Define to 1 if you have the `_isnan' function. */ ++/* #undef _GLIBCXX_HAVE__ISNAN */ ++ ++/* Define to 1 if you have the `_isnanf' function. */ ++/* #undef _GLIBCXX_HAVE__ISNANF */ ++ ++/* Define to 1 if you have the `_isnanl' function. */ ++/* #undef _GLIBCXX_HAVE__ISNANL */ ++ ++/* Define to 1 if you have the `_ldexpf' function. */ ++/* #undef _GLIBCXX_HAVE__LDEXPF */ ++ ++/* Define to 1 if you have the `_ldexpl' function. */ ++/* #undef _GLIBCXX_HAVE__LDEXPL */ ++ ++/* Define to 1 if you have the `_log10f' function. */ ++/* #undef _GLIBCXX_HAVE__LOG10F */ ++ ++/* Define to 1 if you have the `_log10l' function. */ ++/* #undef _GLIBCXX_HAVE__LOG10L */ ++ ++/* Define to 1 if you have the `_logf' function. */ ++/* #undef _GLIBCXX_HAVE__LOGF */ ++ ++/* Define to 1 if you have the `_logl' function. */ ++/* #undef _GLIBCXX_HAVE__LOGL */ ++ ++/* Define to 1 if you have the `_modf' function. */ ++/* #undef _GLIBCXX_HAVE__MODF */ ++ ++/* Define to 1 if you have the `_modff' function. */ ++/* #undef _GLIBCXX_HAVE__MODFF */ ++ ++/* Define to 1 if you have the `_modfl' function. */ ++/* #undef _GLIBCXX_HAVE__MODFL */ ++ ++/* Define to 1 if you have the `_powf' function. */ ++/* #undef _GLIBCXX_HAVE__POWF */ ++ ++/* Define to 1 if you have the `_powl' function. */ ++/* #undef _GLIBCXX_HAVE__POWL */ ++ ++/* Define to 1 if you have the `_qfpclass' function. */ ++/* #undef _GLIBCXX_HAVE__QFPCLASS */ ++ ++/* Define to 1 if you have the `_sincos' function. */ ++/* #undef _GLIBCXX_HAVE__SINCOS */ ++ ++/* Define to 1 if you have the `_sincosf' function. */ ++/* #undef _GLIBCXX_HAVE__SINCOSF */ ++ ++/* Define to 1 if you have the `_sincosl' function. */ ++/* #undef _GLIBCXX_HAVE__SINCOSL */ ++ ++/* Define to 1 if you have the `_sinf' function. */ ++/* #undef _GLIBCXX_HAVE__SINF */ ++ ++/* Define to 1 if you have the `_sinhf' function. */ ++/* #undef _GLIBCXX_HAVE__SINHF */ ++ ++/* Define to 1 if you have the `_sinhl' function. */ ++/* #undef _GLIBCXX_HAVE__SINHL */ ++ ++/* Define to 1 if you have the `_sinl' function. */ ++/* #undef _GLIBCXX_HAVE__SINL */ ++ ++/* Define to 1 if you have the `_sqrtf' function. */ ++/* #undef _GLIBCXX_HAVE__SQRTF */ ++ ++/* Define to 1 if you have the `_sqrtl' function. */ ++/* #undef _GLIBCXX_HAVE__SQRTL */ ++ ++/* Define to 1 if you have the `_tanf' function. */ ++/* #undef _GLIBCXX_HAVE__TANF */ ++ ++/* Define to 1 if you have the `_tanhf' function. */ ++/* #undef _GLIBCXX_HAVE__TANHF */ ++ ++/* Define to 1 if you have the `_tanhl' function. */ ++/* #undef _GLIBCXX_HAVE__TANHL */ ++ ++/* Define to 1 if you have the `_tanl' function. */ ++/* #undef _GLIBCXX_HAVE__TANL */ ++ ++/* Define to 1 if you have the `_wfopen' function. */ ++/* #undef _GLIBCXX_HAVE__WFOPEN */ ++ ++/* Define to 1 if you have the `__cxa_thread_atexit' function. */ ++/* #undef _GLIBCXX_HAVE___CXA_THREAD_ATEXIT */ ++ ++/* Define to 1 if you have the `__cxa_thread_atexit_impl' function. */ ++/* #undef _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL */ ++ ++/* Define as const if the declaration of iconv() needs const. */ ++/* #undef _GLIBCXX_ICONV_CONST */ ++ ++/* Define to the sub-directory in which libtool stores uninstalled libraries. ++ */ ++#define _GLIBCXX_LT_OBJDIR ".libs/" ++ ++/* Name of package */ ++/* #undef _GLIBCXX_PACKAGE */ ++ ++/* Define to the address where bug reports for this package should be sent. */ ++#define _GLIBCXX_PACKAGE_BUGREPORT "" ++ ++/* Define to the full name of this package. */ ++#define _GLIBCXX_PACKAGE_NAME "package-unused" ++ ++/* Define to the full name and version of this package. */ ++#define _GLIBCXX_PACKAGE_STRING "package-unused version-unused" ++ ++/* Define to the one symbol short name of this package. */ ++#define _GLIBCXX_PACKAGE_TARNAME "libstdc++" ++ ++/* Define to the home page for this package. */ ++#define _GLIBCXX_PACKAGE_URL "" ++ ++/* Define to the version of this package. */ ++#define _GLIBCXX_PACKAGE__GLIBCXX_VERSION "version-unused" ++ ++/* Define to 1 if you have the ANSI C header files. */ ++#define _GLIBCXX_STDC_HEADERS 1 ++ ++/* Version number of package */ ++/* #undef _GLIBCXX_VERSION */ ++ ++/* Enable large inode numbers on Mac OS X 10.5. */ ++#ifndef _GLIBCXX_DARWIN_USE_64_BIT_INODE ++# define _GLIBCXX_DARWIN_USE_64_BIT_INODE 1 ++#endif ++ ++/* Number of bits in a file offset, on hosts where this is settable. */ ++/* #undef _GLIBCXX_FILE_OFFSET_BITS */ ++ ++/* Define if C99 functions in should be used in for ++ C++11. Using compiler builtins for these functions requires corresponding ++ C99 library functions to be present. */ ++#define _GLIBCXX11_USE_C99_COMPLEX 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std for C++11. */ ++#define _GLIBCXX11_USE_C99_MATH 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std for C++11. */ ++#define _GLIBCXX11_USE_C99_STDIO 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std for C++11. */ ++#define _GLIBCXX11_USE_C99_STDLIB 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std for C++11. */ ++#define _GLIBCXX11_USE_C99_WCHAR 1 ++ ++/* Define if C99 functions in should be used in for ++ C++98. Using compiler builtins for these functions requires corresponding ++ C99 library functions to be present. */ ++#define _GLIBCXX98_USE_C99_COMPLEX 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std for C++98. */ ++#define _GLIBCXX98_USE_C99_MATH 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std for C++98. */ ++#define _GLIBCXX98_USE_C99_STDIO 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std for C++98. */ ++#define _GLIBCXX98_USE_C99_STDLIB 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std for C++98. */ ++#define _GLIBCXX98_USE_C99_WCHAR 1 ++ ++/* Define if the compiler supports C++11 atomics. */ ++#define _GLIBCXX_ATOMIC_BUILTINS 1 ++ ++/* Define if global objects can be aligned to ++ std::hardware_destructive_interference_size. */ ++#define _GLIBCXX_CAN_ALIGNAS_DESTRUCTIVE_SIZE 1 ++ ++/* Define to use concept checking code from the boost libraries. */ ++/* #undef _GLIBCXX_CONCEPT_CHECKS */ ++ ++/* Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, ++ undefined for platform defaults */ ++#define _GLIBCXX_FULLY_DYNAMIC_STRING 0 ++ ++/* Define if gthreads library is available. */ ++#define _GLIBCXX_HAS_GTHREADS 1 ++ ++/* Define to 1 if a full hosted library is built, or 0 if freestanding. */ ++#define _GLIBCXX_HOSTED 1 ++ ++/* Define if compatibility should be provided for alternative 128-bit long ++ double formats. */ ++ ++/* Define if compatibility should be provided for -mlong-double-64. */ ++ ++/* Define to the letter to which size_t is mangled. */ ++#define _GLIBCXX_MANGLE_SIZE_T j ++ ++/* Define if C99 llrint and llround functions are missing from . */ ++/* #undef _GLIBCXX_NO_C99_ROUNDING_FUNCS */ ++ ++/* Defined if no way to sleep is available. */ ++/* #undef _GLIBCXX_NO_SLEEP */ ++ ++/* Define if ptrdiff_t is int. */ ++#define _GLIBCXX_PTRDIFF_T_IS_INT 1 ++ ++/* Define if using setrlimit to set resource limits during "make check" */ ++/* #undef _GLIBCXX_RES_LIMITS */ ++ ++/* Define if size_t is unsigned int. */ ++#define _GLIBCXX_SIZE_T_IS_UINT 1 ++ ++/* Define if static tzdata should be compiled into the library. */ ++#define _GLIBCXX_STATIC_TZDATA 1 ++ ++/* Define to the value of the EOF integer constant. */ ++#define _GLIBCXX_STDIO_EOF -1 ++ ++/* Define to the value of the SEEK_CUR integer constant. */ ++#define _GLIBCXX_STDIO_SEEK_CUR 1 ++ ++/* Define to the value of the SEEK_END integer constant. */ ++#define _GLIBCXX_STDIO_SEEK_END 2 ++ ++/* Define to use symbol versioning in the shared library. */ ++/* #undef _GLIBCXX_SYMVER */ ++ ++/* Define to use darwin versioning in the shared library. */ ++/* #undef _GLIBCXX_SYMVER_DARWIN */ ++ ++/* Define to use GNU versioning in the shared library. */ ++/* #undef _GLIBCXX_SYMVER_GNU */ ++ ++/* Define to use GNU namespace versioning in the shared library. */ ++/* #undef _GLIBCXX_SYMVER_GNU_NAMESPACE */ ++ ++/* Define to use Sun versioning in the shared library. */ ++/* #undef _GLIBCXX_SYMVER_SUN */ ++ ++/* Define if C11 functions in should be imported into namespace std ++ in . */ ++/* #undef _GLIBCXX_USE_C11_UCHAR_CXX11 */ ++ ++/* Define if C99 functions or macros from , , , ++ , and can be used or exposed. */ ++#define _GLIBCXX_USE_C99 1 ++ ++/* Define if C99 functions in should be used in . ++ Using compiler builtins for these functions requires corresponding C99 ++ library functions to be present. */ ++#define _GLIBCXX_USE_C99_COMPLEX_TR1 1 ++ ++/* Define if C99 functions in should be imported in in ++ namespace std::tr1. */ ++#define _GLIBCXX_USE_C99_CTYPE_TR1 1 ++ ++/* Define if C99 functions in should be imported in in ++ namespace std::tr1. */ ++#define _GLIBCXX_USE_C99_FENV_TR1 1 ++ ++/* Define if C99 functions in should be imported in ++ in namespace std::tr1. */ ++#define _GLIBCXX_USE_C99_INTTYPES_TR1 1 ++ ++/* Define if wchar_t C99 functions in should be imported in ++ in namespace std::tr1. */ ++#define _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 1 ++ ++/* Define if C99 functions or macros in should be imported in ++ in namespace std::tr1. */ ++#define _GLIBCXX_USE_C99_MATH_TR1 1 ++ ++/* Define if C99 types in should be imported in in ++ namespace std::tr1. */ ++#define _GLIBCXX_USE_C99_STDINT_TR1 1 ++ ++/* Defined if clock_gettime syscall has monotonic and realtime clock support. ++ */ ++/* #undef _GLIBCXX_USE_CLOCK_GETTIME_SYSCALL */ ++ ++/* Defined if clock_gettime has monotonic clock support. */ ++/* #undef _GLIBCXX_USE_CLOCK_MONOTONIC */ ++ ++/* Defined if clock_gettime has realtime clock support. */ ++/* #undef _GLIBCXX_USE_CLOCK_REALTIME */ ++ ++/* Define if ISO/IEC TR 24733 decimal floating point types are supported on ++ this host. */ ++/* #undef _GLIBCXX_USE_DECIMAL_FLOAT */ ++ ++/* Define if /dev/random and /dev/urandom are available for ++ std::random_device. */ ++/* #undef _GLIBCXX_USE_DEV_RANDOM */ ++ ++/* Define if fchmod is available in . */ ++/* #undef _GLIBCXX_USE_FCHMOD */ ++ ++/* Define if fchmodat is available in . */ ++/* #undef _GLIBCXX_USE_FCHMODAT */ ++ ++/* Define if fseeko and ftello are available. */ ++#define _GLIBCXX_USE_FSEEKO_FTELLO 1 ++ ++/* Defined if gettimeofday is available. */ ++#define _GLIBCXX_USE_GETTIMEOFDAY 1 ++ ++/* Define if get_nprocs is available in . */ ++/* #undef _GLIBCXX_USE_GET_NPROCS */ ++ ++/* Define if init_priority should be used for iostream initialization. */ ++#define _GLIBCXX_USE_INIT_PRIORITY_ATTRIBUTE 1 ++ ++/* Define if LFS support is available. */ ++/* #undef _GLIBCXX_USE_LFS */ ++ ++/* Define if code specialized for long long should be used. */ ++#define _GLIBCXX_USE_LONG_LONG 1 ++ ++/* Define if lstat is available in . */ ++/* #undef _GLIBCXX_USE_LSTAT */ ++ ++/* Defined if nanosleep is available. */ ++/* #undef _GLIBCXX_USE_NANOSLEEP */ ++ ++/* Define if NLS translations are to be used. */ ++/* #undef _GLIBCXX_USE_NLS */ ++ ++/* Define if pthreads_num_processors_np is available in . */ ++/* #undef _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP */ ++ ++/* Define if pthread_cond_clockwait is available in . */ ++/* #undef _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT */ ++ ++/* Define if pthread_mutex_clocklock is available in . */ ++/* #undef _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK */ ++ ++/* Define if pthread_rwlock_clockrdlock and pthread_rwlock_clockwrlock are ++ available in . */ ++/* #undef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK */ ++ ++/* Define if POSIX read/write locks are available in . */ ++/* #undef _GLIBCXX_USE_PTHREAD_RWLOCK_T */ ++ ++/* Define if /dev/random and /dev/urandom are available for the random_device ++ of TR1 (Chapter 5.1). */ ++/* #undef _GLIBCXX_USE_RANDOM_TR1 */ ++ ++/* Define if usable realpath is available in . */ ++/* #undef _GLIBCXX_USE_REALPATH */ ++ ++/* Defined if sched_yield is available. */ ++/* #undef _GLIBCXX_USE_SCHED_YIELD */ ++ ++/* Define if _SC_NPROCESSORS_ONLN is available in . */ ++#define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1 ++ ++/* Define if _SC_NPROC_ONLN is available in . */ ++/* #undef _GLIBCXX_USE_SC_NPROC_ONLN */ ++ ++/* Define if sendfile is available in . */ ++/* #undef _GLIBCXX_USE_SENDFILE */ ++ ++/* Define to restrict std::__basic_file<> to stdio APIs. */ ++/* #undef _GLIBCXX_USE_STDIO_PURE */ ++ ++/* Define if struct stat has timespec members. */ ++#define _GLIBCXX_USE_ST_MTIM 1 ++ ++/* Define if sysctl(), CTL_HW and HW_NCPU are available in . */ ++/* #undef _GLIBCXX_USE_SYSCTL_HW_NCPU */ ++ ++/* Define if obsolescent tmpnam is available in . */ ++#define _GLIBCXX_USE_TMPNAM 1 ++ ++/* Define if c8rtomb and mbrtoc8 functions in should be imported ++ into namespace std in for C++20. */ ++/* #undef _GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_CXX20 */ ++ ++/* Define if c8rtomb and mbrtoc8 functions in should be imported ++ into namespace std in for -fchar8_t. */ ++/* #undef _GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_FCHAR8_T */ ++ ++/* Define if utime is available in . */ ++/* #undef _GLIBCXX_USE_UTIME */ ++ ++/* Define if utimensat and UTIME_OMIT are available in and ++ AT_FDCWD in . */ ++/* #undef _GLIBCXX_USE_UTIMENSAT */ ++ ++/* Define if code specialized for wchar_t should be used. */ ++#define _GLIBCXX_USE_WCHAR_T 1 ++ ++/* Defined if Sleep exists. */ ++/* #undef _GLIBCXX_USE_WIN32_SLEEP */ ++ ++/* Define to 1 if a verbose library is built, or 0 otherwise. */ ++#define _GLIBCXX_VERBOSE 1 ++ ++/* Defined if as can handle rdrand. */ ++/* #undef _GLIBCXX_X86_RDRAND */ ++ ++/* Defined if as can handle rdseed. */ ++/* #undef _GLIBCXX_X86_RDSEED */ ++ ++/* Define if a directory should be searched for tzdata files. */ ++/* #undef _GLIBCXX_ZONEINFO_DIR */ ++ ++/* Define to 1 if mutex_timedlock is available. */ ++#define _GTHREAD_USE_MUTEX_TIMEDLOCK 1 ++ ++/* Define for large files, on AIX-style hosts. */ ++/* #undef _GLIBCXX_LARGE_FILES */ ++ ++/* Define if all C++11 floating point overloads are available in . */ ++#if __cplusplus >= 201103L ++/* #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP */ ++#endif ++ ++/* Define if all C++11 integral type overloads are available in . */ ++#if __cplusplus >= 201103L ++/* #undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT */ ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ACOSF) && ! defined (_GLIBCXX_HAVE_ACOSF) ++# define _GLIBCXX_HAVE_ACOSF 1 ++# define acosf _acosf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ACOSL) && ! defined (_GLIBCXX_HAVE_ACOSL) ++# define _GLIBCXX_HAVE_ACOSL 1 ++# define acosl _acosl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ASINF) && ! defined (_GLIBCXX_HAVE_ASINF) ++# define _GLIBCXX_HAVE_ASINF 1 ++# define asinf _asinf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ASINL) && ! defined (_GLIBCXX_HAVE_ASINL) ++# define _GLIBCXX_HAVE_ASINL 1 ++# define asinl _asinl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ATAN2F) && ! defined (_GLIBCXX_HAVE_ATAN2F) ++# define _GLIBCXX_HAVE_ATAN2F 1 ++# define atan2f _atan2f ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ATAN2L) && ! defined (_GLIBCXX_HAVE_ATAN2L) ++# define _GLIBCXX_HAVE_ATAN2L 1 ++# define atan2l _atan2l ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ATANF) && ! defined (_GLIBCXX_HAVE_ATANF) ++# define _GLIBCXX_HAVE_ATANF 1 ++# define atanf _atanf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ATANL) && ! defined (_GLIBCXX_HAVE_ATANL) ++# define _GLIBCXX_HAVE_ATANL 1 ++# define atanl _atanl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__CEILF) && ! defined (_GLIBCXX_HAVE_CEILF) ++# define _GLIBCXX_HAVE_CEILF 1 ++# define ceilf _ceilf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__CEILL) && ! defined (_GLIBCXX_HAVE_CEILL) ++# define _GLIBCXX_HAVE_CEILL 1 ++# define ceill _ceill ++#endif ++ ++#if defined (_GLIBCXX_HAVE__COSF) && ! defined (_GLIBCXX_HAVE_COSF) ++# define _GLIBCXX_HAVE_COSF 1 ++# define cosf _cosf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__COSHF) && ! defined (_GLIBCXX_HAVE_COSHF) ++# define _GLIBCXX_HAVE_COSHF 1 ++# define coshf _coshf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__COSHL) && ! defined (_GLIBCXX_HAVE_COSHL) ++# define _GLIBCXX_HAVE_COSHL 1 ++# define coshl _coshl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__COSL) && ! defined (_GLIBCXX_HAVE_COSL) ++# define _GLIBCXX_HAVE_COSL 1 ++# define cosl _cosl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__EXPF) && ! defined (_GLIBCXX_HAVE_EXPF) ++# define _GLIBCXX_HAVE_EXPF 1 ++# define expf _expf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__EXPL) && ! defined (_GLIBCXX_HAVE_EXPL) ++# define _GLIBCXX_HAVE_EXPL 1 ++# define expl _expl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FABSF) && ! defined (_GLIBCXX_HAVE_FABSF) ++# define _GLIBCXX_HAVE_FABSF 1 ++# define fabsf _fabsf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FABSL) && ! defined (_GLIBCXX_HAVE_FABSL) ++# define _GLIBCXX_HAVE_FABSL 1 ++# define fabsl _fabsl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FINITE) && ! defined (_GLIBCXX_HAVE_FINITE) ++# define _GLIBCXX_HAVE_FINITE 1 ++# define finite _finite ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FINITEF) && ! defined (_GLIBCXX_HAVE_FINITEF) ++# define _GLIBCXX_HAVE_FINITEF 1 ++# define finitef _finitef ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FINITEL) && ! defined (_GLIBCXX_HAVE_FINITEL) ++# define _GLIBCXX_HAVE_FINITEL 1 ++# define finitel _finitel ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FLOORF) && ! defined (_GLIBCXX_HAVE_FLOORF) ++# define _GLIBCXX_HAVE_FLOORF 1 ++# define floorf _floorf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FLOORL) && ! defined (_GLIBCXX_HAVE_FLOORL) ++# define _GLIBCXX_HAVE_FLOORL 1 ++# define floorl _floorl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FMODF) && ! defined (_GLIBCXX_HAVE_FMODF) ++# define _GLIBCXX_HAVE_FMODF 1 ++# define fmodf _fmodf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FMODL) && ! defined (_GLIBCXX_HAVE_FMODL) ++# define _GLIBCXX_HAVE_FMODL 1 ++# define fmodl _fmodl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FPCLASS) && ! defined (_GLIBCXX_HAVE_FPCLASS) ++# define _GLIBCXX_HAVE_FPCLASS 1 ++# define fpclass _fpclass ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FREXPF) && ! defined (_GLIBCXX_HAVE_FREXPF) ++# define _GLIBCXX_HAVE_FREXPF 1 ++# define frexpf _frexpf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__FREXPL) && ! defined (_GLIBCXX_HAVE_FREXPL) ++# define _GLIBCXX_HAVE_FREXPL 1 ++# define frexpl _frexpl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__HYPOT) && ! defined (_GLIBCXX_HAVE_HYPOT) ++# define _GLIBCXX_HAVE_HYPOT 1 ++# define hypot _hypot ++#endif ++ ++#if defined (_GLIBCXX_HAVE__HYPOTF) && ! defined (_GLIBCXX_HAVE_HYPOTF) ++# define _GLIBCXX_HAVE_HYPOTF 1 ++# define hypotf _hypotf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__HYPOTL) && ! defined (_GLIBCXX_HAVE_HYPOTL) ++# define _GLIBCXX_HAVE_HYPOTL 1 ++# define hypotl _hypotl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ISINF) && ! defined (_GLIBCXX_HAVE_ISINF) ++# define _GLIBCXX_HAVE_ISINF 1 ++# define isinf _isinf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ISINFF) && ! defined (_GLIBCXX_HAVE_ISINFF) ++# define _GLIBCXX_HAVE_ISINFF 1 ++# define isinff _isinff ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ISINFL) && ! defined (_GLIBCXX_HAVE_ISINFL) ++# define _GLIBCXX_HAVE_ISINFL 1 ++# define isinfl _isinfl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ISNAN) && ! defined (_GLIBCXX_HAVE_ISNAN) ++# define _GLIBCXX_HAVE_ISNAN 1 ++# define isnan _isnan ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ISNANF) && ! defined (_GLIBCXX_HAVE_ISNANF) ++# define _GLIBCXX_HAVE_ISNANF 1 ++# define isnanf _isnanf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__ISNANL) && ! defined (_GLIBCXX_HAVE_ISNANL) ++# define _GLIBCXX_HAVE_ISNANL 1 ++# define isnanl _isnanl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__LDEXPF) && ! defined (_GLIBCXX_HAVE_LDEXPF) ++# define _GLIBCXX_HAVE_LDEXPF 1 ++# define ldexpf _ldexpf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__LDEXPL) && ! defined (_GLIBCXX_HAVE_LDEXPL) ++# define _GLIBCXX_HAVE_LDEXPL 1 ++# define ldexpl _ldexpl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__LOG10F) && ! defined (_GLIBCXX_HAVE_LOG10F) ++# define _GLIBCXX_HAVE_LOG10F 1 ++# define log10f _log10f ++#endif ++ ++#if defined (_GLIBCXX_HAVE__LOG10L) && ! defined (_GLIBCXX_HAVE_LOG10L) ++# define _GLIBCXX_HAVE_LOG10L 1 ++# define log10l _log10l ++#endif ++ ++#if defined (_GLIBCXX_HAVE__LOGF) && ! defined (_GLIBCXX_HAVE_LOGF) ++# define _GLIBCXX_HAVE_LOGF 1 ++# define logf _logf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__LOGL) && ! defined (_GLIBCXX_HAVE_LOGL) ++# define _GLIBCXX_HAVE_LOGL 1 ++# define logl _logl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__MODF) && ! defined (_GLIBCXX_HAVE_MODF) ++# define _GLIBCXX_HAVE_MODF 1 ++# define modf _modf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__MODFF) && ! defined (_GLIBCXX_HAVE_MODFF) ++# define _GLIBCXX_HAVE_MODFF 1 ++# define modff _modff ++#endif ++ ++#if defined (_GLIBCXX_HAVE__MODFL) && ! defined (_GLIBCXX_HAVE_MODFL) ++# define _GLIBCXX_HAVE_MODFL 1 ++# define modfl _modfl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__POWF) && ! defined (_GLIBCXX_HAVE_POWF) ++# define _GLIBCXX_HAVE_POWF 1 ++# define powf _powf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__POWL) && ! defined (_GLIBCXX_HAVE_POWL) ++# define _GLIBCXX_HAVE_POWL 1 ++# define powl _powl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__QFPCLASS) && ! defined (_GLIBCXX_HAVE_QFPCLASS) ++# define _GLIBCXX_HAVE_QFPCLASS 1 ++# define qfpclass _qfpclass ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SINCOS) && ! defined (_GLIBCXX_HAVE_SINCOS) ++# define _GLIBCXX_HAVE_SINCOS 1 ++# define sincos _sincos ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SINCOSF) && ! defined (_GLIBCXX_HAVE_SINCOSF) ++# define _GLIBCXX_HAVE_SINCOSF 1 ++# define sincosf _sincosf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SINCOSL) && ! defined (_GLIBCXX_HAVE_SINCOSL) ++# define _GLIBCXX_HAVE_SINCOSL 1 ++# define sincosl _sincosl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SINF) && ! defined (_GLIBCXX_HAVE_SINF) ++# define _GLIBCXX_HAVE_SINF 1 ++# define sinf _sinf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SINHF) && ! defined (_GLIBCXX_HAVE_SINHF) ++# define _GLIBCXX_HAVE_SINHF 1 ++# define sinhf _sinhf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SINHL) && ! defined (_GLIBCXX_HAVE_SINHL) ++# define _GLIBCXX_HAVE_SINHL 1 ++# define sinhl _sinhl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SINL) && ! defined (_GLIBCXX_HAVE_SINL) ++# define _GLIBCXX_HAVE_SINL 1 ++# define sinl _sinl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SQRTF) && ! defined (_GLIBCXX_HAVE_SQRTF) ++# define _GLIBCXX_HAVE_SQRTF 1 ++# define sqrtf _sqrtf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__SQRTL) && ! defined (_GLIBCXX_HAVE_SQRTL) ++# define _GLIBCXX_HAVE_SQRTL 1 ++# define sqrtl _sqrtl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__STRTOF) && ! defined (_GLIBCXX_HAVE_STRTOF) ++# define _GLIBCXX_HAVE_STRTOF 1 ++# define strtof _strtof ++#endif ++ ++#if defined (_GLIBCXX_HAVE__STRTOLD) && ! defined (_GLIBCXX_HAVE_STRTOLD) ++# define _GLIBCXX_HAVE_STRTOLD 1 ++# define strtold _strtold ++#endif ++ ++#if defined (_GLIBCXX_HAVE__TANF) && ! defined (_GLIBCXX_HAVE_TANF) ++# define _GLIBCXX_HAVE_TANF 1 ++# define tanf _tanf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__TANHF) && ! defined (_GLIBCXX_HAVE_TANHF) ++# define _GLIBCXX_HAVE_TANHF 1 ++# define tanhf _tanhf ++#endif ++ ++#if defined (_GLIBCXX_HAVE__TANHL) && ! defined (_GLIBCXX_HAVE_TANHL) ++# define _GLIBCXX_HAVE_TANHL 1 ++# define tanhl _tanhl ++#endif ++ ++#if defined (_GLIBCXX_HAVE__TANL) && ! defined (_GLIBCXX_HAVE_TANL) ++# define _GLIBCXX_HAVE_TANL 1 ++# define tanl _tanl ++#endif ++ ++#endif // _GLIBCXX_CXX_CONFIG_H +-- +2.43.0 + diff --git a/libs/libxx/libstdc++/CMakeLists.txt b/libs/libxx/libstdc++/CMakeLists.txt new file mode 100644 index 00000000000..d73ca5f1981 --- /dev/null +++ b/libs/libxx/libstdc++/CMakeLists.txt @@ -0,0 +1,167 @@ +# ############################################################################## +# libs/libxx/libstdc++/CMakeLists.txt +# +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed to the Apache Software Foundation (ASF) under one or more contributor +# license agreements. See the NOTICE file distributed with this work for +# additional information regarding copyright ownership. The ASF licenses this +# file to you under the Apache License, Version 2.0 (the "License"); you may not +# use this file except in compliance with the License. You may obtain a copy of +# the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations under +# the License. +# +# ############################################################################## + +if(CONFIG_LIBSUPCXX) + + set(LIBSTDCXX_VERSION ${CONFIG_LIBSTDCXX_VERSION}) + + # Download and unpack tarball if no git repo found + if(NOT EXISTS ${CMAKE_CURRENT_LIST_DIR}/libstdc++/.git) + if(NOT EXISTS ${CMAKE_CURRENT_LIST_DIR}/libstdc++) + + FetchContent_Declare( + libstdcxx + DOWNLOAD_NAME "libstdc++-v3.tar.gz" + DOWNLOAD_DIR ${CMAKE_CURRENT_LIST_DIR} + URL "https://gnu.googlesource.com/gcc/+archive/refs/tags/releases/gcc-${LIBSTDCXX_VERSION}/libstdc++-v3.tar.gz" + SOURCE_DIR + ${CMAKE_CURRENT_LIST_DIR}/libstdc++ + BINARY_DIR + ${CMAKE_BINARY_DIR}/libs/libxx/libstdc++ + CONFIGURE_COMMAND + "" + BUILD_COMMAND + "" + INSTALL_COMMAND + "" + TEST_COMMAND + "" + PATCH_COMMAND + patch -p1 -d ${CMAKE_CURRENT_LIST_DIR}/libstdc++ < + ${CMAKE_CURRENT_LIST_DIR}/0001-libsupc-Add-missing-header-files.patch + DOWNLOAD_NO_PROGRESS true + TIMEOUT 30) + + FetchContent_GetProperties(libstdcxx) + + if(NOT libstdcxx_POPULATED) + FetchContent_Populate(libstdcxx) + endif() + + endif() + endif() + + # Set directories + set(SUPDIR ${CMAKE_CURRENT_LIST_DIR}/libstdc++/libsupc++) + set(INCDIR ${CMAKE_CURRENT_LIST_DIR}/libstdc++/include) + set(CONDIR ${CMAKE_CURRENT_LIST_DIR}/libstdc++/config) + + # Determine CPU config + if(CONFIG_ARCH_ARM) + set(CPU_CONFIG arm) + else() + set(CPU_CONFIG generic) + endif() + + # Create include directories + file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/include/c++) + file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/include/c++/bits) + + # Copy headers to c++ include directory + set(CXXDIR ${CMAKE_BINARY_DIR}/include/c++) + set(BITSDIR ${CMAKE_BINARY_DIR}/include/c++/bits) + + # Copy libsupc++ headers + file(COPY ${SUPDIR}/compare DESTINATION ${CXXDIR}) + file(COPY ${SUPDIR}/exception DESTINATION ${CXXDIR}) + file(COPY ${SUPDIR}/initializer_list DESTINATION ${CXXDIR}) + file(COPY ${SUPDIR}/new DESTINATION ${CXXDIR}) + file(COPY ${SUPDIR}/typeinfo DESTINATION ${CXXDIR}) + + # Copy gthr headers from libgcc + file(COPY ${NUTTX_DIR}/libs/libbuiltin/libgcc/libgcc/gthr.h + DESTINATION ${CXXDIR}) + file(COPY ${NUTTX_DIR}/libs/libbuiltin/libgcc/libgcc/gthr.h + DESTINATION ${BITSDIR}) + file(COPY_FILE ${NUTTX_DIR}/libs/libbuiltin/libgcc/libgcc/gthr-posix.h + ${CXXDIR}/gthr-default.h) + file(COPY_FILE ${NUTTX_DIR}/libs/libbuiltin/libgcc/libgcc/gthr-posix.h + ${BITSDIR}/gthr-default.h) + + # Copy unwind-pe.h + file(COPY ${NUTTX_DIR}/libs/libbuiltin/libgcc/libgcc/unwind-pe.h + DESTINATION ${CMAKE_CURRENT_LIST_DIR}) + + # Copy bits headers + file(COPY ${SUPDIR}/atomic_lockfree_defines.h DESTINATION ${BITSDIR}) + file(COPY ${SUPDIR}/cxxabi_forced.h DESTINATION ${BITSDIR}) + file(COPY ${SUPDIR}/exception_defines.h DESTINATION ${BITSDIR}) + file(COPY ${SUPDIR}/exception_ptr.h DESTINATION ${BITSDIR}) + file(COPY ${SUPDIR}/hash_bytes.h DESTINATION ${BITSDIR}) + file(COPY ${SUPDIR}/nested_exception.h DESTINATION ${BITSDIR}) + file(COPY ${SUPDIR}/exception.h DESTINATION ${BITSDIR}) + file(COPY ${SUPDIR}/cxxabi_init_exception.h DESTINATION ${BITSDIR}) + file(COPY ${CONDIR}/cpu/generic/cpu_defines.h DESTINATION ${BITSDIR}) + file(COPY ${CONDIR}/cpu/${CPU_CONFIG}/cxxabi_tweaks.h DESTINATION ${BITSDIR}) + file(COPY ${CONDIR}/cpu/generic/atomic_word.h DESTINATION ${BITSDIR}) + file(COPY ${CONDIR}/os/generic/os_defines.h DESTINATION ${BITSDIR}) + + # Set include directories for nuttx + set_property( + TARGET nuttx + APPEND + PROPERTY NUTTX_CXX_INCLUDE_DIRECTORIES ${CXXDIR} ${INCDIR} ${SUPDIR} + ${CMAKE_CURRENT_LIST_DIR}) + + # Get source files + file(GLOB SRCS ${SUPDIR}/*.cc) + + # Remove RTTI sources if RTTI is disabled + if(NOT CONFIG_CXX_RTTI) + list(REMOVE_ITEM SRCS ${SUPDIR}/eh_arm.cc ${SUPDIR}/eh_call.cc) + endif() + + set(FLAGS -Wno-undef -Wno-unused-result) + + # Create library manually to avoid inheriting NUTTX_CXX_INCLUDE_DIRECTORIES + # which contains libcxx paths that conflict with libstdc++ headers + add_library(libsupcxx ${SRCS}) + add_dependencies(libsupcxx nuttx_context) + + target_compile_options(libsupcxx PRIVATE ${FLAGS}) + + target_include_directories( + libsupcxx BEFORE PRIVATE ${INCDIR} ${INCDIR}/std ${INCDIR}/c_global + ${SUPDIR} ${CMAKE_CURRENT_LIST_DIR} ${CXXDIR}) + + # Add system include directories + target_include_directories( + libsupcxx SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/include + ${CMAKE_BINARY_DIR}/include) + + # Set global compile options & definitions from nuttx target + target_compile_options( + libsupcxx + PRIVATE $>) + target_compile_definitions( + libsupcxx PRIVATE $>) + target_include_directories( + libsupcxx + PRIVATE $>) + + # Add to system libraries list + set_property(GLOBAL APPEND PROPERTY NUTTX_SYSTEM_LIBRARIES libsupcxx) + + # Install target + install(TARGETS libsupcxx) + +endif() diff --git a/libs/libxx/libstdc++/libsupc++.defs b/libs/libxx/libstdc++/libsupc++.defs new file mode 100644 index 00000000000..1c13804bc8b --- /dev/null +++ b/libs/libxx/libstdc++/libsupc++.defs @@ -0,0 +1,103 @@ + +############################################################################ +# libs/libxx/libstdc++/libsupc++.defs +# +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. The +# ASF licenses this file to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance with the +# License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +########################################################################### + +LIBSTDCXX_VERSION=$(patsubst "%",%,$(CONFIG_LIBSTDCXX_VERSION)) + +# Download and unpack tarball if no git repo found +ifeq ($(wildcard libstdc++/libstdc++/.git),) +libstdc++-v3.tar.gz: + $(call DOWNLOAD,https://gnu.googlesource.com/gcc/+archive/refs/tags/releases/gcc-$(LIBSTDCXX_VERSION),libstdc++-v3.tar.gz) + +libstdc++/libstdc++: libstdc++-v3.tar.gz + $(Q) mkdir -p $@ + $(Q) tar -xzf $< -C $@ + $(Q) patch -p1 < libstdc++/0001-libsupc-Add-missing-header-files.patch -d $@ +endif + +C++DIR = $(TOPDIR)/include/c++ +BITSDIR = $(TOPDIR)/include/c++/bits +CONDIR = libstdc++/libstdc++/config +INCDIR = libstdc++/libstdc++/include +SUPDIR = libstdc++/libstdc++/libsupc++ + +ifeq ($(CONFIG_ARCH_ARM),y) +CPU_CONFIG = arm +else +CPU_CONFIG = generic +endif + +$(BITSDIR): libstdc++/libstdc++ + $(Q) mkdir -p $(BITSDIR) + +copy_headers: $(BITSDIR) + $(Q) cp $(SUPDIR)/compare $(C++DIR) + $(Q) cp $(SUPDIR)/exception $(C++DIR) + $(Q) cp $(SUPDIR)/initializer_list $(C++DIR) + $(Q) cp $(SUPDIR)/new $(C++DIR) + $(Q) cp $(SUPDIR)/typeinfo $(C++DIR) + $(Q) cp $(TOPDIR)/libs/libbuiltin/libgcc/libgcc/gthr.h $(C++DIR) + $(Q) cp $(TOPDIR)/libs/libbuiltin/libgcc/libgcc/gthr-posix.h $(C++DIR)/gthr-default.h + $(Q) cp $(TOPDIR)/libs/libbuiltin/libgcc/libgcc/unwind-pe.h libstdc++ + $(Q) cp $(SUPDIR)/atomic_lockfree_defines.h $(BITSDIR) + $(Q) cp $(SUPDIR)/cxxabi_forced.h $(BITSDIR) + $(Q) cp $(SUPDIR)/exception_defines.h $(BITSDIR) + $(Q) cp $(SUPDIR)/exception_ptr.h $(BITSDIR) + $(Q) cp $(SUPDIR)/hash_bytes.h $(BITSDIR) + $(Q) cp $(SUPDIR)/nested_exception.h $(BITSDIR) + $(Q) cp $(SUPDIR)/exception.h $(BITSDIR) + $(Q) cp $(SUPDIR)/cxxabi_init_exception.h $(BITSDIR) + $(Q) cp $(CONDIR)/cpu/generic/cpu_defines.h $(BITSDIR) + $(Q) cp $(CONDIR)/cpu/$(CPU_CONFIG)/cxxabi_tweaks.h $(BITSDIR) + $(Q) cp $(CONDIR)/cpu/generic/atomic_word.h $(BITSDIR) + $(Q) cp $(CONDIR)/os/generic/os_defines.h $(BITSDIR) + +context:: copy_headers + +distclean:: + $(call DELDIR, $(BITSDIR)) +ifeq ($(wildcard libstdc++/libstdc++/.git),) + $(call DELDIR, libstdc++) + $(call DELFILE, libstdc++.tar.gz) +endif + +SUPCXXFLAGS += -I$(INCDIR) -I$(SUPDIR) -I$(TOPDIR)/libs/libxx/libstdc++ + +CXXFLAGS += -Wno-undef -Wno-unused-result + +define COMPILESUPCC + $(ECHO_BEGIN)"CC $1 " + $(Q) $(CCACHE) $(CC) -c $(SUPCXXFLAGS) $3 $($(strip $1)_CXXFLAGS) $1 -o $2 + $(ECHO_END) +endef + +ifneq ($(CONFIG_CXX_RTTI),y) +RTTI_SUPSRCS = $(SUPDIR)/eh_arm.cc $(SUPDIR)/eh_call.cc +endif + +SUPSRCS += $(filter-out $(RTTI_SUPSRCS),$(wildcard $(SUPDIR)/*.cc)) +SUPOBJS = $(SUPSRCS:.cc=.o) + +$(SUPOBJS): %.o: %.cc + $(call COMPILESUPCC, $<, $@) + +OBJS += $(SUPOBJS)