tree 194fb674530718f577fa244699ed446f8339a8f4
parent 7dbe5d1de73d3442595e51c90c5ba611bd35815e
author Alan Zhao <ayzhao@google.com> 1655357757 +0000
committer Copybara-Service <copybara-worker@google.com> 1655359052 -0700

Revert "Roll src/buildtools/third_party/libc++/trunk/ b1269813e..1a637088a (287 commits)"

This reverts commit 49792f173a1be0abefae749285e8590e84889fb2.

Reason for revert: Create revert as part of the procedure to update libassistant per wutao's instructions in https://crrev.com/c/3702740.

Original change's description:
> Roll src/buildtools/third_party/libc++/trunk/ b1269813e..1a637088a (287 commits)
>
> In order to get the chromeos buidls to pass (broken by this CL due to
> libassistant), we need to first submit this CL so libassistant can pick
> up buildtools, revert this CL, and then resubmit once libassistant has
> been updated.
>
> Additionally, reenable libc++ debug mode with ThinLTO since this is
> resolved by https://reviews.llvm.org/D122941.
>
> Additional changes to get this to build:
> * Regenerate absl
> * Regenerate gvr shims
> * Update #pragma clang_max_tokens as necessary
>
> https://chromium.googlesource.com/external/github.com/llvm/llvm-project/libcxx.git/+log/b1269813eaf5..1a637088a36d
>
> $ git log b1269813e..1a637088a --date=short --no-merges --format='%ad %ae %s'
> 2022-06-12 koraq [libc++][NFC] Use concepts in <bit>.
> 2022-06-12 koraq [libc++] Removes unneeded includes.
> 2022-06-12 koraq [libc++] Removes a GCC bug work-around.
> 2022-06-12 koraq [libc++][test] Remove support old compiler support.
> 2022-05-26 ldionne.2 [libc++] Do not yield from __sp_mut::lock()
> 2022-06-13 nikolasklauser [libc++] Fix std::lower_bound with C++20-hostile iterators
> 2022-03-28 phosek [CMake][libcxx] Use target_include_directories for libc++ headers
> 2022-06-11 nikolasklauser [libc++] Use unsigned char in basic_string::__short again
> 2022-06-11 joeloser93 [libc++][test] Add tuple trivial destructor test
> 2022-05-28 joeloser93 [libc++][test] Refactor SmallBasicString uses in range.lazy.split tests
> 2022-06-11 nikolasklauser [libc++][NFC] Update ranges algorithms status page
> 2021-10-02 koraq [libc++][format] Implement format-string.
> 2022-06-10 nikolasklauser [libc++] Use the same implementation of invoke for C++03 and C++11
> 2022-06-10 nikolasklauser [libc++] Granularize <iterator> includes
> 2022-06-10 nikolasklauser [libc++] Simplify type_traits and use more builtins
> 2022-06-10 ldionne.2 [libc++] Make sure we install the modulemap file with install-cxx-headers
> 2022-06-10 nikolasklauser [libc++] Remove uses of __two in type_traits
> 2022-06-10 ldionne.2 [libc++][NFC] Fix indentation of some #if directives
> 2022-06-10 nikolasklauser [libc++] Granularize even more of type_traits
> 2022-06-07 nikolasklauser [libc++] Implement ranges::replace{, _if}
> 2022-06-09 koraq [libc++] Fixes CI after Jammy update.
> 2022-06-09 ldionne.2 [libc++] Mark GDB pretty printers as unsupported on GCC 11.2 to make CI green
> 2022-06-06 martin [libcxx] [doc] Add a release note for distributors about MinGW builds and dllimport
> 2022-06-06 nikolasklauser [libc++] Granularize __string
> 2022-06-09 fmayer [NFC] change error message wording.
> 2022-06-07 fmayer [libcxx] improve LIBCXX_ABI_NAMESPACE error message
> 2022-05-30 koraq [libc++][CI] Updates Docker image.
> 2021-06-08 ldionne.2 [libc++] Towards a simpler extern template story in libc++
> 2022-05-23 ldionne.2 [libc++] Fix modules builds when features are removed
> 2022-06-08 koraq Revert "[libc++][CI] Updates Docker image."
> 2022-06-08 ldionne.2 [libc++][NFC] Add missing 'return 0'
> 2022-06-07 ldionne.2 [libc++][NFC] Simplify enable_if for std::copy optimization
> 2022-06-08 ldionne.2 [libc++] Make sure we add /llvm to the list of safe directories
> 2022-06-08 nikolasklauser [libc++] Implement ranges::adjacent_find
> 2022-06-07 joeloser93 Revert "[libc++][test] Mark ranges.transform.pass.cpp UNSUPPORTED for AIX"
> 2022-04-01 ldionne.2 [libc++] Make the Debug mode a configuration-time only option
> 2022-05-31 koraq [libc++] Removes _LIBCPP_AVAILABILITY_TO_CHARS.
> 2022-05-30 koraq [libc++][CI] Updates Docker image.
> 2022-06-02 koraq [libc++] Don't use static constexpr in headers.
> 2022-06-07 ldionne.2 [libc++] Forgot to bump the CI timeout everywhere
> 2022-06-07 ldionne.2 [libc++] Bump timeout to avoid spurious failures on AIX
> 2022-06-06 nikolasklauser [libc++] Implement ranges::find_first_of
> 2022-04-10 martin [libcxx] Omit dllimport in public headers in MinGW mode
> 2022-04-11 martin [libcxx] [test] Don't use header defines for detecting linking against a DLL
> 2022-06-06 ldionne.2 [libc++][NFC] Move span tests under views.span
> 2022-06-06 ldionne.2 [libc++][NFC] Fix outdated comment in span test
> 2022-06-06 ldionne.2 [libc++][NFC] Add missing includes
> 2022-05-05 ldionne.2 [libc++] Avoid creating temporaries in unary expressions involving valarray
> 2022-06-03 ldionne.2 [libc++] Remove a bunch of conditionals on _LIBCPP_DEBUG_LEVEL
> 2022-06-05 nikolasklauser [libc++][ranges] Implement ranges::binary_search and ranges::{lower, upper}_bound
> (...)
> 2022-04-05 aeubanks [libcxx] Add flag to disable __builtin_assume in _LIBCPP_ASSERT
> 2022-04-04 ldionne.2 [libc++] Add back-deployment testing on arm64 macs
> 2022-04-07 nikolasklauser [libc++][ranges] Implement ranges::count{, _if}
> 2022-04-06 nikolasklauser [libc++] Remove redundant __invoke_constexpr functions
> 2022-04-07 nikolasklauser [libc++][ranges] Add implicit conversion to bool test for ranges::find{, if, if_not}
> 2022-02-25 martin [libcxx] [test] Stop defining LIBCXX-WINDOWS-FIXME
> 2022-04-05 koraq [libc++] Use cpp20_output_iterator in tests.
> 2022-04-03 koraq [NFC][libc++] Modularize chrono's calendar.
> 2021-10-26 ldionne.2 [libc++] Support arrays in make_shared and allocate_shared (P0674R1)
> 2022-03-10 martin [libcxx] [test] Remove UNSUPPORTED markings for mingw issues that no longer are present in CI
> 2022-04-05 ldionne.2 [libc++] Remove error about _LIBCPP_ALTERNATE_STRING_LAYOUT not being supported anymore
> 2022-04-05 ldionne.2 [libc++][NFC] Remove stray whitespace in comment
> 2022-01-20 martin [libcxx] [test] Fix the locale ctype widen tests on Windows
> 2022-04-05 hui.xie1990 [libc++] add global variable template std::views::empty
> 2022-03-19 koraq [libc++][test] Adds an cpp20_output_iterator.
> 2022-04-04 ldionne.2 [libc++] Tidy up tests for deduction guides and other compile-time failing properties in std::string
> 2022-04-05 ldionne.2 [libc++] Silence new deprecation warnings for C functions in tests
> 2022-04-05 nikolasklauser [libc++][ranges] Implement ranges::transform
> 2022-03-25 ldionne.2 [libc++] Implement tests for private headers using the new generator
> 2022-03-23 martin [libcxx] Stop recommending setting LIBCXX_HAS_WIN32_THREAD_API in the MinGW builds
> 2022-03-31 ldionne.2 [libc++] Fix std::is_array<T[0]> and add tests
> 2022-04-04 ldionne.2 [libc++][NFC] Rename generate_assertion_tests.py to generate_header_tests.py
> 2022-03-25 ldionne.2 [libc++] Implement all public header tests using the new generator
> 2022-04-03 ldionne.2 [libc++] Remove unused <iosfwd> include from <__debug>
> 2022-04-03 ldionne.2 [libc++][NFC] Fix weird indentation in test
> 2022-04-03 nikolasklauser [libc++][ranges] Implement ranges::max
> 2022-03-31 nikolasklauser [libc++] Canonicalize the ranges results and their tests
> 2022-03-30 martin [libcxx] [test] Avoid spurious test breakage in clang-cl-dll configs with newer CMake
> 2022-03-31 martin [libcxx] [ci] Enable -Werror for libcxxabi and libunwind too
> 2022-03-31 koraq [libc++] Fixes calendar function visibility.
> 2022-03-30 koraq [libc++][ci] Installs Japanese locale in Docker.
> 2022-03-27 koraq [libc++][doc] Update formatting status.
> 2022-03-31 ldionne.2 [libc++] Install psutil on the macOS nodes
> 2022-03-23 ldionne.2 [libc++] Remove the __libcpp_version file
> 2022-03-02 ldionne.2 [libc++] Add a CI job running MSAN
> 2022-03-30 martin [libcxx] [doc] Update Windows build instructions after deprecating the legacy standalone builds
> 2022-03-25 ldionne.2 [libc++] Ensure that all public C++ headers include <__assert>
> 2022-03-04 ldionne.2 [libunwind] Add a _LIBUNWIND_VERSION macro
> 2022-03-24 ldionne.2 [libc++] Use __builtin_expect and __builtin_assume in _LIBCPP_ASSERT
> 2022-03-29 ldionne.2 [libc++][NFC] Fix typo in comment
> 2022-03-28 ldionne.2 [libc++][libc++abi] Serialize the enable_assertions Lit parameter in the generated config
> 2022-03-28 brad [libcxx] random_device, specify optimal entropy properties for all OS's using arc4random()
> 2022-03-27 koraq [libc++][doc] Update format implementation status.
> 2021-09-04 koraq [libc++][format][2/6] Adds a __output_iterator.
> 2022-03-23 ldionne.2 [libc++] Remove the _LIBCPP_BOOL_CONSTANT macro
> 2022-03-18 nikolasklauser [libc++] Rename __identity to __type_identity
> 2022-03-24 ldionne.2 [libc++] Audit all uses of _LIBCPP_ASSERT and _LIBCPP_DEBUG_ASSERT
> 2022-03-24 ldionne.2 [libc++][NFC] Refactor the ABI changelog
> 2022-03-24 ldionne.2 [libc++][NFC] Update ABI changelog to account for new assertion handler
> 2022-03-03 ldionne.2 [libc++] Add a lightweight overridable assertion handler
>
> Created with:
>   roll-dep src/buildtools/third_party/libc++/trunk
>
> Bug: 1273285
> Change-Id: I46b3a6b4b1263bcd9ed4b7ef443a7388e1d52cc3
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3702740
> Commit-Queue: Alan Zhao <ayzhao@google.com>
> Owners-Override: Nico Weber <thakis@chromium.org>
> Reviewed-by: Nico Weber <thakis@chromium.org>
> Cr-Commit-Position: refs/heads/main@{#1014777}

Bug: 1273285
Change-Id: I2dabf7eb995fd94837729de03e654edeab424b95
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3708965
Reviewed-by: Tao Wu <wutao@chromium.org>
Owners-Override: Zain Afzal <zafzal@google.com>
Auto-Submit: Alan Zhao <ayzhao@google.com>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Zain Afzal <zafzal@google.com>
Reviewed-by: Zain Afzal <zafzal@google.com>
Cr-Commit-Position: refs/heads/main@{#1014801}
NOKEYCHECK=True
GitOrigin-RevId: 67e5cfc8a6bf41b3d39a52f1fe5a10625a1babf5
