tree 04df3a39beab7c1f1873566c301b2629120710dd
parent 31d704a1a8f2986051d0ebfe74b102968996c45e
author luci-bisection@appspot.gserviceaccount.com <luci-bisection@appspot.gserviceaccount.com> 1776753983 -0700
committer Copybara-Service <copybara-worker@google.com> 1776754182 -0700

Revert "Roll libc++ from cb9c06560a68 to af4386908c37 (64 revisions)"

This reverts commit 1a580b58216b763955184e9796d04bbac5fc6010.

Reason for revert:
LUCI Bisection has identified this change as the cause of a test failure. See the analysis: https://ci.chromium.org/ui/p/chromium/bisection/test-analysis/b/5380712057274368

Sample build with failed test: https://ci.chromium.org/b/8683959806504414017
Affected test(s):
[://remoting\:remoting_unittests!gtest::WebrtcTransportTest#Connects](https://ci.chromium.org/ui/test/chromium/:%2F%2Fremoting%5C:remoting_unittests%21gtest::WebrtcTransportTest%23Connects?q=VHash%3A7b15a58160a124d1)
[://third_party/perfetto\:perfetto_unittests!gtest::TracingServiceImplTest#StartTracingTriggerDeferredStart](https://ci.chromium.org/ui/test/chromium/:%2F%2Fthird_party%2Fperfetto%5C:perfetto_unittests%21gtest::TracingServiceImplTest%23StartTracingTriggerDeferredStart?q=VHash%3A420a05dd3ad0603a)

If this is a false positive, please report it at http://b.corp.google.com/createIssue?component=1199205&description=Analysis%3A+https%3A%2F%2Fci.chromium.org%2Fui%2Fp%2Fchromium%2Fbisection%2Ftest-analysis%2Fb%2F5380712057274368&format=PLAIN&priority=P3&title=Wrongly+blamed+https%3A%2F%2Fchromium-review.googlesource.com%2Fc%2Fchromium%2Fsrc%2F%2B%2F7495232&type=BUG

Original change's description:
> Roll libc++ from cb9c06560a68 to af4386908c37 (64 revisions)
>
> buildtools/third_party/libc++/__config_site needs two additions for
> these two commits:
>
> 2026-01-09 nikolasklauser@berlin.de [libc++] Introduce the notion of a minimum header version (#166074)
> 2026-01-15 vturanskyy@gmail.com [libc++] Provide flag for RUNTIMES_USE_LIBC=llvm-libc (#174967)
>
> Depends on:
> https://chromium-review.googlesource.com/c/chromium/src/+/7774536
>
> https://chromium.googlesource.com/external/github.com/llvm/llvm-project/libcxx.git/+log/cb9c06560a68..af4386908c37
>
> 2026-01-19 com.webkit.iidmsa@gmail.com [libc++] Use correct Apple platform naming (#176290)
> 2026-01-19 com.webkit.iidmsa@gmail.com [libc++] Remove redundant code after static_assert(false) (#176294)
> 2026-01-19 ldionne.2@gmail.com [libc++] Update maintainer list (#175044)
> 2026-01-19 nikolasklauser@berlin.de [libc++] Remove benchmarks for ranges algorithms that have a std equivalent (#176138)
> 2026-01-16 aidengrossman@google.com [libcxx] Bump release runner image version (#176184)
> 2026-01-16 de34@live.cn [libc++][test] Fix `constexpr` stdver. for tests for `find_if(_not)` (#176303)
> 2026-01-15 vturanskyy@gmail.com [libc++] Provide flag for RUNTIMES_USE_LIBC=llvm-libc (#174967)
> 2026-01-15 nikolasklauser@berlin.de Reapply "[libc++] Optimize std::find_if" (#175903) (#175921)
> 2026-01-14 com.webkit.iidmsa@gmail.com [libc++] Add parentheses around shift operations in bitwise expressions (#175407)
> 2026-01-14 ldionne.2@gmail.com [libc++][NFC] Refactor __request_unbuffered_mode (#168950)
> 2026-01-14 ldionne.2@gmail.com [runtimes] Post-branch tasks for the LLVM 23 release (#176007)
> 2026-01-14 ldionne.2@gmail.com [libc++] Remove CSV tracking for PSTL (#175797)
> 2026-01-14 nikolasklauser@berlin.de [libc++] Add benchmarks to the associative containers that don't go to the end of the container (#175005)
> 2026-01-14 prabhukr@google.com [libc++] Fix use of static in constexpr (#175667)
> 2026-01-14 nikolasklauser@berlin.de Revert "[libc++] Optimize std::find_if" (#175903)
> 2026-01-14 hghristov.rmm@gmail.com [libc++][ranges][NFC] Merge  `join_with_view`s `[[nodiscard]]` tests (#175734)
> 2026-01-13 ldionne.2@gmail.com [libc++] Fix backslash substitution in RST synchronization scripts
> 2026-01-13 ldionne.2@gmail.com [libc++] Improve the script to manage libc++ conformance issues (#172905)
> 2026-01-13 hghristov.rmm@gmail.com [libc++][ranges][NFC] Cleanup `nodiscard.verify.cpp` tests (#175725)
> 2026-01-13 nikolasklauser@berlin.de [libc++] Simplify __unwrap_iter a bit (#175153)
> 2026-01-13 hghristov.rmm@gmail.com [libc++][ranges] Applied `[[nodiscard]]` to Range access (#173550)
> 2026-01-13 de34@live.cn [libc++][test] Move the SFINAE test for return types of `quoted` to `libcxx/test/libcxx/` (#157026)
> 2026-01-13 ldionne.2@gmail.com [libc++] Fix typo in math special functions
> 2026-01-13 nikolasklauser@berlin.de [libc++] Replace uses of _LIBCPP_WEAK with [[gnu::weak]] (#171798)
> 2026-01-13 nikolasklauser@berlin.de [libc++] Optimize std::find_if (#167697)
> 2026-01-13 nikolasklauser@berlin.de [libc++] Remove empty container benchmarks that are meaningless from the associative containers (#175180)
> 2026-01-13 hehiralbi@gmail.com [libc++][NFC] Remove unused __key_equiv from flat_multimap and flat_multiset (#175612)
> 2026-01-13 nikolasklauser@berlin.de [libc++] Annotate filesystem::path with [[clang::lifetimebound]] (#175507)
> 2026-01-13 cullen.rhodes@arm.com Bump version to 23.0.0-git
> 2026-01-13 hghristov.rmm@gmail.com [libc++][istream] Removed `[[nodiscard]]` from `peek()` (#175591)
> 2026-01-12 nikolasklauser@berlin.de [libc++] Remove some low value benchmarks (#175178)
> 2026-01-12 ldionne.2@gmail.com [libc++] Fix filebuf resetting its underlying buffer upon close() (#168947)
> 2026-01-12 hghristov.rmm@gmail.com [libc++][memory_resource] Applied `[[nodiscard]]` (#172134)
> 2026-01-12 eiytoq@outlook.com [libc++] Removed unused internal helper functions from the midpoint.h header (#175514)
> 2026-01-12 nikolasklauser@berlin.de [libc++] Make basic_string::__erase_external_with_move noexcept (#171591)
> 2026-01-12 hghristov.rmm@gmail.com [libc++][scoped_allocator] Applied `[[nodiscard]]` (#175291)
> 2026-01-11 hghristov.rmm@gmail.com [libc++][NFC] Refactored `nodiscard.verify.cpp` tests (#175285)
> 2026-01-11 hghristov.rmm@gmail.com [libc++][chrono][NFC] Refactor `nodiscard.verify.cpp` (#175411)
> 2026-01-10 aidengrossman@google.com [libcxx][Github] Bump container version in premerge CI
> 2026-01-10 aidengrossman@google.com [libcxx][Github] Bump Github Runner Version to v2.331.0
> 2026-01-10 eiytoq@outlook.com [libc++][mdspan][NFC] Remove redundant `else` and trailing semicolons (#175024)
> 2026-01-10 wtranviet@proton.me [libc++] Guard `optional::iterator` range variables behind experimental (#175222)
> 2026-01-10 de34@live.cn [libc++][NFC] Small cleanups for `any` (#175164)
> 2026-01-10 vojta.michall@email.cz [libcxx] Add missing member `cend()` to `MinSequenceContainer` (#175114)
> 2026-01-09 nikolasklauser@berlin.de [libc++] Make optional::iterator experimental (#173470)
> 2026-01-09 nikolasklauser@berlin.de [libc++][NFC] Simplify the implementation of __mul_overflowed (#174956)
> 2026-01-09 nikolasklauser@berlin.de [libc++][NFC] Refactor _LIBCPP_OVERRIDABLE_FUNCTION to be a normal attribute macro (#174964)
> 2026-01-09 nikolasklauser@berlin.de [libc++] Fix {deque,vector}::append_range assuming too much about the types (#162438)
> 2026-01-09 nikolasklauser@berlin.de [libc++] Refactor variant benchmarks (#174743)
> 2026-01-09 nikolasklauser@berlin.de [libc++] Introduce the notion of a minimum header version (#166074)
> 2026-01-09 wtranviet@proton.me [libc++] Correct `optional<T&>` implementation (#174537)
> 2026-01-08 eiytoq@outlook.com [libc++] Fix LWG 4265: std::midpoint should not accept const bool (#174579)
> 2026-01-08 nikolasklauser@berlin.de [libc++][NFC] Update <any> to a more modern code style (#174619)
> 2026-01-08 hghristov.rmm@gmail.com [libc++][future] Applied `[[nodiscard]]` (#174924)
> 2026-01-08 nikolasklauser@berlin.de [libc++] Update our release notes for the upcoming release (#174625)
> 2026-01-08 nikolasklauser@berlin.de [libc++] Avoid ranges::upper_bound inside <format> (#173150)
> 2026-01-08 nikolasklauser@berlin.de [libc++] Remove numpunct_byname::__init (#173283)
> 2026-01-08 nikolasklauser@berlin.de [libc++] Optimize search_n (#171389)
> 2026-01-08 hghristov.rmm@gmail.com [libc++][memory] Applied `[[nodiscard]]` to more functions (#172131)
> 2026-01-08 hghristov.rmm@gmail.com [libc++][numeric]  Modernized `std::midpoint` (#174596)
> 2026-01-08 de34@live.cn [libc++] Revert undesired `[[nodiscard]]` added to conversion functions (#173658)
> 2026-01-07 hui.xie1990@gmail.com [libc++] Refactor poll_with_backoff (#173184)
> 2026-01-07 ldionne.2@gmail.com [libc++] Force rebuilding of the CI Docker image
> 2026-01-07 nikolasklauser@berlin.de [libc++] Add benchmark for std::find(vector<short>)
>
> If this roll has caused a breakage, revert this CL and stop the roller
> using the controls here:
> https://autoroll.skia.org/r/libcxx-chromium
> Please CC hans@chromium.org,thakis@chromium.org on the revert to ensure that a human
> is aware of the problem.
>
> To file a bug in Chromium: https://bugs.chromium.org/p/chromium/issues/entry
>
> To report a problem with the AutoRoller itself, please file a bug:
> https://issues.skia.org/issues/new?component=1389291&template=1850622
>
> Documentation for the AutoRoller is here:
> https://skia.googlesource.com/buildbot/+doc/main/autoroll/README.md
>
> Bug: 503250165
> Change-Id: I927d67b5eeb35cb15f917542e08cc7c0b4c58884
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/7495232
> Reviewed-by: Arthur Eubanks <aeubanks@google.com>
> Commit-Queue: Nico Weber <thakis@chromium.org>
> Cr-Commit-Position: refs/heads/main@{#1617751}
>

Bug: 503250165
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Change-Id: Id621b69227589acc60ec905a756258ec4716ce85
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/7779915
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Owners-Override: Hayato Ito <hayato@chromium.org>
Commit-Queue: Hayato Ito <hayato@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1618005}
NOKEYCHECK=True
GitOrigin-RevId: 0e9a02cf34a176c095e5acd67afa5e3d5db5a4f5
