/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * Licensed 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. */ #pragma once #include <cstddef> #include <folly/CPortability.h> #include <folly/portability/Config.h> #if defined(_MSC_VER) #define FOLLY_CPLUSPLUS … #else #define FOLLY_CPLUSPLUS … #endif // On MSVC an incorrect <version> header get's picked up #if !defined(_MSC_VER) && __has_include(<version>) #include <version> #endif static_assert …; #if defined(__GNUC__) && !defined(__clang__) static_assert(__GNUC__ >= 10, "__GNUC__ >= 10"); #endif #if defined(_MSC_VER) static_assert(_MSC_VER >= 1920); #endif #if defined(_MSC_VER) || defined(_CPPLIB_VER) static_assert(FOLLY_CPLUSPLUS >= 201703L, "__cplusplus >= 201703L"); #endif // Unaligned loads and stores namespace folly { #if defined(FOLLY_HAVE_UNALIGNED_ACCESS) && FOLLY_HAVE_UNALIGNED_ACCESS constexpr bool kHasUnalignedAccess = …; #else constexpr bool kHasUnalignedAccess = false; #endif } // namespace folly // compiler specific attribute translation // msvc should come first, so if clang is in msvc mode it gets the right defines // NOTE: this will only do checking in msvc with versions that support /analyze #ifdef _MSC_VER #ifdef _USE_ATTRIBUTES_FOR_SAL #undef _USE_ATTRIBUTES_FOR_SAL #endif /* nolint */ #define _USE_ATTRIBUTES_FOR_SAL … #include <sal.h> // @manual #define FOLLY_PRINTF_FORMAT … #define FOLLY_PRINTF_FORMAT_ATTR … #else #define FOLLY_PRINTF_FORMAT … #define FOLLY_PRINTF_FORMAT_ATTR(format_param, dots_param) … #endif // warn unused result #if defined(__has_cpp_attribute) #if __has_cpp_attribute(nodiscard) #if defined(__clang__) || defined(__GNUC__) #if __clang_major__ >= 10 || __GNUC__ >= 10 // early clang and gcc both warn on [[nodiscard]] when applied to class ctors // easiest option is just to avoid emitting [[nodiscard]] under early clang/gcc #define FOLLY_NODISCARD … #endif #endif #endif #endif #ifndef FOLLY_NODISCARD #define FOLLY_NODISCARD #endif // older clang-format gets confused by [[deprecated(...)]] on class decls #define FOLLY_DEPRECATED(...) … // target #ifdef _MSC_VER #define FOLLY_TARGET_ATTRIBUTE … #else #define FOLLY_TARGET_ATTRIBUTE(target) … #endif // detection for 64 bit #if defined(__x86_64__) || defined(_M_X64) #define FOLLY_X64 … #else #define FOLLY_X64 … #endif #if defined(__arm__) #define FOLLY_ARM … #else #define FOLLY_ARM … #endif #if defined(__aarch64__) #define FOLLY_AARCH64 … #else #define FOLLY_AARCH64 … #endif #if defined(__powerpc64__) #define FOLLY_PPC64 … #else #define FOLLY_PPC64 … #endif #if defined(__s390x__) #define FOLLY_S390X … #else #define FOLLY_S390X … #endif #if defined(__riscv) #define FOLLY_RISCV64 … #else #define FOLLY_RISCV64 … #endif namespace folly { constexpr bool kIsArchArm = …; constexpr bool kIsArchAmd64 = …; constexpr bool kIsArchAArch64 = …; constexpr bool kIsArchPPC64 = …; constexpr bool kIsArchS390X = …; constexpr bool kIsArchRISCV64 = …; } // namespace folly namespace folly { /** * folly::kIsLibrarySanitizeAddress reports if folly was compiled with ASAN * enabled. Note that for compilation units outside of folly that include * folly/Portability.h, the value of kIsLibrarySanitizeAddress may be different * from whether or not the current compilation unit is being compiled with ASAN. */ #if FOLLY_LIBRARY_SANITIZE_ADDRESS constexpr bool kIsLibrarySanitizeAddress = true; #else constexpr bool kIsLibrarySanitizeAddress = …; #endif #ifdef FOLLY_SANITIZE_ADDRESS constexpr bool kIsSanitizeAddress = true; #else constexpr bool kIsSanitizeAddress = …; #endif #ifdef FOLLY_SANITIZE_THREAD constexpr bool kIsSanitizeThread = true; #else constexpr bool kIsSanitizeThread = …; #endif #ifdef FOLLY_SANITIZE_DATAFLOW constexpr bool kIsSanitizeDataflow = true; #else constexpr bool kIsSanitizeDataflow = …; #endif #ifdef FOLLY_SANITIZE constexpr bool kIsSanitize = true; #else constexpr bool kIsSanitize = …; #endif #if defined(__OPTIMIZE__) constexpr bool kIsOptimize = true; #else constexpr bool kIsOptimize = …; #endif #if defined(__OPTIMIZE_SIZE__) constexpr bool kIsOptimizeSize = true; #else constexpr bool kIsOptimizeSize = …; #endif } // namespace folly // packing is very ugly in msvc #ifdef _MSC_VER #define FOLLY_PACK_ATTR … #define FOLLY_PACK_PUSH … #define FOLLY_PACK_POP … #elif defined(__GNUC__) #define FOLLY_PACK_ATTR … #define FOLLY_PACK_PUSH … #define FOLLY_PACK_POP … #else #define FOLLY_PACK_ATTR … #define FOLLY_PACK_PUSH … #define FOLLY_PACK_POP … #endif // It turns out that GNU libstdc++ and LLVM libc++ differ on how they implement // the 'std' namespace; the latter uses inline namespaces. Wrap this decision // up in a macro to make forward-declarations easier. #if defined(_LIBCPP_VERSION) #define FOLLY_NAMESPACE_STD_BEGIN … #define FOLLY_NAMESPACE_STD_END … #else #define FOLLY_NAMESPACE_STD_BEGIN … #define FOLLY_NAMESPACE_STD_END … #endif // If the new c++ ABI is used, __cxx11 inline namespace needs to be added to // some types, e.g. std::list. #if defined(_GLIBCXX_USE_CXX11_ABI) && _GLIBCXX_USE_CXX11_ABI #define FOLLY_GLIBCXX_NAMESPACE_CXX11_BEGIN … #define FOLLY_GLIBCXX_NAMESPACE_CXX11_END … #else #define FOLLY_GLIBCXX_NAMESPACE_CXX11_BEGIN #define FOLLY_GLIBCXX_NAMESPACE_CXX11_END #endif // MSVC specific defines // mainly for posix compat #ifdef _MSC_VER // We have compiler support for the newest of the new, but // MSVC doesn't tell us that. // // Clang pretends to be MSVC on Windows, but it refuses to compile // SSE4.2 intrinsics unless -march argument is specified. // So cannot unconditionally define __SSE4_2__ in clang. #ifndef __clang__ #if !defined(_M_ARM) && !defined(_M_ARM64) #define __SSE4_2__ … #endif // !defined(_M_ARM) && !defined(_M_ARM64) // Hide a GCC specific thing that breaks MSVC if left alone. #define __extension__ // compiler specific to compiler specific // nolint #define __PRETTY_FUNCTION__ __FUNCSIG__ #endif #endif // Define FOLLY_HAS_EXCEPTIONS #if (defined(__cpp_exceptions) && __cpp_exceptions >= 199711) || \ FOLLY_HAS_FEATURE(cxx_exceptions) #define FOLLY_HAS_EXCEPTIONS … #elif __GNUC__ #if defined(__EXCEPTIONS) && __EXCEPTIONS #define FOLLY_HAS_EXCEPTIONS … #else // __EXCEPTIONS #define FOLLY_HAS_EXCEPTIONS … #endif // __EXCEPTIONS #elif FOLLY_MICROSOFT_ABI_VER #if _CPPUNWIND #define FOLLY_HAS_EXCEPTIONS … #else // _CPPUNWIND #define FOLLY_HAS_EXCEPTIONS … #endif // _CPPUNWIND #else #define FOLLY_HAS_EXCEPTIONS … #endif // Debug namespace folly { #ifdef NDEBUG constexpr auto kIsDebug = false; #else constexpr auto kIsDebug = …; #endif } // namespace folly // Exceptions namespace folly { #if FOLLY_HAS_EXCEPTIONS constexpr auto kHasExceptions = …; #else constexpr auto kHasExceptions = false; #endif } // namespace folly // Endianness namespace folly { #ifdef _MSC_VER // It's MSVC, so we just have to guess ... and allow an override #ifdef FOLLY_ENDIAN_BE constexpr auto kIsLittleEndian = false; #else constexpr auto kIsLittleEndian = true; #endif #else constexpr auto kIsLittleEndian = …; #endif constexpr auto kIsBigEndian = …; } // namespace folly // Weak namespace folly { #if FOLLY_HAVE_WEAK_SYMBOLS constexpr auto kHasWeakSymbols = true; #else constexpr auto kHasWeakSymbols = …; #endif } // namespace folly #ifndef FOLLY_SSE #if defined(__SSE4_2__) #define FOLLY_SSE … #define FOLLY_SSE_MINOR … #elif defined(__SSE4_1__) #define FOLLY_SSE … #define FOLLY_SSE_MINOR … #elif defined(__SSE4__) #define FOLLY_SSE … #define FOLLY_SSE_MINOR … #elif defined(__SSE3__) #define FOLLY_SSE … #define FOLLY_SSE_MINOR … #elif defined(__SSE2__) #define FOLLY_SSE … #define FOLLY_SSE_MINOR … #elif defined(__SSE__) #define FOLLY_SSE … #define FOLLY_SSE_MINOR … #else #define FOLLY_SSE … #define FOLLY_SSE_MINOR … #endif #endif #ifndef FOLLY_SSSE #if defined(__SSSE3__) #define FOLLY_SSSE … #else #define FOLLY_SSSE … #endif #endif #define FOLLY_SSE_PREREQ(major, minor) … #ifndef FOLLY_NEON #if (defined(__ARM_NEON) || defined(__ARM_NEON__)) && !defined(__CUDACC__) #define FOLLY_NEON … #else #define FOLLY_NEON … #endif #endif #ifndef FOLLY_ARM_FEATURE_CRC32 #ifdef __ARM_FEATURE_CRC32 #define FOLLY_ARM_FEATURE_CRC32 … #else #define FOLLY_ARM_FEATURE_CRC32 … #endif #endif // RTTI may not be enabled for this compilation unit. #if defined(__GXX_RTTI) || defined(__cpp_rtti) || \ (defined(_MSC_VER) && defined(_CPPRTTI)) #define FOLLY_HAS_RTTI … #else #define FOLLY_HAS_RTTI … #endif namespace folly { constexpr bool const kHasRtti = …; } // namespace folly #if defined(__APPLE__) || defined(_MSC_VER) #define FOLLY_STATIC_CTOR_PRIORITY_MAX #else // 101 is the highest priority allowed by the init_priority attribute. // This priority is already used by JEMalloc and other memory allocators so // we will take the next one. #define FOLLY_STATIC_CTOR_PRIORITY_MAX … #endif #if defined(__APPLE__) && TARGET_OS_IOS #define FOLLY_APPLE_IOS … #else #define FOLLY_APPLE_IOS … #endif #if defined(__APPLE__) && TARGET_OS_OSX #define FOLLY_APPLE_MACOS … #else #define FOLLY_APPLE_MACOS … #endif #if defined(__APPLE__) && TARGET_OS_TV #define FOLLY_APPLE_TVOS … #else #define FOLLY_APPLE_TVOS … #endif #if defined(__APPLE__) && TARGET_OS_WATCH #define FOLLY_APPLE_WATCHOS … #else #define FOLLY_APPLE_WATCHOS … #endif namespace folly { #ifdef __OBJC__ constexpr auto kIsObjC = true; #else constexpr auto kIsObjC = …; #endif #if FOLLY_MOBILE constexpr auto kIsMobile = true; #else constexpr auto kIsMobile = …; #endif #if defined(__linux__) && !FOLLY_MOBILE constexpr auto kIsLinux = true; #else constexpr auto kIsLinux = …; #endif #if defined(_WIN32) constexpr auto kIsWindows = true; #else constexpr auto kIsWindows = …; #endif #if defined(__APPLE__) constexpr auto kIsApple = …; #else constexpr auto kIsApple = false; #endif constexpr bool kIsAppleIOS = …; constexpr bool kIsAppleMacOS = …; constexpr bool kIsAppleTVOS = …; constexpr bool kIsAppleWatchOS = …; #if defined(__GLIBCXX__) constexpr auto kIsGlibcxx = true; #else constexpr auto kIsGlibcxx = …; #endif #if defined(__GLIBCXX__) && _GLIBCXX_RELEASE // major version, 7+ constexpr auto kGlibcxxVer = _GLIBCXX_RELEASE; #else constexpr auto kGlibcxxVer = …; #endif #if defined(__GLIBCXX__) && defined(_GLIBCXX_ASSERTIONS) constexpr auto kGlibcxxAssertions = true; #else constexpr auto kGlibcxxAssertions = …; #endif #ifdef _LIBCPP_VERSION constexpr auto kIsLibcpp = …; #else constexpr auto kIsLibcpp = false; #endif #if defined(__GLIBCXX__) constexpr auto kIsLibstdcpp = true; #else constexpr auto kIsLibstdcpp = …; #endif #ifdef _MSC_VER constexpr auto kMscVer = _MSC_VER; #else constexpr auto kMscVer = …; #endif #if defined(__GNUC__) && __GNUC__ constexpr auto kGnuc = …; #else constexpr auto kGnuc = 0; #endif #if __clang__ constexpr auto kIsClang = …; constexpr auto kClangVerMajor = …; #else constexpr auto kIsClang = false; constexpr auto kClangVerMajor = 0; #endif #ifdef FOLLY_MICROSOFT_ABI_VER constexpr auto kMicrosoftAbiVer = FOLLY_MICROSOFT_ABI_VER; #else constexpr auto kMicrosoftAbiVer = …; #endif // cpplib is an implementation of the standard library, and is the one typically // used with the msvc compiler #ifdef _CPPLIB_VER constexpr auto kCpplibVer = _CPPLIB_VER; #else constexpr auto kCpplibVer = …; #endif } // namespace folly // MSVC does not permit: // // extern int const num; // constexpr int const num = 3; // // Instead: // // extern int const num; // FOLLY_STORAGE_CONSTEXPR int const num = 3; // // True as of MSVC 2017. #ifdef _MSC_VER #define FOLLY_STORAGE_CONSTEXPR #else #define FOLLY_STORAGE_CONSTEXPR … #endif // FOLLY_CXX20_CONSTEXPR // // C++20 permits more cases to be marked constexpr, including constructors that // leave members uninitialized and virtual functions. #if FOLLY_CPLUSPLUS >= 202002L #define FOLLY_CXX20_CONSTEXPR … #else #define FOLLY_CXX20_CONSTEXPR #endif // FOLLY_CXX23_CONSTEXPR // // C++23 permits more cases to be marked constexpr, including definitions of // variables of non-literal type in constexpr function as long as they are not // constant-evaluated. #if FOLLY_CPLUSPLUS >= 202302L #define FOLLY_CXX23_CONSTEXPR … #else #define FOLLY_CXX23_CONSTEXPR #endif // C++20 constinit #if defined(__cpp_constinit) && __cpp_constinit >= 201907L #define FOLLY_CONSTINIT … #else #define FOLLY_CONSTINIT #endif #if defined(FOLLY_CFG_NO_COROUTINES) #define FOLLY_HAS_COROUTINES … #else // folly::coro requires C++17 support #if defined(__NVCC__) // For now, NVCC matches other compilers but does not offer coroutines. #define FOLLY_HAS_COROUTINES … #elif defined(_WIN32) && defined(__clang__) && !defined(LLVM_COROUTINES) // LLVM and MSVC coroutines are ABI incompatible, so for the MSVC implementation // of <experimental/coroutine> on Windows we *don't* have coroutines. // // LLVM_COROUTINES indicates that LLVM compatible header is added to include // path and can be used. // // Worse, if we define FOLLY_HAS_COROUTINES 1 we will include // <experimental/coroutine> which will conflict with anyone who wants to load // the LLVM implementation of coroutines on Windows. #define FOLLY_HAS_COROUTINES … #elif defined(_MSC_VER) && _MSC_VER && defined(_RESUMABLE_FUNCTIONS_SUPPORTED) // NOTE: MSVC 2017 does not currently support the full Coroutines TS since it // does not yet support symmetric-transfer. #define FOLLY_HAS_COROUTINES … #elif ( \ (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L) || \ (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L)) && \ (__has_include(<coroutine>) || __has_include(<experimental/coroutine>)) #define FOLLY_HAS_COROUTINES … // This is mainly to workaround bugs triggered by LTO, when stack allocated // variables in await_suspend end up on a coroutine frame. #define FOLLY_CORO_AWAIT_SUSPEND_NONTRIVIAL_ATTRIBUTES … #else #define FOLLY_HAS_COROUTINES … #endif #endif // FOLLY_CFG_NO_COROUTINES // C++20 consteval #if FOLLY_CPLUSPLUS >= 202002L #define FOLLY_CONSTEVAL … #else #define FOLLY_CONSTEVAL … #endif
Codebase Browser
folly