From 78da6db1f23c0bfe8a36a5b5c05d06005037e556 Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Mon, 9 Jan 2017 21:23:41 +0000 Subject: [PATCH] Vendor import of libc++ trunk r291476: https://llvm.org/svn/llvm-project/libcxx/trunk@291476 --- CMakeLists.txt | 33 +- CREDITS.TXT | 4 + docs/DesignDocs/ThreadingSupportAPI.rst | 70 ++++ docs/DesignDocs/VisibilityMacros.rst | 2 +- docs/index.rst | 2 +- include/__bit_reference | 14 +- include/__config | 67 ++-- include/__config_site.in | 1 + include/__debug | 6 +- include/__functional_base | 17 +- include/__hash_table | 21 +- include/__sso_allocator | 4 +- include/__threading_support | 312 +++++++++++++++--- include/algorithm | 22 +- include/atomic | 12 +- include/experimental/algorithm | 4 +- include/experimental/dynarray | 13 +- include/experimental/iterator | 10 +- include/istream | 7 +- include/memory | 14 +- include/module.modulemap | 1 - include/new | 4 +- include/ostream | 2 +- include/regex | 66 ++-- include/string_view | 37 +++ include/support/win32/support.h | 4 +- include/thread | 15 +- include/type_traits | 6 +- include/valarray | 3 +- lib/CMakeLists.txt | 2 +- src/chrono.cpp | 48 ++- src/exception.cpp | 34 +- src/experimental/memory_resource.cpp | 2 +- src/include/config_elast.h | 2 +- src/iostream.cpp | 52 ++- src/locale.cpp | 2 +- src/thread.cpp | 7 + test/CMakeLists.txt | 2 +- .../iterators/trivial_iterators.pass.cpp | 3 +- test/libcxx/test/config.py | 59 ++-- test/libcxx/test/executor.py | 25 +- test/libcxx/test/format.py | 5 - test/lit.site.cfg.in | 2 +- .../sequences/array/iterators.pass.cpp | 4 +- .../istream/istream.cons/copy.fail.cpp | 55 +++ .../istream/istream.cons/move.pass.cpp | 8 +- .../iterator.range/begin-end.pass.cpp | 6 +- .../string_view.literals/literal.pass.cpp | 57 ++++ .../string_view.literals/literal1.fail.cpp | 23 ++ .../string_view.literals/literal1.pass.cpp | 25 ++ .../string_view.literals/literal2.fail.cpp | 21 +- .../string_view.literals/literal2.pass.cpp | 25 ++ .../string_view.literals/literal3.pass.cpp | 25 ++ .../util.smartptr.shared/test_deleter.h | 4 +- .../op_mod=duration.pass.cpp | 2 +- .../op_mod=rep.pass.cpp | 2 +- .../op_times=.pass.cpp | 2 +- test/support/disable_missing_braces_warning.h | 2 + test/support/external_threads.cpp | 2 +- test/support/nasty_macros.hpp | 7 + test/support/test_iterators.h | 2 +- www/cxx1z_status.html | 2 +- 62 files changed, 996 insertions(+), 296 deletions(-) create mode 100644 docs/DesignDocs/ThreadingSupportAPI.rst create mode 100644 test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp create mode 100644 test/std/strings/string.view/string_view.literals/literal.pass.cpp create mode 100644 test/std/strings/string.view/string_view.literals/literal1.fail.cpp create mode 100644 test/std/strings/string.view/string_view.literals/literal1.pass.cpp rename include/__undef___deallocate => test/std/strings/string.view/string_view.literals/literal2.fail.cpp (52%) create mode 100644 test/std/strings/string.view/string_view.literals/literal2.pass.cpp create mode 100644 test/std/strings/string.view/string_view.literals/literal3.pass.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 803e8f717a82..9fa0ed37e58e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -116,7 +116,12 @@ if (LIBCXX_CXX_ABI STREQUAL "default") set(LIBCXX_CXX_ABI_INCLUDE_PATHS "${LIBCXX_LIBCXXABI_INCLUDES_INTERNAL}") set(LIBCXX_CXX_ABI_INTREE 1) else() - set(LIBCXX_CXX_ABI_LIBNAME "default") + if (WIN32 AND NOT MINGW) + # FIXME: Figure out how to configure the ABI library on Windows. + set(LIBCXX_CXX_ABI_LIBNAME "none") + else() + set(LIBCXX_CXX_ABI_LIBNAME "default") + endif() endif() else() set(LIBCXX_CXX_ABI_LIBNAME "${LIBCXX_CXX_ABI}") @@ -169,6 +174,9 @@ option(LIBCXX_HAS_PTHREAD_API "Ignore auto-detection and force use of pthread AP option(LIBCXX_HAS_EXTERNAL_THREAD_API "Build libc++ with an externalized threading API. This option may only be set to ON when LIBCXX_ENABLE_THREADS=ON." OFF) +option(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY + "Build libc++ with an externalized threading library. + This option may only be set to ON when LIBCXX_ENABLE_THREADS=ON" OFF) # Misc options ---------------------------------------------------------------- # FIXME: Turn -pedantic back ON. It is currently off because it warns @@ -230,12 +238,24 @@ if(NOT LIBCXX_ENABLE_THREADS) message(FATAL_ERROR "LIBCXX_HAS_EXTERNAL_THREAD_API can only be set to ON" " when LIBCXX_ENABLE_THREADS is also set to ON.") endif() + if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY) + message(FATAL_ERROR "LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY can only be set " + "to ON when LIBCXX_ENABLE_THREADS is also set to ON.") + endif() + endif() -if(LIBCXX_HAS_PTHREAD_API AND LIBCXX_HAS_EXTERNAL_THREAD_API) - message(FATAL_ERROR "The options LIBCXX_HAS_EXTERNAL_THREAD_API" - "and LIBCXX_HAS_PTHREAD_API cannot be both" - "set to ON at the same time.") +if (LIBCXX_HAS_EXTERNAL_THREAD_API) + if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY) + message(FATAL_ERROR "The options LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY and " + "LIBCXX_HAS_EXTERNAL_THREAD_API cannot both be ON at " + "the same time") + endif() + if (LIBCXX_HAS_PTHREAD_API) + message(FATAL_ERROR "The options LIBCXX_HAS_EXTERNAL_THREAD_API" + "and LIBCXX_HAS_PTHREAD_API cannot be both" + "set to ON at the same time.") + endif() endif() # Ensure LLVM_USE_SANITIZER is not specified when LIBCXX_GENERATE_COVERAGE @@ -441,7 +461,7 @@ if (NOT LIBCXX_ENABLE_RTTI) endif() # Threading flags ============================================================= -if (LIBCXX_HAS_EXTERNAL_THREAD_API AND LIBCXX_ENABLE_SHARED) +if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY AND LIBCXX_ENABLE_SHARED) # Need to allow unresolved symbols if this is to work with shared library builds if (APPLE) add_link_flags("-undefined dynamic_lookup") @@ -520,6 +540,7 @@ config_define_if_not(LIBCXX_ENABLE_THREAD_UNSAFE_C_FUNCTIONS _LIBCPP_HAS_NO_THRE config_define_if(LIBCXX_HAS_PTHREAD_API _LIBCPP_HAS_THREAD_API_PTHREAD) config_define_if(LIBCXX_HAS_EXTERNAL_THREAD_API _LIBCPP_HAS_THREAD_API_EXTERNAL) +config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC) # By default libc++ on Windows expects to use a shared library, which requires diff --git a/CREDITS.TXT b/CREDITS.TXT index ceb12c42b965..1311e05c4298 100644 --- a/CREDITS.TXT +++ b/CREDITS.TXT @@ -80,6 +80,10 @@ N: Andrew Morrow E: andrew.c.morrow@gmail.com D: Minor patches and Linux fixes. +N: Michael Park +E: mpark@apache.org +D: Implementation of . + N: Arvid Picciani E: aep at exys dot org D: Minor patches and musl port. diff --git a/docs/DesignDocs/ThreadingSupportAPI.rst b/docs/DesignDocs/ThreadingSupportAPI.rst new file mode 100644 index 000000000000..77ec6bce12ba --- /dev/null +++ b/docs/DesignDocs/ThreadingSupportAPI.rst @@ -0,0 +1,70 @@ +===================== +Threading Support API +===================== + +.. contents:: + :local: + +Overview +======== + +Libc++ supports using multiple different threading models and configurations +to implement the threading parts of libc++, including ```` and ````. +These different models provide entirely different interfaces from each +other. To address this libc++ wraps the underlying threading API in a new and +consistent API, which it uses internally to implement threading primitives. + +The ``<__threading_support>`` header is where libc++ defines its internal +threading interface. It contains forward declarations of the internal threading +interface as well as definitions for the interface. + +External Threading API and the ``<__external_threading>`` header +================================================================ + +In order to support vendors with custom threading API's libc++ allows the +entire internal threading interface to be provided by an external, +vendor provided, header. + +When ``_LIBCPP_HAS_THREAD_API_EXTERNAL`` is defined the ``<__threading_support>`` +header simply forwards to the ``<__external_threading>`` header (which must exist). +It is expected that the ``<__external_threading>`` header provide the exact +interface normally provided by ``<__threading_support>``. + +External Threading Library +========================== + +Normally ``<__threading_support>`` provides inline definitions to each internal +threading API function it declares. However libc++ also supports using an +external library to provide the definitions. + +When ``_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL`` libc++ does not provide inline +definitions for the internal API, instead assuming the definitions will be +provided by an external library. + +Threading Configuration Macros +============================== + +**_LIBCPP_HAS_NO_THREADS** + This macro is defined when libc++ is built without threading support. It + should not be manually defined by the user. + +**_LIBCPP_HAS_THREAD_API_EXTERNAL** + This macro is defined when libc++ should use the ``<__external_threading>`` + header to provide the internal threading API. This macro overrides + ``_LIBCPP_HAS_THREAD_API_PTHREAD``. + +**_LIBCPP_HAS_THREAD_API_PTHREAD** + This macro is defined when libc++ should use POSIX threads to implement the + internal threading API. + +**_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL** + This macro is defined when libc++ expects the definitions of the internal + threading API to be provided by an external library. When defined + ``<__threading_support>`` will only provide the forward declarations and + typedefs for the internal threading API. + +**_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL** + This macro is used to build an external threading library using the + ``<__threading_support>``. Specifically it exposes the threading API + definitions in ``<__threading_support>`` as non-inline definitions meant to + be compiled into a library. diff --git a/docs/DesignDocs/VisibilityMacros.rst b/docs/DesignDocs/VisibilityMacros.rst index 37539ec88884..7c6f39c44b48 100644 --- a/docs/DesignDocs/VisibilityMacros.rst +++ b/docs/DesignDocs/VisibilityMacros.rst @@ -49,7 +49,7 @@ Visibility Macros attribute. With GCC the `visibility(...)` attribute is used and member functions are affected. -**_LIBCPP_TEMPLATE_ONLY** +**_LIBCPP_TEMPLATE_VIS** The same as `_LIBCPP_TYPE_VIS` except that it may be applied to class templates. diff --git a/docs/index.rst b/docs/index.rst index 8f21a27fe763..9e72ca9d47a4 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -131,7 +131,7 @@ Design Documents DesignDocs/CapturingConfigInfo DesignDocs/ABIVersioning DesignDocs/VisibilityMacros - + DesignDocs/ThreadingSupportAPI * ` design `_ * ` design `_ diff --git a/include/__bit_reference b/include/__bit_reference index 8f245463c91d..9aea96145284 100644 --- a/include/__bit_reference +++ b/include/__bit_reference @@ -40,11 +40,8 @@ class __bit_reference __storage_pointer __seg_; __storage_type __mask_; -#if defined(__clang__) || defined(__IBMCPP__) || defined(_LIBCPP_MSVC) friend typename _Cp::__self; -#else - friend class _Cp::__self; -#endif + friend class __bit_const_reference<_Cp>; friend class __bit_iterator<_Cp, false>; public: @@ -130,11 +127,7 @@ class __bit_const_reference __storage_pointer __seg_; __storage_type __mask_; -#if defined(__clang__) || defined(__IBMCPP__) || defined(_LIBCPP_MSVC) friend typename _Cp::__self; -#else - friend class _Cp::__self; -#endif friend class __bit_iterator<_Cp, true>; public: _LIBCPP_INLINE_VISIBILITY @@ -1221,11 +1214,8 @@ private: __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT : __seg_(__s), __ctz_(__ctz) {} -#if defined(__clang__) || defined(__IBMCPP__) || defined(_LIBCPP_MSVC) friend typename _Cp::__self; -#else - friend class _Cp::__self; -#endif + friend class __bit_reference<_Cp>; friend class __bit_const_reference<_Cp>; friend class __bit_iterator<_Cp, true>; diff --git a/include/__config b/include/__config index ffd37c1fbc1b..fedec61126e1 100644 --- a/include/__config +++ b/include/__config @@ -101,6 +101,25 @@ #define __is_identifier(__x) 1 #endif +#if defined(__clang__) +#define _LIBCPP_COMPILER_CLANG +#elif defined(__GNUC__) +#define _LIBCPP_COMPILER_GCC +#elif defined(_MSC_VER) +#define _LIBCPP_COMPILER_MSVC +#elif defined(__IBMCPP__) +#define _LIBCPP_COMPILER_IBM +#endif + +// FIXME: ABI detection should be done via compiler builtin macros. This +// is just a placeholder until Clang implements such macros. For now assume +// that Windows compilers pretending to be MSVC++ target the microsoft ABI. +#if defined(_WIN32) && defined(_MSC_VER) +# define _LIBCPP_ABI_MICROSOFT +#else +# define _LIBCPP_ABI_ITANIUM +#endif + // Need to detect which libc we're using if we're on Linux. #if defined(__linux__) #include @@ -164,16 +183,7 @@ # define _LIBCPP_LITTLE_ENDIAN 1 # define _LIBCPP_BIG_ENDIAN 0 # define _LIBCPP_SHORT_WCHAR 1 -// Compiler intrinsics (MSVC) -# if defined(_MSC_VER) && _MSC_VER >= 1400 -# define _LIBCPP_HAS_IS_BASE_OF -# endif -# if defined(_MSC_VER) && !defined(__clang__) -# define _LIBCPP_MSVC // Using Microsoft Visual C++ compiler -# define _LIBCPP_TOSTRING2(x) #x -# define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x) -# define _LIBCPP_WARNING(x) __pragma(message(__FILE__ "(" _LIBCPP_TOSTRING(__LINE__) ") : warning note: " x)) -# endif + // If mingw not explicitly detected, assume using MS C runtime only. # ifndef __MINGW32__ # define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library @@ -230,7 +240,7 @@ #define _LIBCPP_NO_CFI #endif -#if defined(__clang__) +#if defined(_LIBCPP_COMPILER_CLANG) // _LIBCPP_ALTERNATE_STRING_LAYOUT is an old name for // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT left here for backward compatibility. @@ -275,10 +285,6 @@ typedef __char32_t char32_t; # define _LIBCPP_NORETURN __attribute__ ((noreturn)) #endif -#if !(__has_feature(cxx_deleted_functions)) -#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS -#endif // !(__has_feature(cxx_deleted_functions)) - #if !(__has_feature(cxx_lambdas)) #define _LIBCPP_HAS_NO_LAMBDAS #endif @@ -390,7 +396,7 @@ namespace std { #define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow"))) #endif -#elif defined(__GNUC__) +#elif defined(_LIBCPP_COMPILER_GCC) #define _ALIGNAS(x) __attribute__((__aligned__(x))) #define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x)))) @@ -431,7 +437,6 @@ namespace std { #ifndef __GXX_EXPERIMENTAL_CXX0X__ #define _LIBCPP_HAS_NO_DECLTYPE -#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS #define _LIBCPP_HAS_NO_NULLPTR #define _LIBCPP_HAS_NO_UNICODE_CHARS #define _LIBCPP_HAS_NO_VARIADICS @@ -448,7 +453,6 @@ namespace std { #if _GNUC_VER < 404 #define _LIBCPP_HAS_NO_DECLTYPE -#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS #define _LIBCPP_HAS_NO_UNICODE_CHARS #define _LIBCPP_HAS_NO_VARIADICS #define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS @@ -475,15 +479,23 @@ using namespace _LIBCPP_NAMESPACE __attribute__((__strong__)); #define _LIBCPP_HAS_NO_ASAN #endif -#elif defined(_LIBCPP_MSVC) +#elif defined(_LIBCPP_COMPILER_MSVC) +#define _LIBCPP_TOSTRING2(x) #x +#define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x) +#define _LIBCPP_WARNING(x) __pragma(message(__FILE__ "(" _LIBCPP_TOSTRING(__LINE__) ") : warning note: " x)) + +#if _MSC_VER < 1900 +#error "MSVC versions prior to Visual Studio 2015 are not supported" +#endif + +#define _LIBCPP_HAS_IS_BASE_OF #define _LIBCPP_HAS_NO_CONSTEXPR #define _LIBCPP_HAS_NO_CXX14_CONSTEXPR #define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES #if _MSC_VER <= 1800 #define _LIBCPP_HAS_NO_UNICODE_CHARS #endif -#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS #define _LIBCPP_HAS_NO_NOEXCEPT #define __alignof__ __alignof #define _LIBCPP_NORETURN __declspec(noreturn) @@ -500,7 +512,7 @@ namespace std { #define _LIBCPP_HAS_NO_ASAN -#elif defined(__IBMCPP__) +#elif defined(_LIBCPP_COMPILER_IBM) #define _ALIGNAS(x) __attribute__((__aligned__(x))) #define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x)))) @@ -530,7 +542,7 @@ namespace std { #define _LIBCPP_HAS_NO_ASAN -#endif // __clang__ || __GNUC__ || _MSC_VER || __IBMCPP__ +#endif // _LIBCPP_COMPILER_[CLANG|GCC|MSVC|IBM] #if defined(__ELF__) #define _LIBCPP_OBJECT_FORMAT_ELF 1 @@ -566,7 +578,7 @@ namespace std { #define _LIBCPP_FUNC_VIS_ONLY #define _LIBCPP_ENUM_VIS -#if defined(_LIBCPP_MSVC) +#if defined(_LIBCPP_COMPILER_MSVC) # define _LIBCPP_INLINE_VISIBILITY __forceinline # define _LIBCPP_ALWAYS_INLINE __forceinline # define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __forceinline @@ -739,7 +751,7 @@ template struct __static_assert_check {}; #define _LIBCPP_DEFAULT = default; #endif -#ifdef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifdef _LIBCPP_CXX03_LANG #define _LIBCPP_EQUAL_DELETE #else #define _LIBCPP_EQUAL_DELETE = delete @@ -892,8 +904,7 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container( // Thread API #if !defined(_LIBCPP_HAS_NO_THREADS) && \ - !defined(_LIBCPP_HAS_THREAD_API_PTHREAD) && \ - !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL) + !defined(_LIBCPP_HAS_THREAD_API_PTHREAD) # if defined(__FreeBSD__) || \ defined(__Fuchsia__) || \ defined(__NetBSD__) || \ @@ -901,7 +912,9 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container( defined(__APPLE__) || \ defined(__CloudABI__) || \ defined(__sun__) -# define _LIBCPP_HAS_THREAD_API_PTHREAD +# define _LIBCPP_HAS_THREAD_API_PTHREAD +# elif defined(_LIBCPP_WIN32API) +# define _LIBCPP_HAS_THREAD_API_WIN32 # else # error "No thread API" # endif // _LIBCPP_HAS_THREAD_API diff --git a/include/__config_site.in b/include/__config_site.in index f2a1986888ba..667b4e94ccc9 100644 --- a/include/__config_site.in +++ b/include/__config_site.in @@ -21,6 +21,7 @@ #cmakedefine _LIBCPP_HAS_MUSL_LIBC #cmakedefine _LIBCPP_HAS_THREAD_API_PTHREAD #cmakedefine _LIBCPP_HAS_THREAD_API_EXTERNAL +#cmakedefine _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS #endif // _LIBCPP_CONFIG_SITE diff --git a/include/__debug b/include/__debug index 19f079bf2fc0..d95e339310d4 100644 --- a/include/__debug +++ b/include/__debug @@ -122,7 +122,7 @@ struct _LIBCPP_TYPE_VIS __i_node __i_node* __next_; __c_node* __c_; -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifndef _LIBCPP_CXX03_LANG __i_node(const __i_node&) = delete; __i_node& operator=(const __i_node&) = delete; #else @@ -145,7 +145,7 @@ struct _LIBCPP_TYPE_VIS __c_node __i_node** end_; __i_node** cap_; -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifndef _LIBCPP_CXX03_LANG __c_node(const __c_node&) = delete; __c_node& operator=(const __c_node&) = delete; #else @@ -232,7 +232,7 @@ class _LIBCPP_TYPE_VIS __libcpp_db __libcpp_db(); public: -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifndef _LIBCPP_CXX03_LANG __libcpp_db(const __libcpp_db&) = delete; __libcpp_db& operator=(const __libcpp_db&) = delete; #else diff --git a/include/__functional_base b/include/__functional_base index 8589d04408b4..05c9f066fd0f 100644 --- a/include/__functional_base +++ b/include/__functional_base @@ -552,23 +552,10 @@ cref(reference_wrapper<_Tp> __t) _NOEXCEPT return cref(__t.get()); } -#ifndef _LIBCPP_HAS_NO_VARIADICS -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS - +#ifndef _LIBCPP_CXX03_LANG template void ref(const _Tp&&) = delete; template void cref(const _Tp&&) = delete; - -#else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS - -template void ref(const _Tp&&);// = delete; -template void cref(const _Tp&&);// = delete; - -#endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS - -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - -#endif // _LIBCPP_HAS_NO_VARIADICS +#endif #if _LIBCPP_STD_VER > 11 template diff --git a/include/__hash_table b/include/__hash_table index 1c35ec36fe40..e082e6c812f5 100644 --- a/include/__hash_table +++ b/include/__hash_table @@ -20,7 +20,6 @@ #include #include <__undef_min_max> -#include <__undef___deallocate> #include <__debug> @@ -1321,7 +1320,7 @@ private: void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {} #endif // _LIBCPP_CXX03_LANG - void __deallocate(__next_pointer __np) _NOEXCEPT; + void __deallocate_node(__next_pointer __np) _NOEXCEPT; __next_pointer __detach() _NOEXCEPT; template friend class _LIBCPP_TEMPLATE_VIS unordered_map; @@ -1454,7 +1453,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table() "Predicate must be copy-constructible."); static_assert((is_copy_constructible::value), "Hasher must be copy-constructible."); - __deallocate(__p1_.first().__next_); + __deallocate_node(__p1_.first().__next_); #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__erase_c(this); #endif @@ -1492,7 +1491,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u) template void -__hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__next_pointer __np) +__hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate_node(__next_pointer __np) _NOEXCEPT { __node_allocator& __na = __node_alloc(); @@ -1599,11 +1598,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign( } catch (...) { - __deallocate(__cache); + __deallocate_node(__cache); throw; } #endif // _LIBCPP_NO_EXCEPTIONS - __deallocate(__cache); + __deallocate_node(__cache); } const_iterator __i = __u.begin(); while (__u.size() != 0) @@ -1661,11 +1660,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first } catch (...) { - __deallocate(__cache); + __deallocate_node(__cache); throw; } #endif // _LIBCPP_NO_EXCEPTIONS - __deallocate(__cache); + __deallocate_node(__cache); } for (; __first != __last; ++__first) __insert_unique(*__first); @@ -1701,11 +1700,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first, } catch (...) { - __deallocate(__cache); + __deallocate_node(__cache); throw; } #endif // _LIBCPP_NO_EXCEPTIONS - __deallocate(__cache); + __deallocate_node(__cache); } for (; __first != __last; ++__first) __insert_multi(_NodeTypes::__get_value(*__first)); @@ -1765,7 +1764,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT { if (size() > 0) { - __deallocate(__p1_.first().__next_); + __deallocate_node(__p1_.first().__next_); __p1_.first().__next_ = nullptr; size_type __bc = bucket_count(); for (size_type __i = 0; __i < __bc; ++__i) diff --git a/include/__sso_allocator b/include/__sso_allocator index ca3b937c0138..8147e75ec2c8 100644 --- a/include/__sso_allocator +++ b/include/__sso_allocator @@ -15,8 +15,6 @@ #include #include -#include <__undef___deallocate> - #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif @@ -64,7 +62,7 @@ public: if (__p == (pointer)&buf_) __allocated_ = false; else - _VSTD::__deallocate(__p); + _VSTD::__libcpp_deallocate(__p); } _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);} diff --git a/include/__threading_support b/include/__threading_support index b4383b92c287..b2c3b1fc6376 100644 --- a/include/__threading_support +++ b/include/__threading_support @@ -17,39 +17,24 @@ #pragma GCC system_header #endif -#ifndef _LIBCPP_HAS_NO_THREADS - -#ifndef __libcpp_has_include - #ifndef __has_include - #define __libcpp_has_include(x) 0 - #else - #define __libcpp_has_include(x) __has_include(x) - #endif -#endif - -#if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL) && \ - !__libcpp_has_include(<__external_threading>) -// If the <__external_threading> header is absent, build libc++ against a -// pthread-oriented thread api but leave out its implementation. This setup -// allows building+testing of an externally-threaded library variant (on any -// platform that supports pthreads). Here, an 'externally-threaded' library -// variant is one where the implementation of the libc++ thread api is provided -// as a separate library. -#define _LIBCPP_HAS_THREAD_API_EXTERNAL_PTHREAD -#endif - -#if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL) && \ - __libcpp_has_include(<__external_threading>) -#include <__external_threading> -#else - -#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) || \ - defined(_LIBCPP_HAS_THREAD_API_EXTERNAL_PTHREAD) -#include -#include -#endif - #if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL) +# include <__external_threading> +#elif !defined(_LIBCPP_HAS_NO_THREADS) + +#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) +# include +# include +#elif defined(_LIBCPP_HAS_THREAD_API_WIN32) +#include +#include +#include +#include + +#include +#endif + +#if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ + defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) #define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS #else #define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY @@ -57,8 +42,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD -#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) || \ - defined(_LIBCPP_HAS_THREAD_API_EXTERNAL_PTHREAD) +#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) // Mutex typedef pthread_mutex_t __libcpp_mutex_t; #define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER @@ -81,6 +65,33 @@ typedef pthread_t __libcpp_thread_t; // Thrad Local Storage typedef pthread_key_t __libcpp_tls_key; + +#define _LIBCPP_TLS_DESTRUCTOR_CC +#else +// Mutex +typedef SRWLOCK __libcpp_mutex_t; +#define _LIBCPP_MUTEX_INITIALIZER SRWLOCK_INIT + +typedef CRITICAL_SECTION __libcpp_recursive_mutex_t; + +// Condition Variable +typedef CONDITION_VARIABLE __libcpp_condvar_t; +#define _LIBCPP_CONDVAR_INITIALIZER CONDITION_VARIABLE_INIT + +// Execute Once +typedef INIT_ONCE __libcpp_exec_once_flag; +#define _LIBCPP_EXEC_ONCE_INITIALIZER INIT_ONCE_STATIC_INIT + +// Thread ID +typedef DWORD __libcpp_thread_id; + +// Thread +typedef HANDLE __libcpp_thread_t; + +// Thread Local Storage +typedef DWORD __libcpp_tls_key; + +#define _LIBCPP_TLS_DESTRUCTOR_CC WINAPI #endif // Mutex @@ -167,7 +178,8 @@ void __libcpp_thread_yield(); // Thread local storage _LIBCPP_THREAD_ABI_VISIBILITY -int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *)); +int __libcpp_tls_create(__libcpp_tls_key* __key, + void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*)); _LIBCPP_THREAD_ABI_VISIBILITY void *__libcpp_tls_get(__libcpp_tls_key __key); @@ -175,8 +187,10 @@ void *__libcpp_tls_get(__libcpp_tls_key __key); _LIBCPP_THREAD_ABI_VISIBILITY int __libcpp_tls_set(__libcpp_tls_key __key, void *__p); -#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) || \ - defined(_LIBCPP_BUILDING_THREAD_API_EXTERNAL_PTHREAD) +#if !defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ + defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) + +#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m) { @@ -342,12 +356,230 @@ int __libcpp_tls_set(__libcpp_tls_key __key, void *__p) return pthread_setspecific(__key, __p); } +#elif defined(_LIBCPP_HAS_THREAD_API_WIN32) + +// Mutex +int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m) +{ + InitializeCriticalSection(__m); + return 0; +} + +int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m) +{ + EnterCriticalSection(__m); + return 0; +} + +int __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m) +{ + TryEnterCriticalSection(__m); + return 0; +} + +int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m) +{ + LeaveCriticalSection(__m); + return 0; +} + +int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m) +{ + static_cast(__m); + return 0; +} + +int __libcpp_mutex_lock(__libcpp_mutex_t *__m) +{ + AcquireSRWLockExclusive(__m); + return 0; +} + +int __libcpp_mutex_trylock(__libcpp_mutex_t *__m) +{ + TryAcquireSRWLockExclusive(__m); + return 0; +} + +int __libcpp_mutex_unlock(__libcpp_mutex_t *__m) +{ + ReleaseSRWLockExclusive(__m); + return 0; +} + +int __libcpp_mutex_destroy(__libcpp_mutex_t *__m) +{ + static_cast(__m); + return 0; +} + +// Condition Variable +int __libcpp_condvar_signal(__libcpp_condvar_t *__cv) +{ + WakeConditionVariable(__cv); + return 0; +} + +int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv) +{ + WakeAllConditionVariable(__cv); + return 0; +} + +int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m) +{ + SleepConditionVariableSRW(__cv, __m, INFINITE, 0); + return 0; +} + +int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, + timespec *__ts) +{ + using namespace _VSTD::chrono; + + auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec); + auto abstime = + system_clock::time_point(duration_cast(duration)); + auto timeout_ms = duration_cast(abstime - system_clock::now()); + + if (!SleepConditionVariableSRW(__cv, __m, + timeout_ms.count() > 0 ? timeout_ms.count() + : 0, + 0)) + return GetLastError(); + return 0; +} + +int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv) +{ + static_cast(__cv); + return 0; +} + +// Execute Once +static inline _LIBCPP_ALWAYS_INLINE BOOL CALLBACK +__libcpp_init_once_execute_once_thunk(PINIT_ONCE __init_once, PVOID __parameter, + PVOID *__context) +{ + static_cast(__init_once); + static_cast(__context); + + void (*init_routine)(void) = reinterpret_cast(__parameter); + init_routine(); + return TRUE; +} + +int __libcpp_execute_once(__libcpp_exec_once_flag *__flag, + void (*__init_routine)(void)) +{ + if (!InitOnceExecuteOnce(__flag, __libcpp_init_once_execute_once_thunk, + reinterpret_cast(__init_routine), NULL)) + return GetLastError(); + return 0; +} + +// Thread ID +bool __libcpp_thread_id_equal(__libcpp_thread_id __lhs, + __libcpp_thread_id __rhs) +{ + return __lhs == __rhs; +} + +bool __libcpp_thread_id_less(__libcpp_thread_id __lhs, __libcpp_thread_id __rhs) +{ + return __lhs < __rhs; +} + +// Thread +struct __libcpp_beginthreadex_thunk_data +{ + void *(*__func)(void *); + void *__arg; +}; + +static inline _LIBCPP_ALWAYS_INLINE unsigned int WINAPI +__libcpp_beginthreadex_thunk(void *__data) +{ + __libcpp_beginthreadex_thunk_data data = + *reinterpret_cast<__libcpp_beginthreadex_thunk_data *>(__data); + delete reinterpret_cast<__libcpp_beginthreadex_thunk_data *>(__data); + return reinterpret_cast(data.__func(data.__arg)); +} + +int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), + void *__arg) +{ + auto *data = new __libcpp_beginthreadex_thunk_data; + data->__func = __func; + data->__arg = __arg; + + *__t = reinterpret_cast(_beginthreadex(NULL, 0, + __libcpp_beginthreadex_thunk, + data, 0, NULL)); + if (*__t) + return 0; + return GetLastError(); +} + +__libcpp_thread_id __libcpp_thread_get_current_id() +{ + return GetCurrentThreadId(); +} + +__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t) +{ + return GetThreadId(*__t); +} + +int __libcpp_thread_join(__libcpp_thread_t *__t) +{ + if (WaitForSingleObjectEx(*__t, INFINITE, FALSE) == WAIT_FAILED) + return GetLastError(); + if (!CloseHandle(*__t)) + return GetLastError(); + return 0; +} + +int __libcpp_thread_detach(__libcpp_thread_t *__t) +{ + if (!CloseHandle(*__t)) + return GetLastError(); + return 0; +} + +void __libcpp_thread_yield() +{ + SwitchToThread(); +} + +// Thread Local Storage +int __libcpp_tls_create(__libcpp_tls_key* __key, + void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*)) +{ + *__key = FlsAlloc(__at_exit); + if (*__key == FLS_OUT_OF_INDEXES) + return GetLastError(); + return 0; +} + +void *__libcpp_tls_get(__libcpp_tls_key __key) +{ + return FlsGetValue(__key); +} + +int __libcpp_tls_set(__libcpp_tls_key __key, void *__p) +{ + if (!FlsSetValue(__key, __p)) + return GetLastError(); + return 0; +} + #endif // _LIBCPP_HAS_THREAD_API_PTHREAD +#endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL || _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL + _LIBCPP_END_NAMESPACE_STD -#endif // !_LIBCPP_HAS_THREAD_API_EXTERNAL || !__libcpp_has_include(<__external_threading>) - -#endif // _LIBCPP_HAS_NO_THREADS +#endif // !_LIBCPP_HAS_NO_THREADS #endif // _LIBCPP_THREADING_SUPPORT diff --git a/include/algorithm b/include/algorithm index 189991efbee0..5eec80ca013d 100644 --- a/include/algorithm +++ b/include/algorithm @@ -3100,28 +3100,28 @@ template _LIBCPP_INLINE_VISIBILITY _SampleIterator __sample(_PopulationIterator __first, - _PopulationIterator __last, _SampleIterator __out, + _PopulationIterator __last, _SampleIterator __output, _Distance __n, _UniformRandomNumberGenerator & __g, input_iterator_tag) { _Distance __k = 0; for (; __first != __last && __k < __n; ++__first, (void)++__k) - __out[__k] = *__first; + __output[__k] = *__first; _Distance __sz = __k; for (; __first != __last; ++__first, (void)++__k) { _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g); if (__r < __sz) - __out[__r] = *__first; + __output[__r] = *__first; } - return __out + _VSTD::min(__n, __k); + return __output + _VSTD::min(__n, __k); } template _LIBCPP_INLINE_VISIBILITY _SampleIterator __sample(_PopulationIterator __first, - _PopulationIterator __last, _SampleIterator __out, + _PopulationIterator __last, _SampleIterator __output, _Distance __n, _UniformRandomNumberGenerator& __g, forward_iterator_tag) { @@ -3130,18 +3130,18 @@ _SampleIterator __sample(_PopulationIterator __first, _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g); if (__r < __n) { - *__out++ = *__first; + *__output++ = *__first; --__n; } } - return __out; + return __output; } template _LIBCPP_INLINE_VISIBILITY _SampleIterator __sample(_PopulationIterator __first, - _PopulationIterator __last, _SampleIterator __out, + _PopulationIterator __last, _SampleIterator __output, _Distance __n, _UniformRandomNumberGenerator& __g) { typedef typename iterator_traits<_PopulationIterator>::iterator_category _PopCategory; @@ -3153,7 +3153,7 @@ _SampleIterator __sample(_PopulationIterator __first, typedef typename common_type<_Distance, _Difference>::type _CommonType; _LIBCPP_ASSERT(__n >= 0, "N must be a positive number."); return _VSTD::__sample( - __first, __last, __out, _CommonType(__n), + __first, __last, __output, _CommonType(__n), __g, _PopCategory()); } @@ -3162,9 +3162,9 @@ template inline _LIBCPP_INLINE_VISIBILITY _SampleIterator sample(_PopulationIterator __first, - _PopulationIterator __last, _SampleIterator __out, + _PopulationIterator __last, _SampleIterator __output, _Distance __n, _UniformRandomNumberGenerator&& __g) { - return _VSTD::__sample(__first, __last, __out, __n, __g); + return _VSTD::__sample(__first, __last, __output, __n, __g); } #endif // _LIBCPP_STD_VER > 14 diff --git a/include/atomic b/include/atomic index 7e3fac81b801..83889fb473e8 100644 --- a/include/atomic +++ b/include/atomic @@ -943,16 +943,16 @@ struct __atomic_base // false _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {} -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifndef _LIBCPP_CXX03_LANG __atomic_base(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) volatile = delete; -#else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#else private: __atomic_base(const __atomic_base&); __atomic_base& operator=(const __atomic_base&); __atomic_base& operator=(const __atomic_base&) volatile; -#endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#endif }; #if defined(__cpp_lib_atomic_is_always_lock_free) @@ -1699,16 +1699,16 @@ typedef struct atomic_flag _LIBCPP_INLINE_VISIBILITY atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifndef _LIBCPP_CXX03_LANG atomic_flag(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) volatile = delete; -#else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#else private: atomic_flag(const atomic_flag&); atomic_flag& operator=(const atomic_flag&); atomic_flag& operator=(const atomic_flag&) volatile; -#endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#endif } atomic_flag; inline _LIBCPP_INLINE_VISIBILITY diff --git a/include/experimental/algorithm b/include/experimental/algorithm index 392ca1fa41c0..b32d7ca66bd2 100644 --- a/include/experimental/algorithm +++ b/include/experimental/algorithm @@ -60,9 +60,9 @@ template inline _LIBCPP_INLINE_VISIBILITY _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last, - _SampleIterator __out, _Distance __n, + _SampleIterator __output, _Distance __n, _UniformRandomNumberGenerator &&__g) { - return _VSTD::__sample(__first, __last, __out, __n, __g); + return _VSTD::__sample(__first, __last, __output, __n, __g); } _LIBCPP_END_NAMESPACE_LFTS diff --git a/include/experimental/dynarray b/include/experimental/dynarray index d94b29b92ff3..8c9733770c3b 100644 --- a/include/experimental/dynarray +++ b/include/experimental/dynarray @@ -11,9 +11,6 @@ #ifndef _LIBCPP_DYNARRAY #define _LIBCPP_DYNARRAY -#include <__config> -#if _LIBCPP_STD_VER > 11 - /* dynarray synopsis @@ -96,6 +93,8 @@ public: }} // std::experimental */ +#include <__config> +#if _LIBCPP_STD_VER > 11 #include <__functional_base> #include @@ -104,8 +103,6 @@ public: #include #include -#include <__undef___deallocate> - #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif @@ -143,9 +140,9 @@ private: return static_cast (_VSTD::__allocate (sizeof(value_type) * count)); } - static inline _LIBCPP_INLINE_VISIBILITY void __deallocate ( value_type* __ptr ) noexcept + static inline _LIBCPP_INLINE_VISIBILITY void __deallocate_value( value_type* __ptr ) noexcept { - _VSTD::__deallocate (static_cast (__ptr)); + _VSTD::__libcpp_deallocate (static_cast (__ptr)); } public: @@ -265,7 +262,7 @@ dynarray<_Tp>::~dynarray() value_type *__data = data () + __size_; for ( size_t i = 0; i < __size_; ++i ) (--__data)->value_type::~value_type(); - __deallocate ( __base_ ); + __deallocate_value( __base_ ); } template diff --git a/include/experimental/iterator b/include/experimental/iterator index da593febe2b4..37186b3d0b30 100644 --- a/include/experimental/iterator +++ b/include/experimental/iterator @@ -75,19 +75,19 @@ public: typedef void reference; ostream_joiner(ostream_type& __os, _Delim&& __d) - : __out(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {} + : __output(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {} ostream_joiner(ostream_type& __os, const _Delim& __d) - : __out(_VSTD::addressof(__os)), __delim(__d), __first(true) {} + : __output(_VSTD::addressof(__os)), __delim(__d), __first(true) {} template ostream_joiner& operator=(const _Tp& __v) { if (!__first) - *__out << __delim; + *__output << __delim; __first = false; - *__out << __v; + *__output << __v; return *this; } @@ -96,7 +96,7 @@ public: ostream_joiner& operator++(int) _NOEXCEPT { return *this; } private: - ostream_type* __out; + ostream_type* __output; _Delim __delim; bool __first; }; diff --git a/include/istream b/include/istream index e935f519f416..774f38df2e3c 100644 --- a/include/istream +++ b/include/istream @@ -205,14 +205,9 @@ protected: basic_ios::swap(__rhs); } -#if _LIBCPP_STD_VER > 11 -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifndef _LIBCPP_CXX03_LANG basic_istream (const basic_istream& __rhs) = delete; basic_istream& operator=(const basic_istream& __rhs) = delete; -#else - basic_istream (const basic_istream& __rhs); // not defined - basic_istream& operator=(const basic_istream& __rhs); // not defined -#endif #endif public: diff --git a/include/memory b/include/memory index a38d95b9446e..54fd7bf49e89 100644 --- a/include/memory +++ b/include/memory @@ -644,7 +644,6 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space); #endif #include <__undef_min_max> -#include <__undef___deallocate> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header @@ -1772,7 +1771,7 @@ public: return static_cast(_VSTD::__allocate(__n * sizeof(_Tp))); } _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT - {_VSTD::__deallocate((void*)__p);} + {_VSTD::__libcpp_deallocate((void*)__p);} _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {return size_type(~0) / sizeof(_Tp);} #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) @@ -1868,7 +1867,7 @@ public: return static_cast(_VSTD::__allocate(__n * sizeof(_Tp))); } _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT - {_VSTD::__deallocate((void*)__p);} + {_VSTD::__libcpp_deallocate((void*)__p);} _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {return size_type(~0) / sizeof(_Tp);} #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) @@ -3345,12 +3344,13 @@ struct __scalar_hash<_Tp, 4> } }; +struct _PairT { + size_t first; + size_t second; +}; + _LIBCPP_INLINE_VISIBILITY inline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT { - struct _PairT { - size_t first; - size_t second; - }; typedef __scalar_hash<_PairT> _HashT; const _PairT __p = {__lhs, __rhs}; return _HashT()(__p); diff --git a/include/module.modulemap b/include/module.modulemap index 95610bfb735e..c354cae1e5f1 100644 --- a/include/module.modulemap +++ b/include/module.modulemap @@ -485,7 +485,6 @@ module std [system] { module __tree { header "__tree" export * } module __tuple { header "__tuple" export * } module __undef_min_max { header "__undef_min_max" export * } - module __undef___deallocate { header "__undef___deallocate" export * } module experimental { requires cplusplus11 diff --git a/include/new b/include/new index 442e113665dd..6589f16b7a16 100644 --- a/include/new +++ b/include/new @@ -92,8 +92,6 @@ void operator delete[](void* ptr, void*) noexcept; #include #endif -#include <__undef___deallocate> - #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif @@ -217,7 +215,7 @@ inline _LIBCPP_INLINE_VISIBILITY void *__allocate(size_t __size) { #endif } -inline _LIBCPP_INLINE_VISIBILITY void __deallocate(void *__ptr) { +inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate(void *__ptr) { #ifdef _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE ::operator delete(__ptr); #else diff --git a/include/ostream b/include/ostream index be35f2e16e70..3d9be8b7aa56 100644 --- a/include/ostream +++ b/include/ostream @@ -179,7 +179,7 @@ protected: void swap(basic_ostream& __rhs) { basic_ios::swap(__rhs); } -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifndef _LIBCPP_CXX03_LANG basic_ostream (const basic_ostream& __rhs) = delete; basic_ostream& operator=(const basic_ostream& __rhs) = delete; #else diff --git a/include/regex b/include/regex index d8f1fae97230..42e55e86f454 100644 --- a/include/regex +++ b/include/regex @@ -5262,15 +5262,15 @@ public: // format: template _OutputIter - format(_OutputIter __out, const char_type* __fmt_first, + format(_OutputIter __output, const char_type* __fmt_first, const char_type* __fmt_last, regex_constants::match_flag_type __flags = regex_constants::format_default) const; template _LIBCPP_INLINE_VISIBILITY _OutputIter - format(_OutputIter __out, const basic_string& __fmt, + format(_OutputIter __output, const basic_string& __fmt, regex_constants::match_flag_type __flags = regex_constants::format_default) const - {return format(__out, __fmt.data(), __fmt.data() + __fmt.size(), __flags);} + {return format(__output, __fmt.data(), __fmt.data() + __fmt.size(), __flags);} template _LIBCPP_INLINE_VISIBILITY basic_string @@ -5382,7 +5382,7 @@ match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s, template template _OutputIter -match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out, +match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output, const char_type* __fmt_first, const char_type* __fmt_last, regex_constants::match_flag_type __flags) const { @@ -5391,27 +5391,27 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out, for (; __fmt_first != __fmt_last; ++__fmt_first) { if (*__fmt_first == '&') - __out = _VSTD::copy(__matches_[0].first, __matches_[0].second, - __out); + __output = _VSTD::copy(__matches_[0].first, __matches_[0].second, + __output); else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last) { ++__fmt_first; if ('0' <= *__fmt_first && *__fmt_first <= '9') { size_t __i = *__fmt_first - '0'; - __out = _VSTD::copy((*this)[__i].first, - (*this)[__i].second, __out); + __output = _VSTD::copy((*this)[__i].first, + (*this)[__i].second, __output); } else { - *__out = *__fmt_first; - ++__out; + *__output = *__fmt_first; + ++__output; } } else { - *__out = *__fmt_first; - ++__out; + *__output = *__fmt_first; + ++__output; } } } @@ -5424,21 +5424,21 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out, switch (__fmt_first[1]) { case '$': - *__out = *++__fmt_first; - ++__out; + *__output = *++__fmt_first; + ++__output; break; case '&': ++__fmt_first; - __out = _VSTD::copy(__matches_[0].first, __matches_[0].second, - __out); + __output = _VSTD::copy(__matches_[0].first, __matches_[0].second, + __output); break; case '`': ++__fmt_first; - __out = _VSTD::copy(__prefix_.first, __prefix_.second, __out); + __output = _VSTD::copy(__prefix_.first, __prefix_.second, __output); break; case '\'': ++__fmt_first; - __out = _VSTD::copy(__suffix_.first, __suffix_.second, __out); + __output = _VSTD::copy(__suffix_.first, __suffix_.second, __output); break; default: if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9') @@ -5451,25 +5451,25 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out, ++__fmt_first; __i = 10 * __i + *__fmt_first - '0'; } - __out = _VSTD::copy((*this)[__i].first, - (*this)[__i].second, __out); + __output = _VSTD::copy((*this)[__i].first, + (*this)[__i].second, __output); } else { - *__out = *__fmt_first; - ++__out; + *__output = *__fmt_first; + ++__output; } break; } } else { - *__out = *__fmt_first; - ++__out; + *__output = *__fmt_first; + ++__output; } } } - return __out; + return __output; } template @@ -6459,7 +6459,7 @@ typedef regex_token_iterator wsregex_token_iterator; template _OutputIterator -regex_replace(_OutputIterator __out, +regex_replace(_OutputIterator __output, _BidirectionalIterator __first, _BidirectionalIterator __last, const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) @@ -6470,7 +6470,7 @@ regex_replace(_OutputIterator __out, if (__i == __eof) { if (!(__flags & regex_constants::format_no_copy)) - __out = _VSTD::copy(__first, __last, __out); + __output = _VSTD::copy(__first, __last, __output); } else { @@ -6478,29 +6478,29 @@ regex_replace(_OutputIterator __out, for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i) { if (!(__flags & regex_constants::format_no_copy)) - __out = _VSTD::copy(__i->prefix().first, __i->prefix().second, __out); - __out = __i->format(__out, __fmt, __fmt + __len, __flags); + __output = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output); + __output = __i->format(__output, __fmt, __fmt + __len, __flags); __lm = __i->suffix(); if (__flags & regex_constants::format_first_only) break; } if (!(__flags & regex_constants::format_no_copy)) - __out = _VSTD::copy(__lm.first, __lm.second, __out); + __output = _VSTD::copy(__lm.first, __lm.second, __output); } - return __out; + return __output; } template inline _LIBCPP_INLINE_VISIBILITY _OutputIterator -regex_replace(_OutputIterator __out, +regex_replace(_OutputIterator __output, _BidirectionalIterator __first, _BidirectionalIterator __last, const basic_regex<_CharT, _Traits>& __e, const basic_string<_CharT, _ST, _SA>& __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) { - return _VSTD::regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags); + return _VSTD::regex_replace(__output, __first, __last, __e, __fmt.c_str(), __flags); } template struct hash; template <> struct hash; + constexpr basic_string operator "" s( const char *str, size_t len ); // C++17 + constexpr basic_string operator "" s( const wchar_t *str, size_t len ); // C++17 + constexpr basic_string operator "" s( const char16_t *str, size_t len ); // C++17 + constexpr basic_string operator "" s( const char32_t *str, size_t len ); // C++17 + } // namespace std @@ -749,6 +754,38 @@ hash >::operator()( return __do_string_hash(__val.data(), __val.data() + __val.size()); } + +#if _LIBCPP_STD_VER > 11 +inline namespace literals +{ + inline namespace string_view_literals + { + inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR + basic_string_view operator "" sv(const char *__str, size_t __len) + { + return basic_string_view (__str, __len); + } + + inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR + basic_string_view operator "" sv(const wchar_t *__str, size_t __len) + { + return basic_string_view (__str, __len); + } + + inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR + basic_string_view operator "" sv(const char16_t *__str, size_t __len) + { + return basic_string_view (__str, __len); + } + + inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR + basic_string_view operator "" sv(const char32_t *__str, size_t __len) + { + return basic_string_view (__str, __len); + } + } +} +#endif _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_STRING_VIEW diff --git a/include/support/win32/support.h b/include/support/win32/support.h index 17ee1980a643..f9613445cffb 100644 --- a/include/support/win32/support.h +++ b/include/support/win32/support.h @@ -18,7 +18,7 @@ #include // va_ macros // "builtins" not implemented here for Clang or GCC as they provide // implementations. Assuming required for elsewhere else, certainly MSVC. -#if defined(_LIBCPP_MSVC) +#if defined(_LIBCPP_COMPILER_MSVC) #include #endif #if defined(_LIBCPP_MSVCRT) @@ -49,7 +49,7 @@ size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src, #define _Exit _exit #endif -#if defined(_LIBCPP_MSVC) +#if defined(_LIBCPP_COMPILER_MSVC) // Bit builtin's make these assumptions when calling _BitScanForward/Reverse // etc. These assumptions are expected to be true for Win32/Win64 which this diff --git a/include/thread b/include/thread index b5b96e8c71ed..479e3c08f809 100644 --- a/include/thread +++ b/include/thread @@ -148,7 +148,8 @@ class __thread_specific_ptr __thread_specific_ptr(const __thread_specific_ptr&); __thread_specific_ptr& operator=(const __thread_specific_ptr&); - static void __at_thread_exit(void*); + static void _LIBCPP_TLS_DESTRUCTOR_CC __at_thread_exit(void*); + public: typedef _Tp* pointer; @@ -164,7 +165,7 @@ public: }; template -void +void _LIBCPP_TLS_DESTRUCTOR_CC __thread_specific_ptr<_Tp>::__at_thread_exit(void* __p) { delete static_cast(__p); @@ -173,12 +174,10 @@ __thread_specific_ptr<_Tp>::__at_thread_exit(void* __p) template __thread_specific_ptr<_Tp>::__thread_specific_ptr() { - int __ec = __libcpp_tls_create( - &__key_, - &__thread_specific_ptr::__at_thread_exit); - if (__ec) - __throw_system_error(__ec, - "__thread_specific_ptr construction failed"); + int __ec = + __libcpp_tls_create(&__key_, &__thread_specific_ptr::__at_thread_exit); + if (__ec) + __throw_system_error(__ec, "__thread_specific_ptr construction failed"); } template diff --git a/include/type_traits b/include/type_traits index d7ba251549dc..7862955605df 100644 --- a/include/type_traits +++ b/include/type_traits @@ -489,7 +489,7 @@ addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT } #endif -#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_DELETED_FUNCTIONS) +#if !defined(_LIBCPP_CXX03_LANG) template _Tp* addressof(const _Tp&&) noexcept = delete; #endif @@ -1503,7 +1503,7 @@ template _LIBCPP_CONSTEXPR bool is_empty_v // is_polymorphic -#if __has_feature(is_polymorphic) || defined(_LIBCPP_MSVC) +#if __has_feature(is_polymorphic) || defined(_LIBCPP_COMPILER_MSVC) template struct _LIBCPP_TEMPLATE_VIS is_polymorphic @@ -1566,7 +1566,7 @@ struct __type_list struct __nat { -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#ifndef _LIBCPP_CXX03_LANG __nat() = delete; __nat(const __nat&) = delete; __nat& operator=(const __nat&) = delete; diff --git a/include/valarray b/include/valarray index f70304bbd15b..f0f1f62a1db8 100644 --- a/include/valarray +++ b/include/valarray @@ -348,7 +348,6 @@ template unspecified2 end(const valarray& v); #include #include <__undef_min_max> -#include <__undef___deallocate> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header @@ -3697,7 +3696,7 @@ valarray<_Tp>::resize(size_t __n, value_type __x) { while (__end_ != __begin_) (--__end_)->~value_type(); - _VSTD::__deallocate(__begin_); + _VSTD::__libcpp_deallocate(__begin_); __begin_ = __end_ = nullptr; } if (__n) diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 41b9ced3fb93..cc3ed16b9b72 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -275,7 +275,7 @@ if (LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY) ) endif() -if (LIBCXX_HAS_EXTERNAL_THREAD_API) +if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY) file(GLOB LIBCXX_EXTERNAL_THREADING_SUPPORT_SOURCES ../test/support/external_threads.cpp) if (LIBCXX_ENABLE_SHARED) diff --git a/src/chrono.cpp b/src/chrono.cpp index 8c8e6b5d31ad..df5cabdb1845 100644 --- a/src/chrono.cpp +++ b/src/chrono.cpp @@ -12,6 +12,28 @@ #include "system_error" // __throw_system_error #include // clock_gettime, CLOCK_MONOTONIC and CLOCK_REALTIME +#if (__APPLE__) +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) +#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200 +#define _LIBCXX_USE_CLOCK_GETTIME +#endif +#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) +#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000 +#define _LIBCXX_USE_CLOCK_GETTIME +#endif +#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) +#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000 +#define _LIBCXX_USE_CLOCK_GETTIME +#endif +#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) +#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000 +#define _LIBCXX_USE_CLOCK_GETTIME +#endif +#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__ +#else +#define _LIBCXX_USE_CLOCK_GETTIME +#endif // __APPLE__ + #if defined(_LIBCPP_WIN32API) #define WIN32_LEAN_AND_MEAN #define VC_EXTRA_LEAN @@ -70,16 +92,16 @@ system_clock::now() _NOEXCEPT static_cast<__int64>(ft.dwLowDateTime)}; return time_point(duration_cast(d - nt_to_unix_epoch)); #else -#ifdef CLOCK_REALTIME +#if defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME) struct timespec tp; if (0 != clock_gettime(CLOCK_REALTIME, &tp)) __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed"); return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000)); -#else // !CLOCK_REALTIME +#else timeval tv; gettimeofday(&tv, 0); return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec)); -#endif // CLOCK_REALTIME +#endif // _LIBCXX_USE_CLOCK_GETTIME && CLOCK_REALTIME #endif } @@ -106,6 +128,18 @@ const bool steady_clock::is_steady; #if defined(__APPLE__) +// Darwin libc versions >= 1133 provide ns precision via CLOCK_UPTIME_RAW +#if defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW) +steady_clock::time_point +steady_clock::now() _NOEXCEPT +{ + struct timespec tp; + if (0 != clock_gettime(CLOCK_UPTIME_RAW, &tp)) + __throw_system_error(errno, "clock_gettime(CLOCK_UPTIME_RAW) failed"); + return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec)); +} + +#else // mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of // nanoseconds since the computer booted up. MachInfo.numer and MachInfo.denom // are run time constants supplied by the OS. This clock has no relationship @@ -157,6 +191,7 @@ steady_clock::now() _NOEXCEPT static FP fp = init_steady_clock(); return time_point(duration(fp())); } +#endif // defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW) #elif defined(_LIBCPP_WIN32API) @@ -175,6 +210,13 @@ steady_clock::now() _NOEXCEPT #elif defined(CLOCK_MONOTONIC) +// On Apple platforms only CLOCK_UPTIME_RAW or mach_absolute_time are able to +// time functions in the nanosecond range. Thus, they are the only acceptable +// implementations of steady_clock. +#ifdef __APPLE__ +#error "Never use CLOCK_MONOTONIC for steady_clock::now on Apple platforms" +#endif + steady_clock::time_point steady_clock::now() _NOEXCEPT { diff --git a/src/exception.cpp b/src/exception.cpp index ec8969aaf4c0..f25041d83427 100644 --- a/src/exception.cpp +++ b/src/exception.cpp @@ -12,7 +12,10 @@ #include "exception" #include "new" -#if defined(__APPLE__) && !defined(LIBCXXRT) && \ +#if defined(_LIBCPP_ABI_MICROSOFT) +#include +#include +#elif defined(__APPLE__) && !defined(LIBCXXRT) && \ !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) #include @@ -46,13 +49,21 @@ namespace std unexpected_handler set_unexpected(unexpected_handler func) _NOEXCEPT { - return __sync_lock_test_and_set(&__unexpected_handler, func); +#if defined(_LIBCPP_ABI_MICROSOFT) + return ::set_unexpected(func); +#else + return __sync_lock_test_and_set(&__unexpected_handler, func); +#endif } unexpected_handler get_unexpected() _NOEXCEPT { - return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0); +#if defined(_LIBCPP_ABI_MICROSOFT) + return ::_get_unexpected(); +#else + return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0); +#endif } _LIBCPP_NORETURN @@ -67,13 +78,21 @@ unexpected() terminate_handler set_terminate(terminate_handler func) _NOEXCEPT { - return __sync_lock_test_and_set(&__terminate_handler, func); +#if defined(_LIBCPP_ABI_MICROSOFT) + return ::set_terminate(func); +#else + return __sync_lock_test_and_set(&__terminate_handler, func); +#endif } terminate_handler get_terminate() _NOEXCEPT { - return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0); +#if defined(_LIBCPP_ABI_MICROSOFT) + return ::_get_terminate(); +#else + return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0); +#endif } #ifndef __EMSCRIPTEN__ // We provide this in JS @@ -103,6 +122,7 @@ terminate() _NOEXCEPT #endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION) #if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__) + bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; } int uncaught_exceptions() _NOEXCEPT @@ -115,7 +135,9 @@ int uncaught_exceptions() _NOEXCEPT # else return __cxa_uncaught_exception() ? 1 : 0; # endif -#else // __APPLE__ +#elif defined(_LIBCPP_ABI_MICROSOFT) + return __uncaught_exceptions(); +#else # if defined(_MSC_VER) && ! defined(__clang__) _LIBCPP_WARNING("uncaught_exceptions not yet implemented") # else diff --git a/src/experimental/memory_resource.cpp b/src/experimental/memory_resource.cpp index cc6aab38e058..c4dc1ca894a0 100644 --- a/src/experimental/memory_resource.cpp +++ b/src/experimental/memory_resource.cpp @@ -34,7 +34,7 @@ class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp { return __allocate(__size); } virtual void do_deallocate(void * __p, size_t, size_t) - { __deallocate(__p); } + { _VSTD::__libcpp_deallocate(__p); } virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT { return &__other == this; } diff --git a/src/include/config_elast.h b/src/include/config_elast.h index 97104290d883..8328978ef953 100644 --- a/src/include/config_elast.h +++ b/src/include/config_elast.h @@ -31,7 +31,7 @@ #elif defined(__sun__) #define _LIBCPP_ELAST ESTALE #elif defined(_LIBCPP_MSVCRT) -#define _LIBCPP_ELAST _sys_nerr +#define _LIBCPP_ELAST (_sys_nerr - 1) #else // Warn here so that the person doing the libcxx port has an easier time: #warning ELAST for this platform not yet implemented diff --git a/src/iostream.cpp b/src/iostream.cpp index e073aec6ead5..a972be95499b 100644 --- a/src/iostream.cpp +++ b/src/iostream.cpp @@ -14,32 +14,64 @@ _LIBCPP_BEGIN_NAMESPACE_STD #ifndef _LIBCPP_HAS_NO_STDIN -_ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin [sizeof(istream)]; -_ALIGNAS_TYPE (__stdinbuf ) static char __cin [sizeof(__stdinbuf )]; +_ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin[sizeof(istream)] +#if defined(_MSC_VER) && defined(__clang__) +__asm__("?cin@__1@std@@3V?$basic_istream@DU?$char_traits@D@__1@std@@@12@A") +#endif +; +_ALIGNAS_TYPE (__stdinbuf ) static char __cin[sizeof(__stdinbuf )]; static mbstate_t mb_cin; -_ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin [sizeof(wistream)]; -_ALIGNAS_TYPE (__stdinbuf ) static char __wcin [sizeof(__stdinbuf )]; +_ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin[sizeof(wistream)] +#if defined(_MSC_VER) && defined(__clang__) +__asm__("?wcin@__1@std@@3V?$basic_istream@_WU?$char_traits@_W@__1@std@@@12@A") +#endif +; +_ALIGNAS_TYPE (__stdinbuf ) static char __wcin[sizeof(__stdinbuf )]; static mbstate_t mb_wcin; #endif #ifndef _LIBCPP_HAS_NO_STDOUT -_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cout[sizeof(ostream)]; +_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cout[sizeof(ostream)] +#if defined(_MSC_VER) && defined(__clang__) +__asm__("?cout@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A") +#endif +; _ALIGNAS_TYPE (__stdoutbuf) static char __cout[sizeof(__stdoutbuf)]; static mbstate_t mb_cout; -_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)]; +_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)] +#if defined(_MSC_VER) && defined(__clang__) +__asm__("?wcout@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A") +#endif +; _ALIGNAS_TYPE (__stdoutbuf) static char __wcout[sizeof(__stdoutbuf)]; static mbstate_t mb_wcout; #endif -_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)]; +_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)] +#if defined(_MSC_VER) && defined(__clang__) +__asm__("?cerr@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A") +#endif +; _ALIGNAS_TYPE (__stdoutbuf) static char __cerr[sizeof(__stdoutbuf)]; static mbstate_t mb_cerr; -_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)]; +_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)] +#if defined(_MSC_VER) && defined(__clang__) +__asm__("?wcerr@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A") +#endif +; _ALIGNAS_TYPE (__stdoutbuf) static char __wcerr[sizeof(__stdoutbuf)]; static mbstate_t mb_wcerr; -_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)]; -_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)]; +_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)] +#if defined(_MSC_VER) && defined(__clang__) +__asm__("?clog@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A") +#endif +; +_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)] +#if defined(_MSC_VER) && defined(__clang__) +__asm__("?wclog@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A") +#endif +; ios_base::Init __start_std_streams; diff --git a/src/locale.cpp b/src/locale.cpp index 4b462664a60c..338ffde3f5b7 100644 --- a/src/locale.cpp +++ b/src/locale.cpp @@ -140,7 +140,7 @@ class _LIBCPP_HIDDEN locale::__imp : public facet { enum {N = 28}; -#if defined(_LIBCPP_MSVC) +#if defined(_LIBCPP_COMPILER_MSVC) // FIXME: MSVC doesn't support aligned parameters by value. // I can't get the __sso_allocator to work here // for MSVC I think for this reason. diff --git a/src/thread.cpp b/src/thread.cpp index 4fb1dd21fc2c..5ccf829fb864 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -117,6 +117,12 @@ sleep_for(const chrono::nanoseconds& ns) using namespace chrono; if (ns > nanoseconds::zero()) { +#if defined(_LIBCPP_WIN32API) + milliseconds ms = duration_cast(ns); + if (ms.count() == 0 || ns > duration_cast(ms)) + ++ms; + Sleep(ms.count()); +#else seconds s = duration_cast(ns); timespec ts; typedef decltype(ts.tv_sec) ts_sec; @@ -134,6 +140,7 @@ sleep_for(const chrono::nanoseconds& ns) while (nanosleep(&ts, &ts) == -1 && errno == EINTR) ; +#endif } } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index d174ec72ca08..ad110fbfb30b 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -34,7 +34,7 @@ pythonize_bool(LIBCXXABI_ENABLE_SHARED) pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER) pythonize_bool(LIBCXX_HAS_ATOMIC_LIB) pythonize_bool(LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB) -pythonize_bool(LIBCXX_HAS_EXTERNAL_THREAD_API) +pythonize_bool(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY) # By default, for non-standalone builds, libcxx and libcxxabi share a library # directory. diff --git a/test/libcxx/iterators/trivial_iterators.pass.cpp b/test/libcxx/iterators/trivial_iterators.pass.cpp index c4b3aae92ff2..d924a57ffeab 100644 --- a/test/libcxx/iterators/trivial_iterators.pass.cpp +++ b/test/libcxx/iterators/trivial_iterators.pass.cpp @@ -25,9 +25,10 @@ #include #include +#include "test_macros.h" #include "test_iterators.h" -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#if TEST_STD_VER >= 11 #define DELETE_FUNCTION = delete #else #define DELETE_FUNCTION diff --git a/test/libcxx/test/config.py b/test/libcxx/test/config.py index 7043b8a01c4a..5fcb8f4a9b3f 100644 --- a/test/libcxx/test/config.py +++ b/test/libcxx/test/config.py @@ -67,7 +67,8 @@ def __init__(self, lit_config, config): self.cxx_library_root = None self.cxx_runtime_root = None self.abi_library_root = None - self.env = {} + self.link_shared = self.get_lit_bool('enable_shared', default=True) + self.exec_env = {} self.use_target = False self.use_system_cxx_lib = False self.use_clang_verify = False @@ -146,7 +147,7 @@ def print_config_info(self): # Print as list to prevent "set([...])" from being printed. self.lit_config.note('Using available_features: %s' % list(self.config.available_features)) - self.lit_config.note('Using environment: %r' % self.env) + self.lit_config.note('Using environment: %r' % self.exec_env) def get_test_format(self): return LibcxxTestFormat( @@ -154,7 +155,7 @@ def get_test_format(self): self.use_clang_verify, self.execute_external, self.executor, - exec_env=self.env) + exec_env=self.exec_env) def configure_executor(self): exec_str = self.get_lit_conf('executor', "None") @@ -207,12 +208,16 @@ def configure_cxx(self): self.config.available_features.add('%s-%s' % (cxx_type, maj_v)) self.config.available_features.add('%s-%s.%s' % ( cxx_type, maj_v, min_v)) + self.cxx.compile_env = dict(os.environ) + # 'CCACHE_CPP2' prevents ccache from stripping comments while + # preprocessing. This is required to prevent stripping of '-verify' + # comments. + self.cxx.compile_env['CCACHE_CPP2'] = '1' def _configure_clang_cl(self, clang_path): assert self.cxx_is_clang_cl # FIXME: don't hardcode the target - flags = ['-fms-compatibility-version=19.00', - '--target=i686-unknown-windows'] + flags = ['--target=i686-pc-windows'] compile_flags = [] link_flags = ['-fuse-ld=lld'] if 'INCLUDE' in os.environ: @@ -555,7 +560,7 @@ def configure_filesystem_compile_flags(self): if not os.path.isdir(dynamic_env): os.makedirs(dynamic_env) self.cxx.compile_flags += ['-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT="%s"' % dynamic_env] - self.env['LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT'] = ("%s" % dynamic_env) + self.exec_env['LIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT'] = ("%s" % dynamic_env) dynamic_helper = os.path.join(self.libcxx_src_root, 'test', 'support', 'filesystem_dynamic_test_helper.py') @@ -577,7 +582,7 @@ def configure_link_flags(self): self.cxx.link_flags += ['-nodefaultlibs'] # FIXME: Handle MSVCRT as part of the ABI library handling. if self.is_windows: - self.cxx.link_flags += ['-nostdlib', '-lmsvcrtd'] + self.cxx.link_flags += ['-nostdlib'] self.configure_link_flags_cxx_library() self.configure_link_flags_abi_library() self.configure_extra_library_flags() @@ -602,8 +607,14 @@ def configure_link_flags_cxx_library_path(self): if not self.use_system_cxx_lib: if self.cxx_library_root: self.cxx.link_flags += ['-L' + self.cxx_library_root] - if self.cxx_runtime_root and not self.is_windows: - self.cxx.link_flags += ['-Wl,-rpath,' + self.cxx_runtime_root] + if self.is_windows and self.link_shared: + self.add_path(self.cxx.compile_env, self.cxx_library_root) + if self.cxx_runtime_root: + if not self.is_windows: + self.cxx.link_flags += ['-Wl,-rpath,' + + self.cxx_runtime_root] + elif self.is_windows and self.link_shared: + self.add_path(self.exec_env, self.cxx_runtime_root) def configure_link_flags_abi_library_path(self): # Configure ABI library paths. @@ -612,14 +623,15 @@ def configure_link_flags_abi_library_path(self): self.cxx.link_flags += ['-L' + self.abi_library_root] if not self.is_windows: self.cxx.link_flags += ['-Wl,-rpath,' + self.abi_library_root] + else: + self.add_path(self.exec_env, self.abi_library_root) def configure_link_flags_cxx_library(self): libcxx_experimental = self.get_lit_bool('enable_experimental', default=False) if libcxx_experimental: self.config.available_features.add('c++experimental') self.cxx.link_flags += ['-lc++experimental'] - libcxx_shared = self.get_lit_bool('enable_shared', default=True) - if libcxx_shared: + if self.link_shared: self.cxx.link_flags += ['-lc++'] else: cxx_library_root = self.get_lit_conf('cxx_library_root') @@ -654,7 +666,8 @@ def configure_link_flags_abi_library(self): elif cxx_abi == 'libcxxrt': self.cxx.link_flags += ['-lcxxrt'] elif cxx_abi == 'none' or cxx_abi == 'default': - pass + if self.is_windows: + self.cxx.link_flags += ['-lmsvcrtd'] else: self.lit_config.fatal( 'C++ ABI setting %s unsupported for tests' % cxx_abi) @@ -746,7 +759,7 @@ def add_ubsan(): self.cxx.flags += ['-fsanitize=undefined', '-fno-sanitize=vptr,function,float-divide-by-zero', '-fno-sanitize-recover=all'] - self.env['UBSAN_OPTIONS'] = 'print_stacktrace=1' + self.exec_env['UBSAN_OPTIONS'] = 'print_stacktrace=1' self.config.available_features.add('ubsan') # Setup the sanitizer compile flags @@ -754,10 +767,10 @@ def add_ubsan(): if san == 'Address' or san == 'Address;Undefined' or san == 'Undefined;Address': self.cxx.flags += ['-fsanitize=address'] if llvm_symbolizer is not None: - self.env['ASAN_SYMBOLIZER_PATH'] = llvm_symbolizer + self.exec_env['ASAN_SYMBOLIZER_PATH'] = llvm_symbolizer # FIXME: Turn ODR violation back on after PR28391 is resolved # https://llvm.org/bugs/show_bug.cgi?id=28391 - self.env['ASAN_OPTIONS'] = 'detect_odr_violation=0' + self.exec_env['ASAN_OPTIONS'] = 'detect_odr_violation=0' self.config.available_features.add('asan') self.config.available_features.add('sanitizer-new-delete') self.cxx.compile_flags += ['-O1'] @@ -769,7 +782,7 @@ def add_ubsan(): self.cxx.compile_flags += [ '-fsanitize-memory-track-origins'] if llvm_symbolizer is not None: - self.env['MSAN_SYMBOLIZER_PATH'] = llvm_symbolizer + self.exec_env['MSAN_SYMBOLIZER_PATH'] = llvm_symbolizer self.config.available_features.add('msan') self.config.available_features.add('sanitizer-new-delete') self.cxx.compile_flags += ['-O1'] @@ -855,8 +868,8 @@ def configure_substitutions(self): sub.append(('%link', link_str)) sub.append(('%build', build_str)) # Configure exec prefix substitutions. - exec_env_str = 'env ' if len(self.env) != 0 else '' - for k, v in self.env.items(): + exec_env_str = 'env ' if len(self.exec_env) != 0 else '' + for k, v in self.exec_env.items(): exec_env_str += ' %s=%s' % (k, v) # Configure run env substitution. exec_str = exec_env_str @@ -898,4 +911,12 @@ def configure_triple(self): "inferred target_triple as: %r" % self.config.target_triple) def configure_env(self): - self.target_info.configure_env(self.env) + self.target_info.configure_env(self.exec_env) + + def add_path(self, dest_env, new_path): + if 'PATH' not in dest_env: + dest_env['PATH'] = new_path + else: + split_char = ';' if self.is_windows else ':' + dest_env['PATH'] = '%s%s%s' % (new_path, split_char, + dest_env['PATH']) diff --git a/test/libcxx/test/executor.py b/test/libcxx/test/executor.py index ee4288fb0083..250186cecb84 100644 --- a/test/libcxx/test/executor.py +++ b/test/libcxx/test/executor.py @@ -7,6 +7,7 @@ # #===----------------------------------------------------------------------===## +import platform import os from libcxx.test import tracing @@ -34,6 +35,7 @@ def run(self, exe_path, cmd, local_cwd, file_deps=None, env=None): class LocalExecutor(Executor): def __init__(self): super(LocalExecutor, self).__init__() + self.is_windows = platform.system() == 'Windows' def run(self, exe_path, cmd=None, work_dir='.', file_deps=None, env=None): cmd = cmd or [exe_path] @@ -43,9 +45,30 @@ def run(self, exe_path, cmd=None, work_dir='.', file_deps=None, env=None): env_cmd += ['%s=%s' % (k, v) for k, v in env.items()] if work_dir == '.': work_dir = os.getcwd() - out, err, rc = executeCommand(env_cmd + cmd, cwd=work_dir) + if not self.is_windows: + out, err, rc = executeCommand(env_cmd + cmd, cwd=work_dir) + else: + out, err, rc = executeCommand(cmd, cwd=work_dir, + env=self._build_windows_env(env)) return (env_cmd + cmd, out, err, rc) + def _build_windows_env(self, exec_env): + # FIXME: Finding Windows DLL's at runtime requires modifying the + # PATH environment variables. However we don't want to print out + # the entire PATH as part of the diagnostic for every failing test. + # Therefore this hack builds a new executable environment that + # merges the current environment and the supplied environment while + # still only printing the supplied environment in diagnostics. + if not self.is_windows or exec_env is None: + return None + new_env = dict(os.environ) + for key, value in exec_env.items(): + if key == 'PATH': + assert value.strip() != '' and "expected non-empty path" + new_env['PATH'] = "%s;%s" % (value, os.environ['PATH']) + else: + new_env[key] = value + return new_env class PrefixExecutor(Executor): """Prefix an executor with some other command wrapper. diff --git a/test/libcxx/test/format.py b/test/libcxx/test/format.py index ee6ab82c6e3a..cbd96f340bbc 100644 --- a/test/libcxx/test/format.py +++ b/test/libcxx/test/format.py @@ -41,11 +41,6 @@ def __init__(self, cxx, use_verify_for_fail, execute_external, self.execute_external = execute_external self.executor = executor self.exec_env = dict(exec_env) - self.cxx.compile_env = dict(os.environ) - # 'CCACHE_CPP2' prevents ccache from stripping comments while - # preprocessing. This is required to prevent stripping of '-verify' - # comments. - self.cxx.compile_env['CCACHE_CPP2'] = '1' @staticmethod def _make_custom_parsers(): diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in index c89af09ddbf3..0cccffcf5ec0 100644 --- a/test/lit.site.cfg.in +++ b/test/lit.site.cfg.in @@ -28,7 +28,7 @@ config.has_libatomic = "@LIBCXX_HAS_ATOMIC_LIB@" config.use_libatomic = "@LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB@" config.libcxxabi_shared = "@LIBCXXABI_ENABLE_SHARED@" -config.cxx_ext_threads = "@LIBCXX_HAS_EXTERNAL_THREAD_API@" +config.cxx_ext_threads = "@LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY@" # Let the main config do the real work. config.loaded_site_config = True diff --git a/test/std/containers/sequences/array/iterators.pass.cpp b/test/std/containers/sequences/array/iterators.pass.cpp index 7d9050800dea..dd4aab30a026 100644 --- a/test/std/containers/sequences/array/iterators.pass.cpp +++ b/test/std/containers/sequences/array/iterators.pass.cpp @@ -132,10 +132,10 @@ int main() static_assert ( std::rbegin(c) != std::rend(c), ""); static_assert ( std::cbegin(c) != std::cend(c), ""); static_assert ( std::crbegin(c) != std::crend(c), ""); - + static_assert ( *c.begin() == 0, ""); static_assert ( *c.rbegin() == 4, ""); - + static_assert ( *std::begin(c) == 0, "" ); static_assert ( *std::cbegin(c) == 0, "" ); static_assert ( *std::rbegin(c) == 4, "" ); diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp new file mode 100644 index 000000000000..c5721f211abb --- /dev/null +++ b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03 + +// + +// template > +// class basic_istream; + +// basic_istream(basic_istream const& rhs) = delete; +// basic_istream& operator=(basic_istream const&) = delete; + +#include +#include +#include + +struct test_istream + : public std::basic_istream +{ + typedef std::basic_istream base; + + test_istream(test_istream&& s) + : base(std::move(s)) // OK + { + } + + test_istream& operator=(test_istream&& s) { + base::operator=(std::move(s)); // OK + return *this; + } + + test_istream(test_istream const& s) + : base(s) // expected-error {{call to deleted constructor of 'std::basic_istream'}} + { + } + + test_istream& operator=(test_istream const& s) { + base::operator=(s); // expected-error {{call to deleted member function 'operator='}} + return *this; + } + +}; + + +int main() +{ + +} diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp index 04cb9d3fb6ba..6e00f399306d 100644 --- a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp +++ b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp @@ -7,6 +7,8 @@ // //===----------------------------------------------------------------------===// +// UNSUPPORTED: c++98, c++03 + // // template > @@ -17,8 +19,6 @@ #include #include -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - template struct testbuf : public std::basic_streambuf @@ -37,11 +37,8 @@ struct test_istream : base(std::move(s)) {} }; -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - int main() { -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { testbuf sb; test_istream is1(&sb); @@ -74,5 +71,4 @@ int main() assert(is.precision() == 6); assert(is.getloc().name() == "C"); } -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES } diff --git a/test/std/iterators/iterator.range/begin-end.pass.cpp b/test/std/iterators/iterator.range/begin-end.pass.cpp index a0774888d567..2b5377f486f4 100644 --- a/test/std/iterators/iterator.range/begin-end.pass.cpp +++ b/test/std/iterators/iterator.range/begin-end.pass.cpp @@ -179,10 +179,10 @@ int main(){ static_assert ( std::rbegin(c) != std::rend(c), ""); static_assert ( std::cbegin(c) != std::cend(c), ""); static_assert ( std::crbegin(c) != std::crend(c), ""); - + static_assert ( *c.begin() == 0, ""); static_assert ( *c.rbegin() == 4, ""); - + static_assert ( *std::begin(c) == 0, "" ); static_assert ( *std::cbegin(c) == 0, "" ); static_assert ( *std::rbegin(c) == 4, "" ); @@ -191,7 +191,7 @@ int main(){ { static constexpr const int c[] = {0,1,2,3,4}; - + static_assert ( *std::begin(c) == 0, "" ); static_assert ( *std::cbegin(c) == 0, "" ); static_assert ( *std::rbegin(c) == 4, "" ); diff --git a/test/std/strings/string.view/string_view.literals/literal.pass.cpp b/test/std/strings/string.view/string_view.literals/literal.pass.cpp new file mode 100644 index 000000000000..9fb128ab0f55 --- /dev/null +++ b/test/std/strings/string.view/string_view.literals/literal.pass.cpp @@ -0,0 +1,57 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11 +// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8, clang-3.9 +// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8 +// Note: libc++ supports string_view before C++17, but literals were introduced in C++14 + +#include +#include + +int main() +{ + using namespace std::literals::string_view_literals; + + static_assert ( std::is_same::value, "" ); + static_assert ( std::is_same::value, "" ); + static_assert ( std::is_same::value, "" ); + static_assert ( std::is_same::value, "" ); + static_assert ( std::is_same::value, "" ); + + std::string_view foo; + std::wstring_view Lfoo; + std::u16string_view ufoo; + std::u32string_view Ufoo; + + foo = ""sv; assert( foo.size() == 0); + foo = u8""sv; assert( foo.size() == 0); + Lfoo = L""sv; assert(Lfoo.size() == 0); + ufoo = u""sv; assert(ufoo.size() == 0); + Ufoo = U""sv; assert(Ufoo.size() == 0); + + foo = " "sv; assert( foo.size() == 1); + foo = u8" "sv; assert( foo.size() == 1); + Lfoo = L" "sv; assert(Lfoo.size() == 1); + ufoo = u" "sv; assert(ufoo.size() == 1); + Ufoo = U" "sv; assert(Ufoo.size() == 1); + + foo = "ABC"sv; assert( foo == "ABC"); assert( foo == std::string_view ( "ABC")); + foo = u8"ABC"sv; assert( foo == u8"ABC"); assert( foo == std::string_view (u8"ABC")); + Lfoo = L"ABC"sv; assert(Lfoo == L"ABC"); assert(Lfoo == std::wstring_view ( L"ABC")); + ufoo = u"ABC"sv; assert(ufoo == u"ABC"); assert(ufoo == std::u16string_view( u"ABC")); + Ufoo = U"ABC"sv; assert(Ufoo == U"ABC"); assert(Ufoo == std::u32string_view( U"ABC")); + + static_assert( "ABC"sv.size() == 3, ""); + static_assert(u8"ABC"sv.size() == 3, ""); + static_assert( L"ABC"sv.size() == 3, ""); + static_assert( u"ABC"sv.size() == 3, ""); + static_assert( U"ABC"sv.size() == 3, ""); +} diff --git a/test/std/strings/string.view/string_view.literals/literal1.fail.cpp b/test/std/strings/string.view/string_view.literals/literal1.fail.cpp new file mode 100644 index 000000000000..6e6854f5559a --- /dev/null +++ b/test/std/strings/string.view/string_view.literals/literal1.fail.cpp @@ -0,0 +1,23 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11 +// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8, clang-3.9 +// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8 + +#include +#include + +int main() +{ + using std::string_view; + + string_view foo = ""sv; // should fail w/conversion operator not found +} diff --git a/test/std/strings/string.view/string_view.literals/literal1.pass.cpp b/test/std/strings/string.view/string_view.literals/literal1.pass.cpp new file mode 100644 index 000000000000..f663d022b2e1 --- /dev/null +++ b/test/std/strings/string.view/string_view.literals/literal1.pass.cpp @@ -0,0 +1,25 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11 +// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8, clang-3.9 +// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8 +// Note: libc++ supports string_view before C++17, but literals were introduced in C++14 + +#include +#include + +int main() +{ + using namespace std::literals; + + std::string_view foo = ""sv; + assert(foo.length() == 0); +} diff --git a/include/__undef___deallocate b/test/std/strings/string.view/string_view.literals/literal2.fail.cpp similarity index 52% rename from include/__undef___deallocate rename to test/std/strings/string.view/string_view.literals/literal2.fail.cpp index 52f4d9987e21..4907a55104e0 100644 --- a/include/__undef___deallocate +++ b/test/std/strings/string.view/string_view.literals/literal2.fail.cpp @@ -8,13 +8,14 @@ // //===----------------------------------------------------------------------===// -#ifdef __deallocate -#if !defined(_LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS) -#if defined(_MSC_VER) && !defined(__clang__) -_LIBCPP_WARNING("macro __deallocate is incompatible with C++. #undefining __deallocate") -#else -#warning: macro __deallocate is incompatible with C++. #undefining __deallocate -#endif -#endif -#undef __deallocate -#endif +// UNSUPPORTED: c++98, c++03, c++11 +// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8, clang-3.9 +// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8 + +#include +#include + +int main() +{ + std::string_view foo = ""sv; // should fail w/conversion operator not found +} diff --git a/test/std/strings/string.view/string_view.literals/literal2.pass.cpp b/test/std/strings/string.view/string_view.literals/literal2.pass.cpp new file mode 100644 index 000000000000..3bb6f6c0a0e3 --- /dev/null +++ b/test/std/strings/string.view/string_view.literals/literal2.pass.cpp @@ -0,0 +1,25 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11 +// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8, clang-3.9 +// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8 +// Note: libc++ supports string_view before C++17, but literals were introduced in C++14 + +#include +#include + +int main() +{ + using namespace std::literals::string_view_literals; + + std::string_view foo = ""sv; + assert(foo.length() == 0); +} diff --git a/test/std/strings/string.view/string_view.literals/literal3.pass.cpp b/test/std/strings/string.view/string_view.literals/literal3.pass.cpp new file mode 100644 index 000000000000..144a1cdd1c8a --- /dev/null +++ b/test/std/strings/string.view/string_view.literals/literal3.pass.cpp @@ -0,0 +1,25 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11 +// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8, clang-3.9 +// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8 +// Note: libc++ supports string_view before C++17, but literals were introduced in C++14 + +#include +#include + +int main() +{ + using namespace std; + + string_view foo = ""sv; + assert(foo.length() == 0); +} diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/test_deleter.h b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/test_deleter.h index bae1e013f571..6b3f1e2ab0de 100644 --- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/test_deleter.h +++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/test_deleter.h @@ -19,7 +19,9 @@ #include #include -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#include "test_macros.h" + +#if TEST_STD_VER >= 11 #define DELETE_FUNCTION = delete #else #define DELETE_FUNCTION { assert(false); } diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp index 624468671244..194e085ab04e 100644 --- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp @@ -38,7 +38,7 @@ int main() us1 %= std::chrono::milliseconds(3); assert(us1.count() == 2); } - + #if TEST_STD_VER > 14 static_assert(test_constexpr(), ""); #endif diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp index a4852d261f7e..7dcf002259bc 100644 --- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp @@ -34,7 +34,7 @@ int main() us %= 3; assert(us.count() == 2); } - + #if TEST_STD_VER > 14 static_assert(test_constexpr(), ""); #endif diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp index 0f76788c00ef..f3bf79035b0e 100644 --- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp @@ -34,7 +34,7 @@ int main() ns *= 5; assert(ns.count() == 15); } - + #if TEST_STD_VER > 14 static_assert(test_constexpr(), ""); #endif diff --git a/test/support/disable_missing_braces_warning.h b/test/support/disable_missing_braces_warning.h index c53eef8a951d..ac8b40728157 100644 --- a/test/support/disable_missing_braces_warning.h +++ b/test/support/disable_missing_braces_warning.h @@ -13,6 +13,8 @@ // Disable the missing braces warning for this reason. #if defined(__GNUC__) #pragma GCC diagnostic ignored "-Wmissing-braces" +#elif defined(__clang__) +#pragma clang diagnostic ignored "-Wmissing-braces" #endif #endif // SUPPORT_DISABLE_MISSING_BRACES_WARNING_H diff --git a/test/support/external_threads.cpp b/test/support/external_threads.cpp index 68ba96ff879e..019ab473aa11 100644 --- a/test/support/external_threads.cpp +++ b/test/support/external_threads.cpp @@ -6,5 +6,5 @@ // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#define _LIBCPP_BUILDING_THREAD_API_EXTERNAL_PTHREAD +#define _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL #include <__threading_support> diff --git a/test/support/nasty_macros.hpp b/test/support/nasty_macros.hpp index 074853ea0b8a..f6c8aaddbea6 100644 --- a/test/support/nasty_macros.hpp +++ b/test/support/nasty_macros.hpp @@ -37,4 +37,11 @@ #define _Y NASTY_MACRO #define _Z NASTY_MACRO +// Test that libc++ doesn't use names reserved by WIN32 API Macros. +// NOTE: Obviously we can only define these on non-windows platforms. +#ifndef _WIN32 +#define __deallocate NASTY_MACRO +#define __out NASTY_MACRO +#endif + #endif // SUPPORT_NASTY_MACROS_HPP diff --git a/test/support/test_iterators.h b/test/support/test_iterators.h index 379933eb51b4..a2c22b09de84 100644 --- a/test/support/test_iterators.h +++ b/test/support/test_iterators.h @@ -17,7 +17,7 @@ #include "test_macros.h" -#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS +#if TEST_STD_VER >= 11 #define DELETE_FUNCTION = delete #else #define DELETE_FUNCTION diff --git a/www/cxx1z_status.html b/www/cxx1z_status.html index 7c15fdfc4ce3..22503b98016e 100644 --- a/www/cxx1z_status.html +++ b/www/cxx1z_status.html @@ -124,7 +124,7 @@ P0003R5LWGRemoving Deprecated Exception Specifications from C++17Issaquah P0067R5LWGElementary string conversions, revision 5Issaquah - P0403R1LWGLiteral suffixes for basic_string_viewIssaquah + P0403R1LWGLiteral suffixes for basic_string_viewIssaquahComplete4.0 P0414R2LWGMerging shared_ptr changes from Library Fundamentals to C++17Issaquah P0418R2LWGFail or succeed: there is no atomic latticeIssaquah P0426R1LWGConstexpr for std::char_traitsIssaquah