[Libcxx] Add <source_location> header.

[jyknight]

Summary

This requires the __builtin_source_location() builtin, as implemented
by GCC and Clang.

[curdeius]

FWIW, you can maybe check if there is any test (or anything else) to take from https://reviews.llvm.org/D80376 (my failed attempt to implement this, but without clang's built-in).

[philnik]

Looks like you have to run ninja libcxx-generate-files.

libcxx/include/source_location

41

44–45

64–75

78

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

17–20

This should be something along the lines of // UNSUPPORTED: clang-13, depending on when __builtin_source_location was implemented.

[philnik]

You also have to add the header to libcxx/include/modules.modulemap and libcxx/include/CMakeLists.txt.

libcxx/include/version

361–364

You should edit libcxx/utils/generate_feature_test_macro_components.py. This is a generated file.

[• Quuxplusone]

+1 to all @philnik's comments. Looks pretty decent otherwise; let's see what buildkite thinks of it!

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

12–15

44

By convention (something about freestanding support): int main(int, char**) {
and return 0; at the end. See any other test file for comparison.

[Mordante]

Thanks for working on this! Some additional comments.

libcxx/include/source_location

12

Please update the source_location status in docs/Cxx2aStatusPaperStatus.csv. Look like this implements both both P1208 and LWG-3396.

29

This header needs to be included in all library header, it provides all important macros like _LIBCPP_BEGIN_NAMESPACE_STD.

56

The __ptr argument differs from the wording in the Standard, can you add comment why this is done?

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

17–20

Since the clang part is under review it should be also unsupported in clang-13 and apple-clang-12.
All our supported platforms are tested in the precommit CI so it's possible to see which other platforms fail.

[jyknight]

Update per review comments.

[jyknight]

In D120634#3347963, @philnik wrote:

Looks like you have to run ninja libcxx-generate-files.

Done.

In D120634#3347972, @philnik wrote:

You also have to add the header to libcxx/include/modules.modulemap and libcxx/include/CMakeLists.txt.

Done.

libcxx/include/source_location

31–32

I'd like a reviewer to opine on this question here.

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

17–20

Well, it's not implemented until the patch this depends on. So it'll be implemented as of clang-15 -- but current builds of clang-15 don't have that support. Should I just put "// UNSUPPORTED: clang-13, clang-14"? Will that cause problems with test-bots? I'll submit the other patch first -- but do libcxx bots run with older builds of unreleased head clang? Guess I'll just try and see what happens...

[philnik]

libcxx/include/source_location

31–32

Including the header should be fine.

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

17–20

CI doesn't run a trunk clang, so it should just be // UNSUPPORTED: clang-13 clang-14 and the others that don't work.

[jyknight]

So, in doing further testing, I've noticed a problem. Currently, clang cannot compile code that calls a consteval function in a default argument. (see https://github.com/llvm/llvm-project/issues/48230 and https://reviews.llvm.org/D119646)

E.g., clang -std=c++20 -fsyntax-only consteval.cc given:

consteval int foo() { return 1; }
int bar(int N = foo()) { return N; }
int main() { return bar(); }

raises "error: cannot take address of consteval function 'foo' outside of an immediate invocation", incorrectly.

The same issue occurs with the consteval std::source_location::current() -- which makes it effectively impossible to use std::source_location::current() as it's intended to be used, in a default-argument.

[• Quuxplusone]

libcxx/include/source_location

31–32

IMHO #include <cstdint> is fine (but please move it up with the others and alphabetize).
(If @ldionne disagrees, go with what he says.)

44–45

Nit: s/REQUIRED/required/ (the emphasis is unnecessary, and potentially briefly confusing in that REQUIRED has a special meaning in tests). I might reword this comment as

// The names source_location::__impl, _M_file_name, _M_function_name, _M_line, and _M_column
// are hard-coded in the compiler and must not be changed here.

(Note for users of git grep: These names are not hard-coded in Clang yet; they're part of D120159 which has not yet landed.)

58–59

My kneejerk reaction here was "this indentation is messed up," but then my eyes refocused. ;)
I suggest reflowing as

static consteval
source_location current(const void *__ptr = __builtin_source_location()) noexcept {

Using const void * instead of decltype(__builtin_source_location()) helps readability and doesn't seem to hurt anything since you're already doing the cast on line 61. In fact, at that point I'd remove the comment on line 60 because now the cast isn't unusual-looking at all.

(2) Should we use _LIBCPP_HIDE_FROM_ABI here, even though it's consteval? I don't know.

libcxx/utils/generate_feature_test_macro_components.py

636–642

Please git grep source_location ../libcxx/docs/ and see whether you can check off any relevant papers or issues. (Also of course git grep source_location ../libcxx in general.)

[philnik]

libcxx/include/source_location

58–59

(2) Should we use _LIBCPP_HIDE_FROM_ABI here, even though it's consteval? I don't know.

I don't think so. A consteval function can never be part of any ABI, so there is no need to mark it as _LIBCPP_HIDE_FOM_ABI.

[EricWF]

libcxx/include/source_location

58–59

I don't think using const void* improves readability. Why do you say that?

@Quuxplusone Going forward the project should take a "format and forget about it" approach to whitespace changes. What's correct is what clang-format spits out. I don't believe reviewing whitespace changes is a good use of engineering effort.

65

When does this constructor get called?

I assume it's in the spec?

[Mordante]

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

17–20

Well, it's not implemented until the patch this depends on. So it'll be implemented as of clang-15 -- but current builds of clang-15 don't have that support. Should I just put "// UNSUPPORTED: clang-13, clang-14"? Will that cause problems with test-bots? I'll submit the other patch first -- but do libcxx bots run with older builds of unreleased head clang? Guess I'll just try and see what happens...

The CI uses nightly Ubuntu builds, but the Docker file isn't automatically updated. This means:

• we first need to land the clang patch
• wait a short while before it's available in Ubuntu
• ask @ldionne to update the Docker image
• wait a while until the new image is used in the CI

This isn't ideal, but we've used this approach for other patches with dependencies on the CI running the latest version of our Docker file.

[ldionne]

Does this mean we'll only implement source_location with Clang? Or does GCC provide a similar builtin? If so, are both compatible?

libcxx/include/source_location

31–32

Yeah, I'd rather use uint_least32_t and include the header than use the more arcane __UINT_LEAST32_TYPE__.

58–59

We've had numerous discussions about clang-format in the past several months. Please consult the Discord archive for details, but long story short, the current state of things is that we're going to first agree on a clang-format configuration that is suitable, and then slowly move towards it for new code. It hasn't happened yet.

Regarding decltype(__builtin_source_location()), you could also just use auto* instead.

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

17–20

@Mordante is correct -- basically we'll need to wait a bit after the Clang patch lands for the Docker images to be refreshed and then all CI will be running with a Clang that supports the builtin. In the meantime, only the Bootstraping build bot would is relevant, since it's the only one that's going to run this test.

33

I'd like us to test the return type of all these functions. We usually do something like std::same_as<uint_least32_t> auto line = empty.line();.

[EricWF]

libcxx/include/source_location

58–59

Fantastic. Let's do that. Because reviewing whitespace is in nobodys best interest.
And if we can't agree on a clang-format configuration, then we can't agree on whitespace, and we shouldn't bog any review down changing it.

[jyknight]

Update for review comments.

[jyknight]

libcxx/include/source_location

58–59

Can't use auto* in the argument type -- that'd make this into a function template.

I don't want to use a const void * argument, because constexprs are not allowed to cast back _from_ void*, even if the underlying object is a T and you're casting to T*. (However, note that I did add a hack to Clang to support libstdc++ -- which DOES have that invalid cast that GCC doesn't diagnose, but I wouldn't want to introduce the same issue into libc++.)

I can move the decltype into a separate using __bsl_ty = decltype(__builtin_source_location()); line to improve readability.

65

Not sure what you mean. Yes, a default constructor is required by the spec.

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

17–20

The GCC bot should be running the test already.

Are you sure the bootstrapping build is doing this? Because if so, it should've failed (as clang-15 isn't marked unsupported), but it didn't.

libcxx/utils/generate_feature_test_macro_components.py

636–642

Did that already in the preceding update.

[jyknight]

In D120634#3352084, @ldionne wrote:

Does this mean we'll only implement source_location with Clang? Or does GCC provide a similar builtin? If so, are both compatible?

No, GCC implements the same builtin with the same semantics, modulo the return type.

[ldionne]

LGTM. I might make a minor pass on the test to make it look more like our other tests (in particular try to avoid duplication of constexpr and non-constexpr tests), but overall this LGTM.

Thanks a whole lot for working on this, we really needed someone to step up and implement this with the help of the compiler.

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

17–20

Yes, I am sure the bootstrapping build is running with the just-built Clang. Is it possible that CI ran alongside with the parent commit too? I think that's how it works.

[philnik]

LGTM % comments.

libcxx/include/source_location

67–72

I'd like to see __ptr_ != nullptr

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

65

Could you == 0 or cast one to string_view for comparison? The current code looks a lot like they should not be equal. Ditto below.

[• Quuxplusone]

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

66

Too bad we can't std::string_view(local.function_name()).contains("main") until C++23. :(

+1 for assert(strcmp(local.file_name(), "ss") == 0) above (and lines 72,73,79,80...) and for assert(strstr(local.function_name(), "main") != nullptr) here.

[philnik]

@jyknight is there a reason you don't work on this currently?

[jyknight]

I mentioned on Chat, but I see I didn't mention here: I'm not sure there's much point in committing this to libc++ until https://github.com/llvm/llvm-project/issues/48230 has been fixed in Clang, so that it can be properly used.

[ChuanqiXu]

Given https://github.com/llvm/llvm-project/issues/48230 is closed, maybe we could move forward on this direction.

[philnik]

@jyknight Do you plan to finish this PR? If not I'd be happy to complete it.

[ldionne]

I think we should try to ship this in LLVM 16!

[Mordante]

In D120634#3752666, @ldionne wrote:

I think we should try to ship this in LLVM 16!

+1 for what it's worth the libc++ pre-commit CI now uses Clang-16. So if the issues are fixed in Clang-16 it might be worth to rebase the patch.

[AlexApps99]

Are there any remaining blockers on this being merged?

[jyknight]

At this point, std::source_location::current() does still give the "wrong" result when used as a default argument.

After the discussion in https://reviews.llvm.org/D129488#3762490 about the unfortunate interaction between the specified behavior of source_location and consteval, the issue was brought to WG21 for comment, and is still under discussion there. I thought a possible outcome may be to switch current() from being consteval to instead being constexpr, but perhaps the consteval semantics will be changed, instead.

See also https://cplusplus.github.io/CWG/issues/2631.html

[ldionne]

In D120634#3811941, @jyknight wrote:

At this point, std::source_location::current() does still give the "wrong" result when used as a default argument.

After the discussion in https://reviews.llvm.org/D129488#3762490 about the unfortunate interaction between the specified behavior of source_location and consteval, the issue was brought to WG21 for comment, and is still under discussion there. I thought a possible outcome may be to switch current() from being consteval to instead being constexpr, but perhaps the consteval semantics will be changed, instead.

See also https://cplusplus.github.io/CWG/issues/2631.html

Naive question, but would everything work properly if libc++ used constexpr instead? As-in, would this patch work if you only changed that consteval to constexpr?

If so, I think it would be reasonable to do it. Concretely, we'll probably have an answer to this issue by the end of November in Kona, so we'll be able to fix it by the time we release LLVM 16. Also, constexpr is strictly more restrictive than consteval, so we could even ship it that way if it came to that. It would be subtly non-conforming, but at least it would give the right answer and users could start relying on the functionality, which is quite awaited.

[cor3ntin]

Patch for CWG2631 https://reviews.llvm.org/D136554

[cor3ntin]

@ldionne @jyknight Now that the core issue has been implemented in clang, you should be able to land that. (Maybe not today in case people find issues with the changes to clang)

[jyknight]

Rebase, rerun ninja libcxx-generate-files, address last review nits.

[jyknight]

Now that D136554 has re-landed, it seems that we're now actually good to go here (yay!)

PTAL at latest version.

[philnik]

LGTM % nits with green CI assuming you didn't change much about the implementation. I only looked through it quickly. There might be some tooling failing since we've added quite a bit in the last few months. Although I didn't notice while looking through the patch.

libcxx/include/source_location

39

We switched to using this style a few months ago.

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

11–12

We only support these compilers.

[jyknight]

Add missing auto-generated file, fix review nits.

[jyknight]

Fix transitive_includes test errors.

[philnik]

Could you also add the paper to libcxx/docs/ReleaseNotes.rst in the Implemented Papers section?

The CI has some failures, but they all look unrelated. You don't have to run the CI again for the release note.

[ldionne]

This is great, thanks!

[vitalybuka]

This bot is broken https://lab.llvm.org/buildbot/#/builders/37/builds/19454

[jyknight]

In D120634#4046133, @vitalybuka wrote:

This bot is broken https://lab.llvm.org/buildbot/#/builders/37/builds/19454

[ 96%] Generating ScudoUnitTest-i386-Test
/b/sanitizer-x86_64-linux/build/llvm-project/compiler-rt/lib/gwp_asan/tests/recoverable.cpp:31:1: error: unused function 'DeallocateMemory2' [-Werror,-Wunused-function]
DeallocateMemory2(gwp_asan::GuardedPoolAllocator &GPA, void *Ptr) {
^
1 error generated.

That seems unrelated to this change.

[vitalybuka]

In D120634#4047134, @jyknight wrote:

In D120634#4046133, @vitalybuka wrote:

This bot is broken https://lab.llvm.org/buildbot/#/builders/37/builds/19454

[ 96%] Generating ScudoUnitTest-i386-Test
/b/sanitizer-x86_64-linux/build/llvm-project/compiler-rt/lib/gwp_asan/tests/recoverable.cpp:31:1: error: unused function 'DeallocateMemory2' [-Werror,-Wunused-function]
DeallocateMemory2(gwp_asan::GuardedPoolAllocator &GPA, void *Ptr) {
^
1 error generated.

That seems unrelated to this change.

Thanks, in must be the second patch on the blame list, D140173
Sorry for the noise.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_remove_cvref``                        ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_semaphore``                           ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_shift``                               ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_smart_ptr_for_overwrite``             *unimplemented*
     ------------------------------------------------- -----------------
-    ``__cpp_lib_source_location``                     *unimplemented*
+    ``__cpp_lib_source_location``                     ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_span``                                ``202002L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ssize``                               ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_starts_ends_with``                    ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_view``                         ``201803L``

libcxx/docs/Status/Cxx20Issues.csv

 "`3384 <https://wg21.link/LWG3384>`__","``transform_view::*sentinel*``\  has an incorrect ``operator-``\ ","Prague","","","|ranges|"
 "`3385 <https://wg21.link/LWG3385>`__","``common_iterator``\  is not sufficiently constrained for non-copyable iterators","Prague","","","|ranges|"
 "`3387 <https://wg21.link/LWG3387>`__","|sect|\ [range.reverse.view] ``reverse_view<V>``\  unintentionally requires ``range<const V>``\ ","Prague","","","|ranges|"
 "`3388 <https://wg21.link/LWG3388>`__","``view``\  iterator types have ill-formed ``<=>``\  operators","Prague","","","|ranges|"
 "`3389 <https://wg21.link/LWG3389>`__","A move-only iterator still does not have a ``counted_iterator``\ ","Prague","","","|ranges|"
 "`3390 <https://wg21.link/LWG3390>`__","``make_move_iterator()``\  cannot be used to construct a ``move_iterator``\  for a move-only iterator","Prague","|Complete|","14.0","|ranges|"
 "`3393 <https://wg21.link/LWG3393>`__","Missing/incorrect feature test macro for coroutines","Prague","|Complete|","14.0"
 "`3395 <https://wg21.link/LWG3395>`__","Definition for three-way comparison needs to be updated (US 152)","Prague","","","|spaceship|"
-"`3396 <https://wg21.link/LWG3396>`__","Clarify point of reference for ``source_location::current()``\  (DE 169)","Prague","",""
+"`3396 <https://wg21.link/LWG3396>`__","Clarify point of reference for ``source_location::current()``\  (DE 169)","Prague","|Nothing To Do|","15.0"
 "`3397 <https://wg21.link/LWG3397>`__","``ranges::basic_istream_view::iterator``\  should not provide ``iterator_category``\ ","Prague","","","|ranges|"
 "`3398 <https://wg21.link/LWG3398>`__","``tuple_element_t``\  is also wrong for ``const subrange``\ ","Prague","|Complete|","14.0","|ranges|"
 "`3446 <https://wg21.link/LWG3446>`__","``indirectly_readable_traits``\ ambiguity for types with both ``value_type``\ and ``element_type``\ ","November virtual meeting","|Complete|","13.0"

libcxx/docs/Status/Cxx20Papers.csv

 "`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
 "`P0784R7 <https://wg21.link/P0784R7>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
 "`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","",""
 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","",""
 "`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","",""
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135R6 <https://wg21.link/P1135R6>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207R4 <https://wg21.link/P1207R4>`__","LWG","Movability of Single-pass Iterators","Cologne","",""
-"`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","",""
+"`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","|Complete|","15.0"
 "`P1355R2 <https://wg21.link/P1355R2>`__","LWG","Exposing a narrow contract for ceil2","Cologne","|Complete|","9.0"
 "`P1361R2 <https://wg21.link/P1361R2>`__","LWG","Integration of chrono with text formatting","Cologne","",""
 "`P1423R3 <https://wg21.link/P1423R3>`__","LWG","char8_t backward compatibility remediation","Cologne","|In Progress|",""
 "`P1424R1 <https://wg21.link/P1424R1>`__","LWG","'constexpr' feature macro concerns","Cologne","Superseded by `P1902 <https://wg21.link/P1902>`__",""
 "`P1466R3 <https://wg21.link/P1466R3>`__","LWG","Miscellaneous minor fixes for chrono","Cologne","",""
 "`P1474R1 <https://wg21.link/P1474R1>`__","LWG","Helpful pointers for ContiguousIterator","Cologne","",""
 "`P1502R1 <https://wg21.link/P1502R1>`__","LWG","Standard library header units for C++20","Cologne","",""
 "`P1522R1 <https://wg21.link/P1522R1>`__","LWG","Iterator Difference Type and Integer Overflow","Cologne","",""

libcxx/include/CMakeLists.txt

set(files
   ranges
   ratio
   regex
   scoped_allocator
   semaphore
   set
   setjmp.h
   shared_mutex
+  source_location
   span
   sstream
   stack
   stdbool.h
   stddef.h
   stdexcept
   stdint.h
   stdio.h

libcxx/include/module.modulemap

module set {
     header "set"
     export initializer_list
     export *
   }
   module shared_mutex {
     header "shared_mutex"
     export version
   }
+  module source_location {
+    header "source_location"
+    export *
+  }
   module span {
     header "span"
     export ranges.__ranges.enable_borrowed_range
     export version
   }
   module sstream {
     header "sstream"
     // FIXME: should re-export istream, ostream, ios, streambuf, string?

libcxx/include/source_location

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SOURCE_LOCATION
+#define _LIBCPP_SOURCE_LOCATION
+
+/* source_location synopsis
+
+namespace std {
+  struct source_location {
+    static consteval source_location current() noexcept;
+    constexpr source_location() noexcept;
+
+    constexpr uint_least32_t line() const noexcept;
+    constexpr uint_least32_t column() const noexcept;
+    constexpr const char* file_name() const noexcept;
+    constexpr const char* function_name() const noexcept;
+  };
+}
+*/
+
+#include <__config>
+#include <cstdint>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && __has_builtin(__builtin_source_location)
+
+class source_location {
+  // The names source_location::__impl, _M_file_name, _M_function_name, _M_line, and _M_column
+  // are hard-coded in the compiler and must not be changed here.
+  struct __impl {
+    const char* _M_file_name;
+    const char* _M_function_name;
+    unsigned _M_line;
+    unsigned _M_column;
+  };
+  const __impl* __ptr_ = nullptr;
+  // GCC returns the type 'const void*' from the builtin, while clang returns
+  // `const __impl*`. Per C++ [expr.const], casts from void* are not permitted
+  // in constant evaluation, so we don't want to use `void*` as the argument
+  // type unless the builtin returned that, anyhow, and the invalid cast is
+  // unavoidable.
+  using __bsl_ty = decltype(__builtin_source_location());
+
+public:
+  // The defaulted __ptr argument is necessary so that the builtin is evaluated
+  // in the context of the caller. An explicit value should never be provided.
+  static consteval source_location current(__bsl_ty __ptr = __builtin_source_location()) noexcept {
+    source_location __sl;
+    __sl.__ptr_ = static_cast<const __impl*>(__ptr);
+    return __sl;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr source_location() noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr uint_least32_t line() const noexcept { return __ptr_ ? __ptr_->_M_line : 0; }
+  _LIBCPP_HIDE_FROM_ABI constexpr uint_least32_t column() const noexcept { return __ptr_ ? __ptr_->_M_column : 0; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const char* file_name() const noexcept { return __ptr_ ? __ptr_->_M_file_name : ""; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const char* function_name() const noexcept {
+    return __ptr_ ? __ptr_->_M_function_name : "";
+  }
+};
+
+#endif // _LIBCPP_STD_VER > 17 && __has_builtin(__builtin_source_location)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SOURCE_LOCATION

libcxx/include/version

 // # define __cpp_lib_polymorphic_allocator                201902L
 // # define __cpp_lib_ranges                               201811L
 # define __cpp_lib_remove_cvref                         201711L
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)
 #   define __cpp_lib_semaphore                          201907L
 # endif
 # define __cpp_lib_shift                                201806L
 // # define __cpp_lib_smart_ptr_for_overwrite              202002L
-// # define __cpp_lib_source_location                      201907L
+# if __has_builtin(__builtin_source_location)
+#   define __cpp_lib_source_location                    201907L
+# endif
 # define __cpp_lib_span                                 202002L
 # define __cpp_lib_ssize                                201902L
 # define __cpp_lib_starts_ends_with                     201711L
 # undef  __cpp_lib_string_view
 # define __cpp_lib_string_view                          201803L
 // # define __cpp_lib_syncbuf                              201803L
 // # define __cpp_lib_three_way_comparison                 201907L
 # define __cpp_lib_to_address                           201711L
 # define __cpp_lib_to_array                             201907L

libcxx/test/libcxx/clang_tidy.sh.cpp

 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <semaphore>
 #endif
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <shared_mutex>
 #endif
+#include <source_location>
 #include <span>
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #    include <sstream>
 #endif
 #include <stack>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>

libcxx/test/libcxx/double_include.sh.cpp

 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <semaphore>
 #endif
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <shared_mutex>
 #endif
+#include <source_location>
 #include <span>
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #    include <sstream>
 #endif
 #include <stack>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 #include <set>
 TEST_MACROS();
 #include <setjmp.h>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <shared_mutex>
 TEST_MACROS();
 #endif
+#include <source_location>
+TEST_MACROS();
 #include <span>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #    include <sstream>
 TEST_MACROS();
 #endif
 #include <stack>
 TEST_MACROS();

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <semaphore>
 #endif
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <shared_mutex>
 #endif
+#include <source_location>
 #include <span>
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #    include <sstream>
 #endif
 #include <stack>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <semaphore>
 #endif
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #    include <shared_mutex>
 #endif
+#include <source_location>
 #include <span>
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #    include <sstream>
 #endif
 #include <stack>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>

libcxx/test/std/language.support/support.limits/support.limits.general/source_location.version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+//
+// clang-format off
+
+// <source_location>
+
+// Test the feature test macros defined by <source_location>
+
+/*  Constant                     Value
+    __cpp_lib_source_location    201907L [C++20]
+*/
+
+#include <source_location>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_source_location
+#   error "__cpp_lib_source_location should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_source_location
+#   error "__cpp_lib_source_location should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_source_location
+#   error "__cpp_lib_source_location should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 20
+
+# if __has_builtin(__builtin_source_location)
+#   ifndef __cpp_lib_source_location
+#     error "__cpp_lib_source_location should be defined in c++20"
+#   endif
+#   if __cpp_lib_source_location != 201907L
+#     error "__cpp_lib_source_location should have the value 201907L in c++20"
+#   endif
+# else
+#   ifdef __cpp_lib_source_location
+#     error "__cpp_lib_source_location should not be defined when __has_builtin(__builtin_source_location) is not defined!"
+#   endif
+# endif
+
+#elif TEST_STD_VER > 20
+
+# if __has_builtin(__builtin_source_location)
+#   ifndef __cpp_lib_source_location
+#     error "__cpp_lib_source_location should be defined in c++2b"
+#   endif
+#   if __cpp_lib_source_location != 201907L
+#     error "__cpp_lib_source_location should have the value 201907L in c++2b"
+#   endif
+# else
+#   ifdef __cpp_lib_source_location
+#     error "__cpp_lib_source_location should not be defined when __has_builtin(__builtin_source_location) is not defined!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 20
+
+int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 #     error "__cpp_lib_smart_ptr_for_overwrite should have the value 202002L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_smart_ptr_for_overwrite
 #     error "__cpp_lib_smart_ptr_for_overwrite should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if __has_builtin(__builtin_source_location)
 #   ifndef __cpp_lib_source_location
 #     error "__cpp_lib_source_location should be defined in c++20"
 #   endif
 #   if __cpp_lib_source_location != 201907L
 #     error "__cpp_lib_source_location should have the value 201907L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_source_location
-#     error "__cpp_lib_source_location should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_source_location should not be defined when __has_builtin(__builtin_source_location) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_span
 #   error "__cpp_lib_span should be defined in c++20"
 # endif
 # if __cpp_lib_span != 202002L
 #   error "__cpp_lib_span should have the value 202002L in c++20"

 #     error "__cpp_lib_smart_ptr_for_overwrite should have the value 202002L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_smart_ptr_for_overwrite
 #     error "__cpp_lib_smart_ptr_for_overwrite should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if __has_builtin(__builtin_source_location)
 #   ifndef __cpp_lib_source_location
 #     error "__cpp_lib_source_location should be defined in c++2b"
 #   endif
 #   if __cpp_lib_source_location != 201907L
 #     error "__cpp_lib_source_location should have the value 201907L in c++2b"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_source_location
-#     error "__cpp_lib_source_location should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_source_location should not be defined when __has_builtin(__builtin_source_location) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_span
 #   error "__cpp_lib_span should be defined in c++2b"
 # endif
 # if __cpp_lib_span != 202002L
 #   error "__cpp_lib_span should have the value 202002L in c++2b"

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-12, clang-13, clang-14
+// UNSUPPORTED: apple-clang-12, apple-clang-13, apple-clang-14
+
+#include <source_location>
+
+#include <cassert>
+#include <concepts>
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_move_constructible_v<std::source_location>, "support.srcloc.cons (1.1)");
+static_assert(std::is_nothrow_move_assignable_v<std::source_location>, "support.srcloc.cons (1.2)");
+static_assert(std::is_nothrow_swappable_v<std::source_location>, "support.srcloc.cons (1.3)");
+
+ASSERT_NOEXCEPT(std::source_location());
+ASSERT_NOEXCEPT(std::source_location::current());
+
+// Note: the standard doesn't strictly require the particular values asserted
+// here, but does "suggest" them.  Additional tests for details of how the
+// implementation of current() chooses which location to report for more complex
+// scenarios are in the Clang test-suite, and not replicated here.
+
+// A default-constructed value.
+constexpr std::source_location empty;
+static_assert(empty.line() == 0);
+static_assert(empty.column() == 0);
+static_assert(empty.file_name()[0] == '\0');
+static_assert(empty.function_name()[0] == '\0');
+
+ASSERT_NOEXCEPT(empty.line());
+ASSERT_NOEXCEPT(empty.column());
+ASSERT_NOEXCEPT(empty.file_name());
+ASSERT_NOEXCEPT(empty.function_name());
+std::same_as<uint_least32_t> auto line = empty.line();
+std::same_as<uint_least32_t> auto column = empty.column();
+std::same_as<const char*> auto file = empty.file_name();
+std::same_as<const char*> auto function = empty.function_name();
+
+// A simple use of current() outside a function.
+constexpr std::source_location cur =
+#line 1000 "ss"
+    std::source_location::current();
+static_assert(cur.line() == 1000);
+static_assert(cur.column() > 0);
+static_assert(cur.file_name()[0] == 's' && cur.file_name()[1] == 's' && cur.file_name()[2] == '\0');
+static_assert(cur.function_name()[0] == '\0');
+
+// and inside a function.
+int main(int, char**) {
+  auto local =
+#line 2000
+      std::source_location::current();
+  assert(!strcmp(local.file_name(), "ss"));
+  assert(strstr(local.function_name(), "main"));
+  assert(local.line() == 2000);
+  assert(local.column() > 0);
+
+  // Finally, the type should be copy-constructible
+  auto local2 = cur;
+  assert(!strcmp(local2.file_name(), cur.file_name()));
+  assert(!strcmp(local2.function_name(), cur.function_name()));
+  assert(local2.line() == cur.line());
+  assert(local2.column() == cur.column());
+
+  // and copy-assignable.
+  local = cur;
+  assert(!strcmp(local.file_name(), cur.file_name()));
+  assert(!strcmp(local.function_name(), cur.function_name()));
+  assert(local.line() == cur.line());
+  assert(local.column() == cur.column());
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_shift",
     "values": { "c++20": 201806 },
     "headers": ["algorithm"],
   }, {
     "name": "__cpp_lib_smart_ptr_for_overwrite",
     "values": { "c++20": 202002 },
     "headers": ["memory"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_source_location",
     "values": { "c++20": 201907 },
     "headers": ["source_location"],
-    "unimplemented": True,
+    "test_suite_guard": "__has_builtin(__builtin_source_location)",
+    "libcxx_guard": "__has_builtin(__builtin_source_location)",
   }, {
     "name": "__cpp_lib_span",
     "values": { "c++20": 202002 },
     "headers": ["span"],
   }, {
     "name": "__cpp_lib_spanstream",
     "values": { "c++2b": 202106 },
     "headers": ["spanstream"],
     "unimplemented": True,