Support arrays in make_shared and allocate_shared (P0674R1)

[ldionne]

Summary

This patch implements P0674R1. It might be a bit rough around the edges, but I wanted to get it out so it can be reviewed and I can make changes to it as I straighten out the last few parts.

The main changes are how __shared_ptr_pointer deallocates itself and (obviously) the added overloads.

• Relevant section of the standard.
• Paper.
• Based on D62259.

Thanks for the help @mclow.lists and @EricWF

[ldionne]

Thanks a lot for the patch. I've left a lot of comments with suggestions. Feel free to take or leave my suggestions: it's mostly that I had myself started some work on this, so I felt like I should at least put it somewhere instead of just trashing it. Keep what you want and leave the rest.

libcxx/include/memory

663–686

template<class T, class... Args>
    shared_ptr<T> make_shared(Args&&... args); // T is not array
template<class T, class A, class... Args>
    shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not array

template<class T>
    shared_ptr<T> make_shared(size_t N); // T is U[] (since C++20)
template<class T, class A>
    shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[] (since C++20)

template<class T>
    shared_ptr<T> make_shared(); // T is U[N] (since C++20)
template<class T, class A>
    shared_ptr<T> allocate_shared(const A& a); // T is U[N] (since C++20)

template<class T>
    shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)
template<class T, class A>
    shared_ptr<T> allocate_shared(const A& a, size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)

template<class T> shared_ptr<T>
    make_shared(const remove_extent_t<T>& u); // T is U[N] (since C++20)
template<class T, class A>
    shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u); // T is U[N] (since C++20)

1002–1003

You seem to be missing make_shared for arrays.

I had started working on a similar patch, and this is what I had. Feel free to cherry-pick stuff from it if it's useful:

#if _LIBCPP_STD_VER > 17
template<class _Tp, class _Alloc, class ..._Args>
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> __allocate_shared_unbounded_array_impl(const _Alloc& __a, size_t __n, _Args const& ...__args)
{
    ...
}

template<class _Tp, class _Alloc, class ..._Args>
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> __allocate_shared_bounded_array_impl(const _Alloc& __a, size_t __n, _Args const& ...__args)
{
    ...
}

template<class _Tp, class _Alloc, class = _EnableIf<is_unbounded_array<_Tp>::value> >
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n)
{
    return _VSTD::__allocate_shared_unbounded_array_impl<_Tp>(__a, __n);
}

template<class _Tp, class = _EnableIf<is_unbounded_array<_Tp>::value> >
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> make_shared(size_t __n)
{
    return _VSTD::allocate_shared<_Tp>(allocator<_Tp>(), __n);
}


template<class _Tp, class _Alloc, class = _EnableIf<is_bounded_array<_Tp>::value> >
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> allocate_shared(const _Alloc& __a)
{
    return _VSTD::__allocate_shared_bounded_array_impl<_Tp>(__a);
}

template<class _Tp, class = _EnableIf<is_bounded_array<_Tp>::value> >
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> make_shared()
{
    return _VSTD::allocate_shared<_Tp>(allocator<_Tp>());
}


template<class _Tp, class _Alloc, class = _EnableIf<is_unbounded_array<_Tp>::value> >
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n, const remove_extent_t<_Tp>& __t)
{
    return _VSTD::__allocate_shared_unbounded_array_impl<_Tp>(__a, __n, __t);
}

template<class _Tp, class = _EnableIf<is_unbounded_array<_Tp>::value> >
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> make_shared(size_t __n, const remove_extent_t<_Tp>& __t)
{
    return _VSTD::allocate_shared<_Tp>(allocator<_Tp>(), __n, __t);
}


template<class _Tp, class _Alloc, class = _EnableIf<is_bounded_array<_Tp>::value> >
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __t)
{
    return _VSTD::__allocate_shared_bounded_array_impl<_Tp>(__a, __t);
}

template<class _Tp, class = _EnableIf<is_bounded_array<_Tp>::value> >
_LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> make_shared(const remove_extent_t<_Tp>& __t)
{
    return _VSTD::allocate_shared<_Tp>(allocator<_Tp>(), __t);
}
#endif // > C++17

1006

This would need to use Allocator-destruction. In the patch I had started working on, I had this:

// Given an allocator and a range delimited by [first, last), destroys every
// element in the range [first, last) FROM RIGHT TO LEFT using allocator
// destruction. If elements are themselves C-style arrays, they are recursively
// destroyed in the same manner.
//
// This function assumes that destructors do not throw.
//
// The allocator does not need to already be bound to the element type of the
// range -- it is rebound appropriately by this function.
template<class _Alloc, class _BidirectionalIterator, class ..._Args>
_LIBCPP_HIDE_FROM_ABI
void __allocator_destroy_multidimensional(_Alloc const& __alloc, _BidirectionalIterator __first, _BidirectionalIterator __last) noexcept {
    using _ValueType = typename iterator_traits<_BidirectionalIterator>::value_type;
    using _ValueAlloc = typename __allocator_traits_rebind<_Alloc, _ValueType>::type;

    if (__first == __last) {
        return;
    }
    _ValueAlloc __value_alloc(__alloc);
    auto __destroy = [&](_BidirectionalIterator __it) {
        if constexpr (is_array_v<_ValueType>) {
            __allocator_destroy_multidimensional(__value_alloc, _VSTD::begin(*__it), _VSTD::end(*__it));
        } else {
            allocator_traits<_ValueAlloc>::destroy(__value_alloc, _VSTD::addressof(*__it));
        }
    };
    for (--__last; __last != __first; --__last) {
        __destroy(__last);
    }
    // handle __first, which is skipped by the loop above
    __destroy(*__first);
}

If you like it, feel free to add it to your patch. I had placed it in __memory/utilities.h since it was meant to be a general purpose helper function. Also, it's not really tested :-)

1023

I would call this something like __shared_ptr_unbounded_array_holder or similar, to make it clear that this handles unbounded arrays only (see my suggestion to have two separate control blocks below).

1026–1028

Why not only have a member of type _Info? Or even better, just have

[[no_unique_address]] _Alloc __alloc_;
size_t __size_;
union { // make sure the default constructor doesn't initialize __data_
  _Tp __data_[1]; // flexible array member trick
};

inline in the control block definition?

1030

I think it would be useful to have a separate control block for arrays with a known size. That way, we can keep the knowledge of the bounds static.

1049–1061

Those need to use Allocator construction. I would suggest a more generic algorithm like:

// Given an allocator and a range delimited by [first, first + n), initializes
// the range [first, first + n) from left to right using the allocator's construct.
//
// Each element is initialized using allocator_traits construction, and the given
// arguments are passed to construction. The arguments are not perfect-forwarded
// because that could set us up for double-moves. If the elements of the range
// are themselves C-style arrays, they are recursively constructed in the same
// manner.
//
// If an exception is thrown, the initialized elements are destroyed in reverse
// order of initialization using allocator_traits destruction. This requires that
// the iterator type be a BidirectionalIterator.
//
// The allocator does not need to already be bound to the element type of the
// range -- it is rebound appropriately by this function.
template<class _Alloc, class _BidirectionalIterator, class ..._Args>
_LIBCPP_HIDE_FROM_ABI
void __uninitialized_allocator_construct_multidimensional_n(_Alloc const& __alloc, _BidirectionalIterator __first, size_t __n, _Args&& ...__args) {
    using _ValueType = typename iterator_traits<_BidirectionalIterator>::value_type;
    using _ValueAlloc = typename __allocator_traits_rebind<_Alloc, _ValueType>::type;
    auto __idx = __first;
    _ValueAlloc __value_alloc(__alloc);

#ifndef _LIBCPP_NO_EXCEPTIONS
    try {
#endif
        for (; __n > 0; (void)++__idx, --__n) {
            if constexpr (is_array_v<_ValueType>) {
                size_t __size = _VSTD::distance(_VSTD::begin(*__idx), _VSTD::end(*__idx));
                __uninitialized_allocator_construct_multidimensional_n(__value_alloc, _VSTD::begin(*__idx), __size, __args...);
            } else {
                allocator_traits<_ValueAlloc>::construct(__value_alloc, _VSTD::addressof(*__idx), __args...);
            }
        }
#ifndef _LIBCPP_NO_EXCEPTIONS
    } catch (...) {
        _VSTD::__allocator_destroy_multidimensional(__first, __idx);
        throw;
    }
#endif
}

1067

You need to destroy the elements in reverse order of construction. If you use the algorithm I suggested above, it should suffice to say:

_VSTD:: __allocator_destroy_multidimensional(__get_elem_begin(), __get_elem_end());

or something along those lines.

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

9 ↗

(On Diff #313766)

I would like to see more tests for:

1. Multidimensional construction and destruction, and
2. Making sure that we construct and destroy elements in the correct order (both in normal circumstances but also when an exception is thrown while we're initializing the array).

I know this is complicated to test, but I think it is important. It may make sense to split tests into multiple files to make it easier to understand. Your call.

libcxx/utils/generate_feature_test_macro_components.py

294–295

We need to add "c++20": 201707 and leave the c++17 entry as-is.

[zoecarver]

Thanks for those suggestions, Louis! Going to add some more tests over the next few days.

libcxx/include/memory

1002–1003

You seem to be missing make_shared for arrays.

Aha! I actually took this from your earlier patch: make_shared can be implemented in terms of allocate_shared, so it can just be one function template with no constraints that calls out to all the various allocate_shared overloads.

I think the way I have this now composes really nicely, so unless you see a reason to use something else, I'm going to keep this.

1006

Good point. Added these two functions as members with a few tweaks.

I had placed it in __memory/utilities.h since it was meant to be a general purpose helper function.

I can't think of another place we'd want to use these functions, so I'm going to keep them as more specific member functions. It might make sense to break all the shared_ptr stuff out into its own header at some point, though.

1030

I considered this, but I don't think it will actually give us any performance benefits, because we have to dynamically allocate it using the provided allocator either way.

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

9 ↗

(On Diff #313766)

Improved this a little, but I'm going to upload more tests shortly.

[zoecarver]

Fix based on review.

[zoecarver]

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

47 ↗

(On Diff #315705)

This should help make sure we destroy things in the correct order.

[zoecarver]

• Add more multidimensional throwing tests.

[ldionne]

libcxx/include/memory

1002–1003

Aha! I actually took this from your earlier patch: make_shared can be implemented in terms of allocate_shared, so it can just be one function template with no constraints that calls out to all the various allocate_shared overloads.

I don't think that works, actually. For example, std::make_shared<int[3]>(1, 2, 3) should SFINAE away, but with your implementation that would be a hard error. Can you add a test and see whether that's correct? If so, it means we need to conform to the declarations laid out in the standard (there's often reasons why the standard lists overloads explicitly).

1006

Well, one place where we might want to use it is in the statically-sized array version of the block (see below why I think we should have one).

1010

I don't understand the benefit of passing false_type here when we want to default construct, instead of just relying on variadics and always passing down some args... to __construct_elements (and hence to the object's constructors themselves). I think it would be simpler to do that.

Also, I think it makes sense to mark this constructor as explicit, and it needs to be marked with _LIBCPP_HIDE_FROM_ABI.

1030

We save on storing the size itself in the control block, and the size is known statically, which could lead to different code being generated (e.g for small arrays). I think it's fairly important to do it, since it isn't very costly for us.

The representation for statically-sized arrays can be:

[[no_unique_address]] _Alloc __alloc_;
union { // make sure the default constructor doesn't initialize __data_
    _Tp __data_[_Np];
};

1030

I see you're using an int here, but what if construction fails at a very large index, the size_t to int narrowing could be problematic. Is there a reason why you're using int?

1073–1078

The way I understand this is that we should actually always call __destroy_elements(__first, __i + 1); to destroy the half-open range [__first, __first + __i + 1) (which includes the last object that was fully constructed, but not the object that was partially constructed). However, when the current element (__first + __i) is an array, it has already been destroyed before we caught the exception, so we can skip it and just destroy [__first, __first + __i).

This implementation makes that intent clearest IMO:

// <explanation>
if constexpr (is_array_v<_ValueType>)
    __destroy_elements(__first, __i);
else
    __destroy_elements(__first, __i + 1);

Do you agree?

1095

We generally use a trailing underscore (like __alloc_) to make it clear it's a member.

[zoecarver]

libcxx/include/memory

1030

I'm using int because __n will become -1 in the for loop. I could keep it unsigned and just compare __n < "size", but that seems a bit more confusing and would require a second variable. So, I'll make __n a long.

[zoecarver]

• Add static size control block.
• Fix based on review.

[zoecarver]

• Format

[zoecarver]

libcxx/include/memory

1114

Actually, because we're inheriting this base class, the [[no_unique_address]] isn't needed.

[zoecarver]

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

9 ↗

(On Diff #313766)

Oops, forgot the SFINAE test. I'll add that now.

[zoecarver]

• Add SFINAE tests.
• Remove "no_unique_address".

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

9 ↗

(On Diff #313766)

I know this is complicated to test, but I think it is important. It may make sense to split tests into multiple files to make it easier to understand. Your call.

I personally don't mind the mono-test and it makes things easier to find, IMHO. But I also don't have a strong oppinion at all, would you rather me split this test up?

[zoecarver]

@ldionne this is ready for re-review when you're ready to re-review it :)

[zoecarver]

@ldionne friendly ping.

[ldionne]

I don't think we gain much from having a single __shared_ptr_array_base common base. Actually, this forces us to have additional virtual methods in both subclasses. Instead, we should just have two different holder classes, one for statically-sized arrays, and one for dynamic arrays.

libcxx/docs/Cxx2aStatusPaperStatus.csv

3 ↗

(On Diff #317693)

This should be 13.0 now

[zoecarver]

• Bump LLVM release version.
• Remove __shared_ptr_array_base.

[ldionne]

Thanks a lot for all your work on this patch. This is a tough one to get right. I know I'm requesting a lot, but I think it's important to get it right and we'll be even happier when we finally ship this :-).

libcxx/include/memory

1013

I *think* this can cause us to under allocate, for example if there needs to be padding between __count_ and __data_:

[[no_unique_address]] _Alloc __alloc_;
size_t __count_;
// padding possible here - would that be counted in sizeof(_ControlBlock)?
_DataBlock __data_[0];

This concern is moot if I'm right about _DataBlock __data_[0] being an extension and if we change to _DataBlock __data_[1] instead.

1050

We could also use __first[i] here, I think it's clearer?

1072

I haven't looked for that specifically, but can you confirm that you are testing these two code paths?

1079

Can we name them xx_bounded and xx_unbounded instead? It seems to fit better?

1084–1087

Currently, this function is only used in a single place (which is inside the implementation of this class). Furthermore, we duplicate that logic when we compute the size to allocate down there in make_shared_xx.

One possibility would be to move this to a free function like

template <class T>
size_t __get_shared_ptr_unbounded_block_size(size_t __n) {
    // ...
}

Then we could reuse it from both places. Do you agree that would be an improvement?

1107

Don't we need to run the destructor of __alloc_ here?

1113

Is this legal C++? I thought that was a compiler extension and arrays had to have at least one element?

1123

Since this is only used in a single place in the body of __shared_ptr_array_bound, I think we could just inline the function at its single point of use and remove it. WDYT?

1142

Same comment regarding destruction of __alloc_.

[zoecarver]

libcxx/include/memory

1013

Moot because I fixed __data_[0 -> 1].

However, I thought this was the whole point of using a zero size array at the end of a struct? Otherwise, why not just make an empty struct. So, yes, that padding would be accounted for:

struct UnsizedTail {
  int size;
  alignas(8) char buf[0];
};

// UnsizedTail = {i32, [4 x i8 padding], [0 x i8]
static_assert(sizeof(UnsizedTail) == 8);

That being said... when would there be padding between size_t and an aligned storage member?

1040

Why not pass by value?

1072

Yes, these two code paths are tested. See L324 where we use struct D to throw.

1107

Yep. Added a regression test, too.

1113

Yes, you're right. Fixed. (Supprising that we didn't get a warning, though?)

1123

Agreed. Same with __get_count.

[zoecarver]

libcxx/include/memory

1040

Whoops. I thought I deleted this comment. This was just a note to myself.

Anyway, I am actually wondering about this. I see _Alloc const& all over the place, but allocators are generally supposed to be small (often empty) types, so why not pass them by value? We're copy constructing the allocator in this function, so it can't be to prevent that.

[zoecarver]

• Address review comments and add a few more tests.
• Format test file with clang-format.

[ldionne]

This basically LGTM except for the few nitpicks below. We already talked about most of that offline, just adding here so you have a written trace.

libcxx/include/memory

1007

We need to handle the case where __n == 0. Also, we should add a test for it since I'm not seeing anything that says it's not allowed by the API.

1040

Generally, we take by value (and then move into some internal storage) when we take ownership of an object -- or we add a version that takes that object by rvalue reference. You could do that here and move into __value_alloc if you wanted.

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

47 ↗

(On Diff #315705)

Can you add a comment mentioning that? It's clever.

1 ↗

(On Diff #323831)

Can we add a test with overaligned types? (like we discussed offline)

9 ↗

(On Diff #323831)

You can remove c++98 from the Lit features, we don't use it anymore.

[zoecarver]

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

47 ↗

(On Diff #315705)

Done. Thanks :)

[zoecarver]

• Address review comments.
• Re-generate feature test macros after rebase.
• Format changes with git-clang-format.

[zoecarver]

• Poke buildkit.

[zoecarver]

OK, that seems to have worked. @ldionne for future reference: the CI was failing to apply this patch because I had two parent revisions and a child revision which were abandoned/already landed. I think the abandoned one was causing problems because it had conflicts. Removing those patches fixed the issue, but it would be nice to automatically skip abandoned parent patches.

[zoecarver]

• Fix for -fno-exceptions.

[zoecarver]

• Destroy alloc before deallocating this.
• Cast char to size_t in assert.

[zoecarver]

• Fix UBSAN and GCC build bots.

[zoecarver]

• Fix ASAN bots.
• Format test files.

[zoecarver]

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

10 ↗

(On Diff #327002)

I really don't like disabling this whole test for sanitizer-new-delete. We need this because of the globalMemCounter tests. This is the same thing the unique_ptr tests use.

@ldionne do you know if there's a macro or some other way we can detect if we're running on sanitizer-new-delete? If so, we could just disable the two tests that actually cause this to fail.

[ldionne]

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/create_array.pass.cpp

10 ↗

(On Diff #327002)

I don't think there's such a macro. You could split it off into its own test file if you wanted.

[zoecarver]

• Fix UBSAN bot.
• Fix macOS bot.

[ldionne]

Commandeering to finish this up.

[mumbleskates]

What's the status of this one? Looks stalled, and I understand it's still a blocker for make_{unique,shared}_for_overwrite in D90111

[ldionne]

In D62641#3268485, @mumbleskates wrote:

What's the status of this one? Looks stalled, and I understand it's still a blocker for make_{unique,shared}_for_overwrite in D90111

This is rather complicated, but it's basically blocked on D114903.

[ldionne]

Finish this. It turns out this is implementable without the construct_at extension for arrays.

[• Quuxplusone]

libcxx/include/__memory/shared_ptr.h

976–981

IMO it would be cleaner to eliminate the partial specialization and just write

template <class _Array, class _Alloc>
struct __unbounded_array_control_block : __shared_weak_count
{
    using _Tp = remove_extent_t<_Array>;

Ditto for __bounded_array_control_block below. But admittedly I'd expect this to be marginally more expensive in terms of compile time.

989

__data_ is an array.

1008–1009

The condition could be __elements == 0 ? ~~~; the only singularity requiring a special case is at zero. It looks to me as if make_shared<int[]>(0) is intended to be UB: https://eel.is/c++draft/util.smartptr.shared#create-13 — but maybe we want to support it anyway for QoI, or maybe I'm misunderstanding the possibility of returning a pointer to an object of type U[0].

1069

This isn't ADL-proof — add a regression test!
And then this can just be return __data_; because __data_ is an array, and then this function doesn't need to exist.
Ditto lines 1072, 1077, maybe elsewhere.

1081–1082

This should be =default...

1085

...and this should be override (not virtual), IIUC.
(Ditto throughout.)

libcxx/include/__memory/uninitialized_algorithms.h

360–362

Why does this need to work with non-pointers at all? I'm 99% positive it should take _Tp* instead of an arbitrary _BidirIter. Likewise throughout — there are a lot of these unnecessarily bidirectional-iterator helpers.
Likewise line 363: using _ValueType = _Tp and then there's no more need for _ValueType to exist.

[Mordante]

I'm not to familiar with this part of the Standard so didn't do an in-depth review. But I didn't see any oddities.

libcxx/include/__memory/shared_ptr.h

983

Let's guard against ADL-hijacking. (The required header is already included.)

[ldionne]

Address some comments. Updating to poke CI, I'll address remaining comments when I get another minute of free time.

[ldionne]

libcxx/include/__memory/shared_ptr.h

976–981

I like the fact that we can confirm by inspection that the class is being instantiated on _Tp[] and not _Tp[N]. If I made it the base template, I would probably want to add a static_assert, but then I might as well use the status quo, which is simpler. I'm inclined not to change anything.

989

I know, but given that we're working with multidimensional arrays, it can become extremely confusing and I think the std::begin adds clarity, so I'm tempted to keep it.

1069

I don't think this specific one is an ADL issue, because we're taking the address of the array, not the address of the first element (see https://godbolt.org/z/KMjezb6qE). But I'll still simplify this and stop taking the address, which is indeed not necessary. It *is* an issue in places below where we do &__data_[0] and I fixed it there and added tests.

I can't get rid of the method entirely without making __data_ public, which I'd rather not do, so I'll keep it around.

1081–1082

It turns out this doesn't work because __data_ is sometimes non-trivial, and a non-trivial member in a union results in a the destructor being deleted (which makes sense, because you might need to check which of the non-trivial members of the union needs to be deleted). I added a comment.

[ldionne]

Address review comments and fix modular CI. I'll ship this once CI passes.

libcxx/include/__memory/shared_ptr.h

1008–1009

I actually didn't find anything explicitly prohibiting make_shared<T[]>(0). Furthermore, I had never really thought about it, but based on https://stackoverflow.com/a/1087066/627587 it seems like dynamically-sized arrays of size 0 are definitely a thing and they are supported. Arrays with a static size 0 are not, though.

So yeah, I think make_shared<int[]>(0) & friends definitely need to work, and it must allocate an array with no members. I realized after reading this that I did have tests for this case already. I will add tests to ensure that we reject arrays with a static size of 0.

I reworded the comment and changed the condition to __elements == 0.

libcxx/include/__memory/uninitialized_algorithms.h

360–362

I don't see the benefit in removing abstraction when the cost of doing it is close to nothing. During development of the algorithm, abstracting to arbitrary iterators was incredibly useful, because at some point I was really confused -- these algorithms handle arrays specially, and arrays decay into pointers. Drawing a clear distinction between the iterator and the value type (which is sometimes an array) was very useful, and in fact there were some subtle bugs in the implementation before I decided to write it this way. So I'm pretty attached to the specific way those are written.

[ldionne]

libcxx/include/__memory/shared_ptr.h

1008–1009

Oh yeah, also I did check with other implementations: https://godbolt.org/z/z8nacGhx1

[ldionne]

Investigate CI failure on GCC.

[ldionne]

Fix CI issues.

[ldionne]

Poke CI.

[ldionne]

Try to fix macOS CI.

[ldionne]

Rebase on top of the is_array fix.

[ldionne]

Try to fix CI issues on AIX and GCC.

[ldionne]

Try to fix CI again

[ldionne]

Finally! Shipping this now.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_polymorphic_allocator``               *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges``                              *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_remove_cvref``                        ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_semaphore``                           ``201907L``
     ------------------------------------------------- -----------------
+    ``__cpp_lib_shared_ptr_arrays``                   ``201707L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_shift``                               ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_smart_ptr_for_overwrite``             *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_source_location``                     *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_span``                                ``202002L``
     ------------------------------------------------- -----------------

libcxx/docs/ReleaseNotes.rst

 
 New Features
 ------------
 
 - Implemented P0627R6 (Function to mark unreachable code)
 
 - Implemented P1165R1 (Make stateful allocator propagation more consistent for ``operator+(basic_string)``)
 
+- Implemented P0674R1 (Support arrays in make_shared and allocate_shared)
+
 - `pop_heap` now uses an algorithm known as "bottom-up heapsort" or
   "heapsort with bounce" to reduce the number of comparisons, and rearranges
   elements using move-assignment instead of `swap`.
 
  - Libc++ now supports a variety of assertions that can be turned on to help catch
    undefined behavior in user code. This new support is now separate from the old
    (and incomplete) Debug Mode. Vendors can select whether the library they ship
    should include assertions or not by default. For details, see

libcxx/docs/Status/Cxx20Papers.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version"
 "`P0463R1 <https://wg21.link/P0463R1>`__","LWG","Endian just Endian","Toronto","|Complete|","7.0"
-"`P0674R1 <https://wg21.link/P0674R1>`__","LWG","Extending make_shared to Support Arrays","Toronto","",""
+"`P0674R1 <https://wg21.link/P0674R1>`__","LWG","Extending make_shared to Support Arrays","Toronto","|Complete|","15.0"
 "","","","","",""
 "`P0020R6 <https://wg21.link/P0020R6>`__","LWG","Floating Point Atomic","Albuquerque","",""
 "`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","",""
 "`P0202R3 <https://wg21.link/P0202R3>`__","LWG","Add constexpr modifiers to functions in <algorithm> and <utility> Headers","Albuquerque","|Complete|","12.0"
 "`P0415R1 <https://wg21.link/P0415R1>`__","LWG","Constexpr for ``std::complex``\ ","Albuquerque","|In Progress|","7.0"
 "`P0439R0 <https://wg21.link/P0439R0>`__","LWG","Make ``std::memory_order``\  a scoped enumeration","Albuquerque","|Complete|",""
 "`P0457R2 <https://wg21.link/P0457R2>`__","LWG","String Prefix and Suffix Checking","Albuquerque","|Complete|","6.0"
 "`P0550R2 <https://wg21.link/P0550R2>`__","LWG","Transformation Trait ``remove_cvref``\ ","Albuquerque","|Complete|","6.0"

libcxx/include/__memory/shared_ptr.h

 #ifndef _LIBCPP___MEMORY_SHARED_PTR_H
 #define _LIBCPP___MEMORY_SHARED_PTR_H
 
 #include <__availability>
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/operations.h>
 #include <__functional/reference_wrapper.h>
+#include <__iterator/access.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
+#include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
 #include <stdexcept>

 
 template<class _Tp, class ..._Args, class = __enable_if_t<!is_array<_Tp>::value> >
 _LIBCPP_HIDE_FROM_ABI
 shared_ptr<_Tp> make_shared(_Args&& ...__args)
 {
     return _VSTD::allocate_shared<_Tp>(allocator<_Tp>(), _VSTD::forward<_Args>(__args)...);
 }
 
+#if _LIBCPP_STD_VER > 17
+
+template <size_t _Alignment>
+struct __sp_aligned_storage {
+    alignas(_Alignment) char __storage[_Alignment];
+};
+
+template <class _Tp, class _Alloc>
+struct __unbounded_array_control_block;
+
+template <class _Tp, class _Alloc>
+struct __unbounded_array_control_block<_Tp[], _Alloc> : __shared_weak_count
+{
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    _Tp* __get_data() noexcept { return __data_; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count, _Tp const& __arg)
+        : __alloc_(__alloc), __count_(__count)
+    {
+        std::__uninitialized_allocator_fill_n(__alloc_, std::begin(__data_), __count_, __arg);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count)
+        : __alloc_(__alloc), __count_(__count)
+    {
+        std::__uninitialized_allocator_value_construct_n(__alloc_, std::begin(__data_), __count_);
+    }
+
+    // Returns the number of bytes required to store a control block followed by the given number
+    // of elements of _Tp, with the whole storage being aligned to a multiple of _Tp's alignment.
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr size_t __bytes_for(size_t __elements) {
+        // When there's 0 elements, the control block alone is enough since it holds one element.
+        // Otherwise, we allocate one fewer element than requested because the control block already
+        // holds one. Also, we use the bitwise formula below to ensure that we allocate enough bytes
+        // for the whole allocation to be a multiple of _Tp's alignment. That formula is taken from [1].
+        //
+        // [1]: https://en.wikipedia.org/wiki/Data_structure_alignment#Computing_padding
+        size_t __bytes = __elements == 0 ? sizeof(__unbounded_array_control_block)
+                                         : (__elements - 1) * sizeof(_Tp) + sizeof(__unbounded_array_control_block);
+        constexpr size_t __align = alignof(_Tp);
+        return (__bytes + __align - 1) & ~(__align - 1);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    ~__unbounded_array_control_block() override { } // can't be `= default` because of the sometimes-non-trivial union member __data_
+
+private:
+    void __on_zero_shared() _NOEXCEPT override {
+        __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
+        std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + __count_);
+    }
+
+    void __on_zero_shared_weak() _NOEXCEPT override {
+        using _AlignedStorage = __sp_aligned_storage<alignof(__unbounded_array_control_block)>;
+        using _StorageAlloc = __allocator_traits_rebind_t<_Alloc, _AlignedStorage>;
+        using _PointerTraits = pointer_traits<typename allocator_traits<_StorageAlloc>::pointer>;
+
+        _StorageAlloc __tmp(__alloc_);
+        __alloc_.~_Alloc();
+        size_t __size = __unbounded_array_control_block::__bytes_for(__count_);
+        _AlignedStorage* __storage = reinterpret_cast<_AlignedStorage*>(this);
+        allocator_traits<_StorageAlloc>::deallocate(__tmp, _PointerTraits::pointer_to(*__storage), __size);
+    }
+
+    _LIBCPP_NO_UNIQUE_ADDRESS _Alloc __alloc_;
+    size_t __count_;
+    union {
+        _Tp __data_[1];
+    };
+};
+
+template<class _Array, class _Alloc, class... _Arg>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Array> __allocate_shared_unbounded_array(const _Alloc& __a, size_t __n, _Arg&& ...__arg)
+{
+    static_assert(is_unbounded_array_v<_Array>);
+    // We compute the number of bytes necessary to hold the control block and the
+    // array elements. Then, we allocate an array of properly-aligned dummy structs
+    // large enough to hold the control block and array. This allows shifting the
+    // burden of aligning memory properly from us to the allocator.
+    using _ControlBlock = __unbounded_array_control_block<_Array, _Alloc>;
+    using _AlignedStorage = __sp_aligned_storage<alignof(_ControlBlock)>;
+    using _StorageAlloc = __allocator_traits_rebind_t<_Alloc, _AlignedStorage>;
+    __allocation_guard<_StorageAlloc> __guard(__a, _ControlBlock::__bytes_for(__n) / sizeof(_AlignedStorage));
+    _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
+    std::construct_at(__control_block, __a, __n, std::forward<_Arg>(__arg)...);
+    __guard.__release_ptr();
+    return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
+}
+
+template <class _Tp, class _Alloc>
+struct __bounded_array_control_block;
+
+template <class _Tp, size_t _Count, class _Alloc>
+struct __bounded_array_control_block<_Tp[_Count], _Alloc>
+    : __shared_weak_count
+{
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    _Tp* __get_data() noexcept { return __data_; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    explicit __bounded_array_control_block(_Alloc const& __alloc, _Tp const& __arg) : __alloc_(__alloc) {
+        std::__uninitialized_allocator_fill_n(__alloc_, std::addressof(__data_[0]), _Count, __arg);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    explicit __bounded_array_control_block(_Alloc const& __alloc) : __alloc_(__alloc) {
+        std::__uninitialized_allocator_value_construct_n(__alloc_, std::addressof(__data_[0]), _Count);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    ~__bounded_array_control_block() override { } // can't be `= default` because of the sometimes-non-trivial union member __data_
+
+private:
+    void __on_zero_shared() _NOEXCEPT override {
+        __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
+        std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + _Count);
+    }
+
+    void __on_zero_shared_weak() _NOEXCEPT override {
+        using _ControlBlockAlloc = __allocator_traits_rebind_t<_Alloc, __bounded_array_control_block>;
+        using _PointerTraits = pointer_traits<typename allocator_traits<_ControlBlockAlloc>::pointer>;
+
+        _ControlBlockAlloc __tmp(__alloc_);
+        __alloc_.~_Alloc();
+        allocator_traits<_ControlBlockAlloc>::deallocate(__tmp, _PointerTraits::pointer_to(*this), sizeof(*this));
+    }
+
+    _LIBCPP_NO_UNIQUE_ADDRESS _Alloc __alloc_;
+    union {
+        _Tp __data_[_Count];
+    };
+};
+
+template<class _Array, class _Alloc, class... _Arg>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Array> __allocate_shared_bounded_array(const _Alloc& __a, _Arg&& ...__arg)
+{
+    static_assert(is_bounded_array_v<_Array>);
+    using _ControlBlock = __bounded_array_control_block<_Array, _Alloc>;
+    using _ControlBlockAlloc = __allocator_traits_rebind_t<_Alloc, _ControlBlock>;
+
+    __allocation_guard<_ControlBlockAlloc> __guard(__a, 1);
+    _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
+    std::construct_at(__control_block, __a, std::forward<_Arg>(__arg)...);
+    __guard.__release_ptr();
+    return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
+}
+
+template<class _Tp, class _Alloc, class = __enable_if_t<is_bounded_array<_Tp>::value>>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Tp> allocate_shared(const _Alloc& __a)
+{
+    return std::__allocate_shared_bounded_array<_Tp>(__a);
+}
+
+template<class _Tp, class _Alloc, class = __enable_if_t<is_bounded_array<_Tp>::value>>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Tp> allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u)
+{
+    return std::__allocate_shared_bounded_array<_Tp>(__a, __u);
+}
+
+template<class _Tp, class _Alloc, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n)
+{
+    return std::__allocate_shared_unbounded_array<_Tp>(__a, __n);
+}
+
+template<class _Tp, class _Alloc, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n, const remove_extent_t<_Tp>& __u)
+{
+    return std::__allocate_shared_unbounded_array<_Tp>(__a, __n, __u);
+}
+
+template<class _Tp, class = __enable_if_t<is_bounded_array<_Tp>::value>>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Tp> make_shared()
+{
+    return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>());
+}
+
+template<class _Tp, class = __enable_if_t<is_bounded_array<_Tp>::value>>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Tp> make_shared(const remove_extent_t<_Tp>& __u)
+{
+    return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>(), __u);
+}
+
+template<class _Tp, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Tp> make_shared(size_t __n)
+{
+    return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n);
+}
+
+template<class _Tp, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
+_LIBCPP_HIDE_FROM_ABI
+shared_ptr<_Tp> make_shared(size_t __n, const remove_extent_t<_Tp>& __u)
+{
+    return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n, __u);
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return __x.get() == __y.get();
 }
 

libcxx/include/__memory/uninitialized_algorithms.h

 // -*- 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___MEMORY_UNINITIALIZED_ALGORITHMS_H
 #define _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
+#include <__memory/allocator_traits.h>
 #include <__memory/construct_at.h>
 #include <__memory/voidify.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
+#include <__utility/transaction.h>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // This is a simplified version of C++20 `unreachable_sentinel` that doesn't use concepts and thus can be used in any
uninitialized_move_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst) {
   auto __iter_move = [](auto&& __iter) -> decltype(auto) { return _VSTD::move(*__iter); };
 
   return _VSTD::__uninitialized_move_n<_ValueType>(_VSTD::move(__ifirst), __n, _VSTD::move(__ofirst),
                                                    __unreachable_sentinel(), __iter_move);
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
+#if _LIBCPP_STD_VER > 17
+
+// Destroys every element in the range [first, last) FROM RIGHT TO LEFT using allocator
+// destruction. If elements are themselves C-style arrays, they are recursively destroyed
+// in the same manner.
+//
+// This function assumes that destructors do not throw, and that the allocator is bound to
+// the correct type.
+template<class _Alloc, class _BidirIter, class = __enable_if_t<
+    __is_cpp17_bidirectional_iterator<_BidirIter>::value
+>>
+_LIBCPP_HIDE_FROM_ABI
+constexpr void __allocator_destroy_multidimensional(_Alloc& __alloc, _BidirIter __first, _BidirIter __last) noexcept {
+    using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+    static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _ValueType>,
+        "The allocator should already be rebound to the correct type");
+
+    if (__first == __last)
+        return;
+
+    if constexpr (is_array_v<_ValueType>) {
+        static_assert(!is_unbounded_array_v<_ValueType>,
+            "arrays of unbounded arrays don't exist, but if they did we would mess up here");
+
+        using _Element = remove_extent_t<_ValueType>;
+        __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+        do {
+            --__last;
+            decltype(auto) __array = *__last;
+            std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + extent_v<_ValueType>);
+        } while (__last != __first);
+    } else {
+        do {
+            --__last;
+            allocator_traits<_Alloc>::destroy(__alloc, std::addressof(*__last));
+        } while (__last != __first);
+    }
+}
+
+// Constructs the object at the given location using the allocator's construct method.
+//
+// If the object being constructed is an array, each element of the array is allocator-constructed,
+// recursively. If an exception is thrown during the construction of an array, the initialized
+// elements are destroyed in reverse order of initialization using allocator destruction.
+//
+// This function assumes that the allocator is bound to the correct type.
+template<class _Alloc, class _Tp>
+_LIBCPP_HIDE_FROM_ABI
+constexpr void __allocator_construct_at(_Alloc& __alloc, _Tp* __loc) {
+    static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _Tp>,
+        "The allocator should already be rebound to the correct type");
+
+    if constexpr (is_array_v<_Tp>) {
+        using _Element = remove_extent_t<_Tp>;
+        __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+        size_t __i = 0;
+        _Tp& __array = *__loc;
+
+        // If an exception is thrown, destroy what we have constructed so far in reverse order.
+        __transaction __guard([&]() { std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i); });
+        for (; __i != extent_v<_Tp>; ++__i) {
+            std::__allocator_construct_at(__elem_alloc, std::addressof(__array[__i]));
+        }
+        __guard.__complete();
+    } else {
+        allocator_traits<_Alloc>::construct(__alloc, __loc);
+    }
+}
+
+// Constructs the object at the given location using the allocator's construct method, passing along
+// the provided argument.
+//
+// If the object being constructed is an array, the argument is also assumed to be an array. Each
+// each element of the array being constructed is allocator-constructed from the corresponding
+// element of the argument array. If an exception is thrown during the construction of an array,
+// the initialized elements are destroyed in reverse order of initialization using allocator
+// destruction.
+//
+// This function assumes that the allocator is bound to the correct type.
+template<class _Alloc, class _Tp, class _Arg>
+_LIBCPP_HIDE_FROM_ABI
+constexpr void __allocator_construct_at(_Alloc& __alloc, _Tp* __loc, _Arg const& __arg) {
+    static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _Tp>,
+        "The allocator should already be rebound to the correct type");
+
+    if constexpr (is_array_v<_Tp>) {
+        static_assert(is_array_v<_Arg>,
+            "Provided non-array initialization argument to __allocator_construct_at when "
+            "trying to construct an array.");
+
+        using _Element = remove_extent_t<_Tp>;
+        __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+        size_t __i = 0;
+        _Tp& __array = *__loc;
+
+        // If an exception is thrown, destroy what we have constructed so far in reverse order.
+        __transaction __guard([&]() { std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i); });
+        for (; __i != extent_v<_Tp>; ++__i) {
+            std::__allocator_construct_at(__elem_alloc, std::addressof(__array[__i]), __arg[__i]);
+        }
+        __guard.__complete();
+    } else {
+        allocator_traits<_Alloc>::construct(__alloc, __loc, __arg);
+    }
+}
+
+// Given a range starting at it and containing n elements, initializes each element in the
+// range from left to right using the construct method of the allocator (rebound to the
+// correct type).
+//
+// If an exception is thrown, the initialized elements are destroyed in reverse order of
+// initialization using allocator_traits destruction. If the elements in the range are C-style
+// arrays, they are initialized element-wise using allocator construction, and recursively so.
+template<class _Alloc, class _BidirIter, class _Tp, class _Size = typename iterator_traits<_BidirIter>::difference_type>
+_LIBCPP_HIDE_FROM_ABI
+constexpr void __uninitialized_allocator_fill_n(_Alloc& __alloc, _BidirIter __it, _Size __n, _Tp const& __value) {
+    using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+    __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
+    _BidirIter __begin = __it;
+
+    // If an exception is thrown, destroy what we have constructed so far in reverse order.
+    __transaction __guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
+    for (; __n != 0; --__n, ++__it) {
+        std::__allocator_construct_at(__value_alloc, std::addressof(*__it), __value);
+    }
+    __guard.__complete();
+}
+
+// Same as __uninitialized_allocator_fill_n, but doesn't pass any initialization argument
+// to the allocator's construct method, which results in value initialization.
+template<class _Alloc, class _BidirIter, class _Size = typename iterator_traits<_BidirIter>::difference_type>
+_LIBCPP_HIDE_FROM_ABI
+constexpr void __uninitialized_allocator_value_construct_n(_Alloc& __alloc, _BidirIter __it, _Size __n) {
+    using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+    __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
+    _BidirIter __begin = __it;
+
+    // If an exception is thrown, destroy what we have constructed so far in reverse order.
+    __transaction __guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
+    for (; __n != 0; --__n, ++__it) {
+        std::__allocator_construct_at(__value_alloc, std::addressof(*__it));
+    }
+    __guard.__complete();
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H

libcxx/include/memory

 
 // shared_ptr I/O:
 template<class E, class T, class Y>
     basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p);
 
 // shared_ptr get_deleter:
 template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept;
 
 template<class T, class... Args>
-    shared_ptr<T> make_shared(Args&&... args);
+    shared_ptr<T> make_shared(Args&&... args); // T is not an array
 template<class T, class A, class... Args>
-    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
+    shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not an array
+
+template<class T>
+    shared_ptr<T> make_shared(size_t N); // T is U[] (since C++20)
+template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[] (since C++20)
+
+template<class T>
+    shared_ptr<T> make_shared(); // T is U[N] (since C++20)
+template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a); // T is U[N] (since C++20)
+
+template<class T>
+    shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)
+template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a, size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)
+
+template<class T> shared_ptr<T>
+    make_shared(const remove_extent_t<T>& u); // T is U[N] (since C++20)
+template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u); // T is U[N] (since C++20)
 
 template<class T>
 class weak_ptr
 {
 public:
     typedef T element_type; // until C++17
     typedef remove_extent_t<T> element_type; // since C++17
 
public:
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
         {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
         {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
 };
 
 _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
 
 // --- Helper for container swap --
 template <typename _Alloc>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
 #if _LIBCPP_STD_VER > 11
     _NOEXCEPT
 #else
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
     using _VSTD::swap;
     swap(__a1, __a2);
 }
 
 template <typename _Alloc>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
 
 template <typename _Alloc>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
 #if _LIBCPP_STD_VER > 11
     _NOEXCEPT
 #else
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
     _VSTD::__swap_allocator(__a1, __a2,
       integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>());
 }
 
 template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
 struct __noexcept_move_assign_container : public integral_constant<bool,
     _Traits::propagate_on_container_move_assignment::value
 #if _LIBCPP_STD_VER > 14
         || _Traits::is_always_equal::value
 #else
         && is_nothrow_move_assignable<_Alloc>::value
 #endif
     > {};
 
 
 template <class _Tp, class _Alloc>
 struct __temp_value {
     typedef allocator_traits<_Alloc> _Traits;
 
     typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
     _Alloc &__a;
 
     _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
     _Tp &   get() { return *__addr(); }
 
     template<class... _Args>
     _LIBCPP_NO_CFI
     __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
       _Traits::construct(__a, reinterpret_cast<_Tp*>(addressof(__v)),
                          _VSTD::forward<_Args>(__args)...);
     }
 
     ~__temp_value() { _Traits::destroy(__a, __addr()); }
     };
 
 template<typename _Alloc, typename = void, typename = void>
 struct __is_allocator : false_type {};
 
 template<typename _Alloc>
 struct __is_allocator<_Alloc,
        typename __void_t<typename _Alloc::value_type>::type,
        typename __void_t<decltype(declval<_Alloc&>().allocate(size_t(0)))>::type
      >
    : true_type {};
 
 // __builtin_new_allocator -- A non-templated helper for allocating and
 // deallocating memory using __builtin_operator_new and
 // __builtin_operator_delete. It should be used in preference to
 // `std::allocator<T>` to avoid additional instantiations.
 struct __builtin_new_allocator {
   struct __builtin_new_deleter {
     typedef void* pointer_type;
 
     _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
         : __size_(__size), __align_(__align) {}
 
     void operator()(void* p) const _NOEXCEPT {
         _VSTD::__libcpp_deallocate(p, __size_, __align_);
     }
 
    private:
     size_t __size_;
     size_t __align_;
   };
 
   typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
 
   static __holder_t __allocate_bytes(size_t __s, size_t __align) {
       return __holder_t(_VSTD::__libcpp_allocate(__s, __align),
                      __builtin_new_deleter(__s, __align));
   }
 
   static void __deallocate_bytes(void* __p, size_t __s,
                                  size_t __align) _NOEXCEPT {
       _VSTD::__libcpp_deallocate(__p, __s, __align);
   }
 
   template <class _Tp>
   _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
   static __holder_t __allocate_type(size_t __n) {
       return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
   }
 
   template <class _Tp>
   _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
   static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
       __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
   }
 };
 
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_memory>
 #endif
 
 #endif // _LIBCPP_MEMORY

libcxx/include/version

 __cpp_lib_reference_from_temporary                      202202L <type_traits>
 __cpp_lib_remove_cvref                                  201711L <type_traits>
 __cpp_lib_result_of_sfinae                              201210L <functional> <type_traits>
 __cpp_lib_robust_nonmodifying_seq_ops                   201304L <algorithm>
 __cpp_lib_sample                                        201603L <algorithm>
 __cpp_lib_scoped_lock                                   201703L <mutex>
 __cpp_lib_semaphore                                     201907L <semaphore>
 __cpp_lib_shared_mutex                                  201505L <shared_mutex>
-__cpp_lib_shared_ptr_arrays                             201611L <memory>
+__cpp_lib_shared_ptr_arrays                             201707L <memory>
+                                                        201611L // C++17
 __cpp_lib_shared_ptr_weak_type                          201606L <memory>
 __cpp_lib_shared_timed_mutex                            201402L <shared_mutex>
 __cpp_lib_shift                                         201806L <algorithm>
 __cpp_lib_smart_ptr_for_overwrite                       202002L <memory>
 __cpp_lib_source_location                               201907L <source_location>
 __cpp_lib_span                                          202002L <span>
 __cpp_lib_spanstream                                    202106L <spanstream>
 __cpp_lib_ssize                                         201902L <iterator>

 # define __cpp_lib_list_remove_return_type              201806L
 # define __cpp_lib_math_constants                       201907L
 // # 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
+# undef  __cpp_lib_shared_ptr_arrays
+# define __cpp_lib_shared_ptr_arrays                    201707L
 # define __cpp_lib_shift                                201806L
 // # define __cpp_lib_smart_ptr_for_overwrite              202002L
 // # define __cpp_lib_source_location                      201907L
 # 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

libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.array.zero_size.compile.fail.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
+
+// Make sure that std::allocate_shared<T[0]>(...) fails at compile-time.
+// While Clang and GCC appear to support T[0] as a language extension, that support is
+// unreliable (for example T[0] doesn't match a T[N] partial specialization on Clang as
+// of writing this). So instead, we make sure that this doesn't work at all with our
+// implementation.
+
+#include <memory>
+
+void f() {
+  auto p = std::allocate_shared<int[0]>(std::allocator<int[0]>());
+  (void)p;
+}

libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.array.zero_size.compile.fail.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
+
+// Make sure that std::make_shared<T[0]>(...) fails at compile-time.
+// While Clang and GCC appear to support T[0] as a language extension, that support is
+// unreliable (for example T[0] doesn't match a T[N] partial specialization on Clang as
+// of writing this). So instead, we make sure that this doesn't work at all with our
+// implementation.
+
+#include <memory>
+
+void f() {
+  auto p = std::make_shared<int[0]>();
+  (void)p;
+}

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

/*  Constant                                      Value
     __cpp_lib_constexpr_dynamic_alloc             201907L [C++20]
     __cpp_lib_constexpr_memory                    201811L [C++20]
     __cpp_lib_enable_shared_from_this             201603L [C++17]
     __cpp_lib_make_unique                         201304L [C++14]
     __cpp_lib_out_ptr                             202106L [C++2b]
     __cpp_lib_ranges                              201811L [C++20]
     __cpp_lib_raw_memory_algorithms               201606L [C++17]
     __cpp_lib_shared_ptr_arrays                   201611L [C++17]
+                                                  201707L [C++20]
     __cpp_lib_shared_ptr_weak_type                201606L [C++17]
     __cpp_lib_smart_ptr_for_overwrite             202002L [C++20]
     __cpp_lib_to_address                          201711L [C++20]
     __cpp_lib_transparent_operators               201210L [C++14]
                                                   201510L [C++17]
 */
 
 #include <memory>

 # endif
 # if __cpp_lib_raw_memory_algorithms != 201606L
 #   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++20"
 # endif
 
 # ifndef __cpp_lib_shared_ptr_arrays
 #   error "__cpp_lib_shared_ptr_arrays should be defined in c++20"
 # endif
-# if __cpp_lib_shared_ptr_arrays != 201611L
-#   error "__cpp_lib_shared_ptr_arrays should have the value 201611L in c++20"
+# if __cpp_lib_shared_ptr_arrays != 201707L
+#   error "__cpp_lib_shared_ptr_arrays should have the value 201707L in c++20"
 # endif
 
 # ifndef __cpp_lib_shared_ptr_weak_type
 #   error "__cpp_lib_shared_ptr_weak_type should be defined in c++20"
 # endif
 # if __cpp_lib_shared_ptr_weak_type != 201606L
 #   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++20"
 # endif

 # endif
 # if __cpp_lib_raw_memory_algorithms != 201606L
 #   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++2b"
 # endif
 
 # ifndef __cpp_lib_shared_ptr_arrays
 #   error "__cpp_lib_shared_ptr_arrays should be defined in c++2b"
 # endif
-# if __cpp_lib_shared_ptr_arrays != 201611L
-#   error "__cpp_lib_shared_ptr_arrays should have the value 201611L in c++2b"
+# if __cpp_lib_shared_ptr_arrays != 201707L
+#   error "__cpp_lib_shared_ptr_arrays should have the value 201707L in c++2b"
 # endif
 
 # ifndef __cpp_lib_shared_ptr_weak_type
 #   error "__cpp_lib_shared_ptr_weak_type should be defined in c++2b"
 # endif
 # if __cpp_lib_shared_ptr_weak_type != 201606L
 #   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++2b"
 # endif

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

/*  Constant                                       Value
     __cpp_lib_remove_cvref                         201711L [C++20]
     __cpp_lib_result_of_sfinae                     201210L [C++14]
     __cpp_lib_robust_nonmodifying_seq_ops          201304L [C++14]
     __cpp_lib_sample                               201603L [C++17]
     __cpp_lib_scoped_lock                          201703L [C++17]
     __cpp_lib_semaphore                            201907L [C++20]
     __cpp_lib_shared_mutex                         201505L [C++17]
     __cpp_lib_shared_ptr_arrays                    201611L [C++17]
+                                                   201707L [C++20]
     __cpp_lib_shared_ptr_weak_type                 201606L [C++17]
     __cpp_lib_shared_timed_mutex                   201402L [C++14]
     __cpp_lib_shift                                201806L [C++20]
     __cpp_lib_smart_ptr_for_overwrite              202002L [C++20]
     __cpp_lib_source_location                      201907L [C++20]
     __cpp_lib_span                                 202002L [C++20]
     __cpp_lib_spanstream                           202106L [C++2b]
     __cpp_lib_ssize                                201902L [C++20]

 #   ifdef __cpp_lib_shared_mutex
 #     error "__cpp_lib_shared_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_shared_ptr_arrays
 #   error "__cpp_lib_shared_ptr_arrays should be defined in c++20"
 # endif
-# if __cpp_lib_shared_ptr_arrays != 201611L
-#   error "__cpp_lib_shared_ptr_arrays should have the value 201611L in c++20"
+# if __cpp_lib_shared_ptr_arrays != 201707L
+#   error "__cpp_lib_shared_ptr_arrays should have the value 201707L in c++20"
 # endif
 
 # ifndef __cpp_lib_shared_ptr_weak_type
 #   error "__cpp_lib_shared_ptr_weak_type should be defined in c++20"
 # endif
 # if __cpp_lib_shared_ptr_weak_type != 201606L
 #   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++20"
 # endif

 #   ifdef __cpp_lib_shared_mutex
 #     error "__cpp_lib_shared_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_shared_ptr_arrays
 #   error "__cpp_lib_shared_ptr_arrays should be defined in c++2b"
 # endif
-# if __cpp_lib_shared_ptr_arrays != 201611L
-#   error "__cpp_lib_shared_ptr_arrays should have the value 201611L in c++2b"
+# if __cpp_lib_shared_ptr_arrays != 201707L
+#   error "__cpp_lib_shared_ptr_arrays should have the value 201707L in c++2b"
 # endif
 
 # ifndef __cpp_lib_shared_ptr_weak_type
 #   error "__cpp_lib_shared_ptr_weak_type should be defined in c++2b"
 # endif
 # if __cpp_lib_shared_ptr_weak_type != 201606L
 #   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++2b"
 # endif

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.array.bounded.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
+
+// Aligned deallocation isn't provided before macOS 10.14, and some tests for overaligned types
+// below require that feature.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13}}
+
+// <memory>
+
+// shared_ptr
+
+// template<class T, class A>
+// shared_ptr<T> allocate_shared(const A& a); // T is U[N]
+//
+// template<class T, class A>
+// shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u); // T is U[N]
+
+#include <cassert>
+#include <concepts>
+#include <cstdint> // std::uintptr_t
+#include <memory>
+#include <utility>
+
+#include "min_allocator.h"
+#include "operator_hijacker.h"
+#include "types.h"
+
+template <class T, class ...Args>
+concept CanAllocateShared = requires(Args&& ...args) {
+  { std::allocate_shared<T>(std::forward<Args>(args)...) } -> std::same_as<std::shared_ptr<T>>;
+};
+
+int main(int, char**) {
+  // Make sure we initialize elements correctly
+  {
+    // Without passing an initial value
+    {
+      using Array = int[8];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i] == 0);
+      }
+    }
+    {
+      using Array = int[8][3];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 0);
+        assert(ptr[i][1] == 0);
+        assert(ptr[i][2] == 0);
+      }
+    }
+    {
+      using Array = int[8][3][2];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0][0] == 0);
+        assert(ptr[i][0][1] == 0);
+        assert(ptr[i][1][0] == 0);
+        assert(ptr[i][1][1] == 0);
+        assert(ptr[i][2][0] == 0);
+        assert(ptr[i][2][1] == 0);
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[8];
+      int init = 42;
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i] == init);
+      }
+    }
+    {
+      using Array = int[8][3];
+      int init[3] = {42, 43, 44};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 42);
+        assert(ptr[i][1] == 43);
+        assert(ptr[i][2] == 44);
+      }
+    }
+    {
+      using Array = int[8][3][2];
+      int init[3][2] = {{31, 32}, {41, 42}, {51, 52}};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0][0] == 31);
+        assert(ptr[i][0][1] == 32);
+        assert(ptr[i][1][0] == 41);
+        assert(ptr[i][1][1] == 42);
+        assert(ptr[i][2][0] == 51);
+        assert(ptr[i][2][1] == 52);
+      }
+    }
+  }
+
+  // Make sure array elements are destroyed in reverse order
+  {
+    // Without passing an initial value
+    {
+      using Array = DestroyInReverseOrder[8];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+        assert(DestroyInReverseOrder::alive() == 8);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+    {
+      using Array = DestroyInReverseOrder[8][3];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+        assert(DestroyInReverseOrder::alive() == 8 * 3);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+    {
+      using Array = DestroyInReverseOrder[8][3][2];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+        assert(DestroyInReverseOrder::alive() == 8 * 3 * 2);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = DestroyInReverseOrder[8];
+      int count = 0;
+      DestroyInReverseOrder init(&count);
+      int init_count = 1;
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+        assert(count == 8 + init_count);
+      }
+      assert(count == init_count);
+    }
+    {
+      using Array = DestroyInReverseOrder[8][3];
+      int count = 0;
+      DestroyInReverseOrder init[3] = {&count, &count, &count};
+      int init_count = 3;
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+        assert(count == 8 * 3 + init_count);
+      }
+      assert(count == init_count);
+    }
+    {
+      using Array = DestroyInReverseOrder[8][3][2];
+      int count = 0;
+      DestroyInReverseOrder init[3][2] = {{&count, &count}, {&count, &count}, {&count, &count}};
+      int init_count = 3 * 2;
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+        assert(count == 8 * 3 * 2 + init_count);
+      }
+      assert(count == init_count);
+    }
+  }
+
+  // Count the number of copies being made
+  {
+    // Without passing an initial value
+    {
+      using Array = CountCopies[8];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+      assert(CountCopies::copies() == 0);
+    }
+    {
+      using Array = CountCopies[8][3];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());;
+      assert(CountCopies::copies() == 0);
+    }
+    {
+      using Array = CountCopies[8][3][2];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());;
+      assert(CountCopies::copies() == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = CountCopies[8];
+      int copies = 0;
+      CountCopies init(&copies);
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+      assert(copies == 8);
+    }
+    {
+      using Array = CountCopies[8][3];
+      int copies = 0;
+      CountCopies init[3] = {&copies, &copies, &copies};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+      assert(copies == 8 * 3);
+    }
+    {
+      using Array = CountCopies[8][3][2];
+      int copies = 0;
+      CountCopies init[3][2] = {{&copies, &copies}, {&copies, &copies}, {&copies, &copies}};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+      assert(copies == 8 * 3 * 2);
+    }
+  }
+
+  // Make sure array elements are aligned properly when the array contains an overaligned type.
+  //
+  // Here, we don't need to test both the with-initial-value and without-initial-value code paths,
+  // since we're just checking the alignment and both are going to use the same code path unless
+  // the implementation is completely crazy.
+  {
+    auto check_alignment = []<class T> {
+      {
+        using Array = T[8];
+        std::shared_ptr ptr = std::allocate_shared<Array>(std::allocator<Array>());
+        for (int i = 0; i < 8; ++i) {
+          T* p = std::addressof(ptr[i]);
+          assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+        }
+      }
+      {
+        using Array = T[8][3];
+        std::shared_ptr ptr = std::allocate_shared<Array>(std::allocator<Array>());
+        for (int i = 0; i < 8; ++i) {
+          for (int j = 0; j < 3; ++j) {
+            T* p = std::addressof(ptr[i][j]);
+            assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+          }
+        }
+      }
+      {
+        using Array = T[8][3][2];
+        std::shared_ptr ptr = std::allocate_shared<Array>(std::allocator<Array>());
+        for (int i = 0; i < 8; ++i) {
+          for (int j = 0; j < 3; ++j) {
+            for (int k = 0; k < 2; ++k) {
+              T* p = std::addressof(ptr[i][j][k]);
+              assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+            }
+          }
+        }
+      }
+    };
+
+    struct Empty { };
+    check_alignment.operator()<Empty>();
+    check_alignment.operator()<OverAligned>();
+    check_alignment.operator()<MaxAligned>();
+
+    // test non corner cases as well while we're at it
+    struct Foo { int i; char c; };
+    check_alignment.operator()<int>();
+    check_alignment.operator()<Foo>();
+  }
+
+  // Make sure that we destroy all the elements constructed so far when an exception
+  // is thrown. Also make sure that we do it in reverse order of construction.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    struct Sentinel : ThrowOnConstruction, DestroyInReverseOrder { };
+
+    // Without passing an initial value
+    {
+      using Array = Sentinel[8];
+      for (int i = 0; i < 8; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[8][3];
+      for (int i = 0; i < 8 * 3; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[8][3][2];
+      for (int i = 0; i < 8 * 3 * 2; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = Sentinel[8];
+      for (int i = 0; i < 8; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init;
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 1);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[8][3];
+      for (int i = 0; i < 8 * 3; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init[3] = {};
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 3);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[8][3][2];
+      for (int i = 0; i < 8 * 3 * 2; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init[3][2] = {};
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 3 * 2);
+        }
+      }
+    }
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // Test with another allocator that's not std::allocator
+  {
+    // Without passing an initial value
+    {
+      using Array = int[8][3];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(min_allocator<Array>());
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 0);
+        assert(ptr[i][1] == 0);
+        assert(ptr[i][2] == 0);
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[8][3];
+      int init[3] = {42, 43, 44};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(min_allocator<Array>(), init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 42);
+        assert(ptr[i][1] == 43);
+        assert(ptr[i][2] == 44);
+      }
+    }
+  }
+
+  // Make sure the version without an initialization argument works even for non-movable types
+  {
+    using Array = NonMovable[8][3];
+    std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>());
+    (void)ptr;
+  }
+
+  // Make sure std::allocate_shared handles badly-behaved types properly
+  {
+    using Array = operator_hijacker[3];
+    std::shared_ptr<Array> p1 = std::allocate_shared<Array>(std::allocator<Array>());
+    std::shared_ptr<Array> p2 = std::allocate_shared<Array>(std::allocator<Array>(), operator_hijacker());
+    assert(p1 != nullptr);
+    assert(p2 != nullptr);
+  }
+
+  // Check that we SFINAE-away for invalid arguments
+  {
+    struct T { };
+    static_assert( CanAllocateShared<T[8], std::allocator<T[8]>>);
+    static_assert( CanAllocateShared<T[8], std::allocator<T[8]>, T>);
+    static_assert(!CanAllocateShared<T[8], std::allocator<T[8]>, T, int>); // too many arguments
+    static_assert(!CanAllocateShared<T[8], std::allocator<T[8]>, int>); // T is not constructible from int
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.array.unbounded.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
+
+// Aligned deallocation isn't provided before macOS 10.14, and some tests for overaligned types
+// below require that feature.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13}}
+
+// <memory>
+
+// shared_ptr
+
+// template<class T, class A>
+// shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[]
+//
+// template<class T, class A>
+// shared_ptr<T> allocate_shared(const A& a, size_t N, const remove_extent_t<T>& u); // T is U[]
+
+// Ignore error about requesting a large alignment not being ABI compatible with older AIX systems.
+#ifdef _AIX
+# pragma clang diagnostic ignored "-Waix-compat"
+#endif
+
+#include <cassert>
+#include <concepts>
+#include <cstdint> // std::uintptr_t
+#include <memory>
+#include <utility>
+
+#include "min_allocator.h"
+#include "operator_hijacker.h"
+#include "test_macros.h"
+#include "types.h"
+
+template <class T, class ...Args>
+concept CanAllocateShared = requires(Args&& ...args) {
+  { std::allocate_shared<T>(std::forward<Args>(args)...) } -> std::same_as<std::shared_ptr<T>>;
+};
+
+int main(int, char**) {
+  // Check behavior for a zero-sized array
+  {
+    // Without passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 0);
+      assert(ptr != nullptr);
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 0, 42);
+      assert(ptr != nullptr);
+    }
+  }
+
+  // Check behavior for a 1-sized array
+  {
+    // Without passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 1);
+      assert(ptr != nullptr);
+      assert(ptr[0] == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 1, 42);
+      assert(ptr != nullptr);
+      assert(ptr[0] == 42);
+    }
+  }
+
+  // Make sure we initialize elements correctly
+  {
+    // Without passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i] == 0);
+      }
+    }
+    {
+      using Array = int[][3];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 0);
+        assert(ptr[i][1] == 0);
+        assert(ptr[i][2] == 0);
+      }
+    }
+    {
+      using Array = int[][3][2];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0][0] == 0);
+        assert(ptr[i][0][1] == 0);
+        assert(ptr[i][1][0] == 0);
+        assert(ptr[i][1][1] == 0);
+        assert(ptr[i][2][0] == 0);
+        assert(ptr[i][2][1] == 0);
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[];
+      int init = 42;
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i] == init);
+      }
+    }
+    {
+      using Array = int[][3];
+      int init[3] = {42, 43, 44};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 42);
+        assert(ptr[i][1] == 43);
+        assert(ptr[i][2] == 44);
+      }
+    }
+    {
+      using Array = int[][3][2];
+      int init[3][2] = {{31, 32}, {41, 42}, {51, 52}};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0][0] == 31);
+        assert(ptr[i][0][1] == 32);
+        assert(ptr[i][1][0] == 41);
+        assert(ptr[i][1][1] == 42);
+        assert(ptr[i][2][0] == 51);
+        assert(ptr[i][2][1] == 52);
+      }
+    }
+  }
+
+  // Make sure array elements are destroyed in reverse order
+  {
+    // Without passing an initial value
+    {
+      using Array = DestroyInReverseOrder[];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+        assert(DestroyInReverseOrder::alive() == 8);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+    {
+      using Array = DestroyInReverseOrder[][3];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+        assert(DestroyInReverseOrder::alive() == 8 * 3);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+    {
+      using Array = DestroyInReverseOrder[][3][2];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+        assert(DestroyInReverseOrder::alive() == 8 * 3 * 2);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = DestroyInReverseOrder[];
+      int count = 0;
+      DestroyInReverseOrder init(&count);
+      int init_count = 1;
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+        assert(count == 8 + init_count);
+      }
+      assert(count == init_count);
+    }
+    {
+      using Array = DestroyInReverseOrder[][3];
+      int count = 0;
+      DestroyInReverseOrder init[3] = {&count, &count, &count};
+      int init_count = 3;
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+        assert(count == 8 * 3 + init_count);
+      }
+      assert(count == init_count);
+    }
+    {
+      using Array = DestroyInReverseOrder[][3][2];
+      int count = 0;
+      DestroyInReverseOrder init[3][2] = {{&count, &count}, {&count, &count}, {&count, &count}};
+      int init_count = 3 * 2;
+      {
+        std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+        assert(count == 8 * 3 * 2 + init_count);
+      }
+      assert(count == init_count);
+    }
+  }
+
+  // Count the number of copies being made
+  {
+    // Without passing an initial value
+    {
+      using Array = CountCopies[];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+      assert(CountCopies::copies() == 0);
+    }
+    {
+      using Array = CountCopies[][3];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+      assert(CountCopies::copies() == 0);
+    }
+    {
+      using Array = CountCopies[][3][2];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+      assert(CountCopies::copies() == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = CountCopies[];
+      int copies = 0;
+      CountCopies init(&copies);
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+      assert(copies == 8);
+    }
+    {
+      using Array = CountCopies[][3];
+      int copies = 0;
+      CountCopies init[3] = {&copies, &copies, &copies};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+      assert(copies == 8 * 3);
+    }
+    {
+      using Array = CountCopies[][3][2];
+      int copies = 0;
+      CountCopies init[3][2] = {{&copies, &copies}, {&copies, &copies}, {&copies, &copies}};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+      assert(copies == 8 * 3 * 2);
+    }
+  }
+
+  // Make sure array elements are aligned properly when the array contains an overaligned type.
+  //
+  // Here, we don't need to test both the with-initial-value and without-initial-value code paths,
+  // since we're just checking the alignment and both are going to use the same code path unless
+  // the implementation is completely crazy.
+  {
+    auto check_alignment = []<class T> {
+      {
+        using Array = T[];
+        std::shared_ptr ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+        for (int i = 0; i < 8; ++i) {
+          T* p = std::addressof(ptr[i]);
+          assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+        }
+      }
+      {
+        using Array = T[][3];
+        std::shared_ptr ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+        for (int i = 0; i < 8; ++i) {
+          for (int j = 0; j < 3; ++j) {
+            T* p = std::addressof(ptr[i][j]);
+            assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+          }
+        }
+      }
+      {
+        using Array = T[][3][2];
+        std::shared_ptr ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+        for (int i = 0; i < 8; ++i) {
+          for (int j = 0; j < 3; ++j) {
+            for (int k = 0; k < 2; ++k) {
+              T* p = std::addressof(ptr[i][j][k]);
+              assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+            }
+          }
+        }
+      }
+    };
+
+    struct Empty { };
+    check_alignment.operator()<Empty>();
+    check_alignment.operator()<OverAligned>();
+    check_alignment.operator()<MaxAligned>();
+
+    // test non corner cases as well while we're at it
+    struct Foo { int i; char c; };
+    check_alignment.operator()<int>();
+    check_alignment.operator()<Foo>();
+  }
+
+  // Make sure that we destroy all the elements constructed so far when an exception
+  // is thrown. Also make sure that we do it in reverse order of construction.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    struct Sentinel : ThrowOnConstruction, DestroyInReverseOrder { };
+
+    // Without passing an initial value
+    {
+      using Array = Sentinel[];
+      for (int i = 0; i < 8; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[][3];
+      for (int i = 0; i < 8 * 3; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[][3][2];
+      for (int i = 0; i < 8 * 3 * 2; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = Sentinel[];
+      for (int i = 0; i < 8; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init;
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 1);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[][3];
+      for (int i = 0; i < 8 * 3; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init[3] = {};
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 3);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[][3][2];
+      for (int i = 0; i < 8 * 3 * 2; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init[3][2] = {};
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8, init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 3 * 2);
+        }
+      }
+    }
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // Test with another allocator that's not std::allocator
+  {
+    // Without passing an initial value
+    {
+      using Array = int[][3];
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(min_allocator<Array>(), 8);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 0);
+        assert(ptr[i][1] == 0);
+        assert(ptr[i][2] == 0);
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[][3];
+      int init[3] = {42, 43, 44};
+      std::shared_ptr<Array> ptr = std::allocate_shared<Array>(min_allocator<Array>(), 8, init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 42);
+        assert(ptr[i][1] == 43);
+        assert(ptr[i][2] == 44);
+      }
+    }
+  }
+
+  // Make sure the version without an initialization argument works even for non-movable types
+  {
+    using Array = NonMovable[][3];
+    std::shared_ptr<Array> ptr = std::allocate_shared<Array>(std::allocator<Array>(), 8);
+    (void)ptr;
+  }
+
+  // Make sure std::allocate_shared handles badly-behaved types properly
+  {
+    using Array = operator_hijacker[];
+    std::shared_ptr<Array> p1 = std::allocate_shared<Array>(std::allocator<Array>(), 3);
+    std::shared_ptr<Array> p2 = std::allocate_shared<Array>(std::allocator<Array>(), 3, operator_hijacker());
+    assert(p1 != nullptr);
+    assert(p2 != nullptr);
+  }
+
+  // Check that we SFINAE-away for invalid arguments
+  {
+    struct T { };
+    static_assert( CanAllocateShared<T[], std::allocator<T[]>, std::size_t>);
+    static_assert( CanAllocateShared<T[], std::allocator<T[]>, std::size_t, T>);
+    static_assert(!CanAllocateShared<T[], std::allocator<T[]>, std::size_t, T, int>); // too many arguments
+    static_assert(!CanAllocateShared<T[], std::allocator<T[]>, std::size_t, int>); // T not constructible from int
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 
 // template<class T, class A, class... Args>
-//    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
+// shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not an array
 
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
-#include "test_macros.h"
-#include "test_allocator.h"
+
 #include "min_allocator.h"
+#include "operator_hijacker.h"
+#include "test_allocator.h"
+#include "test_macros.h"
 
 int new_count = 0;
 
 struct A
 {
     static int count;
 
     A(int i, char c) : int_(i), char_(c) {++count;}
int main(int, char**)
     char c = 'f';
     std::shared_ptr<A> p = std::allocate_shared<A>(bare_allocator<void>(), i, c);
     assert(A::count == 1);
     assert(p->get_int() == 68);
     assert(p->get_char() == 'f');
     }
     assert(A::count == 0);
 
+    // Make sure std::allocate_shared handles badly-behaved types properly
+    {
+        std::shared_ptr<operator_hijacker> p1 = std::allocate_shared<operator_hijacker>(min_allocator<operator_hijacker>());
+        std::shared_ptr<operator_hijacker> p2 = std::allocate_shared<operator_hijacker>(min_allocator<operator_hijacker>(), operator_hijacker());
+        assert(p1 != nullptr);
+        assert(p2 != nullptr);
+    }
+
     // Test that we don't call construct before C++20.
 #if TEST_STD_VER < 20
     {
     (void)std::allocate_shared<int>(AllocNoConstruct<int>());
     }
 #endif // TEST_STD_VER < 20
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_construct.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
 
 // <memory>
 
 // shared_ptr
 
 // template<class T, class A, class... Args>
-//    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
+// shared_ptr<T> allocate_shared(const A& a, Args&&... args);
 
 // This test checks that allocator_traits::construct is used in allocate_shared
 // as requested in C++20 (via P0674R1).
 
 #include "test_macros.h"
 
 #include <memory>
 #include <cassert>

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.array.bounded.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
+
+// Aligned deallocation isn't provided before macOS 10.14, and some tests for overaligned types
+// below require that feature.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13}}
+
+// <memory>
+
+// shared_ptr
+
+// template<class T>
+// shared_ptr<T> make_shared(); // T is U[N]
+//
+// template<class T>
+// shared_ptr<T> make_shared(const remove_extent_t<T>& u); // T is U[N]
+
+#include <cassert>
+#include <concepts>
+#include <cstdint> // std::uintptr_t
+#include <memory>
+#include <utility>
+
+#include "operator_hijacker.h"
+#include "types.h"
+
+template <class T, class ...Args>
+concept CanMakeShared = requires(Args&& ...args) {
+  { std::make_shared<T>(std::forward<Args>(args)...) } -> std::same_as<std::shared_ptr<T>>;
+};
+
+int main(int, char**) {
+  // Make sure we initialize elements correctly
+  {
+    // Without passing an initial value
+    {
+      using Array = int[8];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>();
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i] == 0);
+      }
+    }
+    {
+      using Array = int[8][3];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>();
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 0);
+        assert(ptr[i][1] == 0);
+        assert(ptr[i][2] == 0);
+      }
+    }
+    {
+      using Array = int[8][3][2];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>();
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0][0] == 0);
+        assert(ptr[i][0][1] == 0);
+        assert(ptr[i][1][0] == 0);
+        assert(ptr[i][1][1] == 0);
+        assert(ptr[i][2][0] == 0);
+        assert(ptr[i][2][1] == 0);
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[8];
+      int init = 42;
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i] == init);
+      }
+    }
+    {
+      using Array = int[8][3];
+      int init[3] = {42, 43, 44};
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 42);
+        assert(ptr[i][1] == 43);
+        assert(ptr[i][2] == 44);
+      }
+    }
+    {
+      using Array = int[8][3][2];
+      int init[3][2] = {{31, 32}, {41, 42}, {51, 52}};
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0][0] == 31);
+        assert(ptr[i][0][1] == 32);
+        assert(ptr[i][1][0] == 41);
+        assert(ptr[i][1][1] == 42);
+        assert(ptr[i][2][0] == 51);
+        assert(ptr[i][2][1] == 52);
+      }
+    }
+  }
+
+  // Make sure array elements are destroyed in reverse order
+  {
+    // Without passing an initial value
+    {
+      using Array = DestroyInReverseOrder[8];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>();
+        assert(DestroyInReverseOrder::alive() == 8);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+    {
+      using Array = DestroyInReverseOrder[8][3];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>();
+        assert(DestroyInReverseOrder::alive() == 8 * 3);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+    {
+      using Array = DestroyInReverseOrder[8][3][2];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>();
+        assert(DestroyInReverseOrder::alive() == 8 * 3 * 2);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = DestroyInReverseOrder[8];
+      int count = 0;
+      DestroyInReverseOrder init(&count);
+      int init_count = 1;
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+        assert(count == 8 + init_count);
+      }
+      assert(count == init_count);
+    }
+    {
+      using Array = DestroyInReverseOrder[8][3];
+      int count = 0;
+      DestroyInReverseOrder init[3] = {&count, &count, &count};
+      int init_count = 3;
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+        assert(count == 8 * 3 + init_count);
+      }
+      assert(count == init_count);
+    }
+    {
+      using Array = DestroyInReverseOrder[8][3][2];
+      int count = 0;
+      DestroyInReverseOrder init[3][2] = {{&count, &count}, {&count, &count}, {&count, &count}};
+      int init_count = 3 * 2;
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+        assert(count == 8 * 3 * 2 + init_count);
+      }
+      assert(count == init_count);
+    }
+  }
+
+  // Count the number of copies being made
+  {
+    // Without passing an initial value
+    {
+      using Array = CountCopies[8];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::make_shared<Array>();
+      assert(CountCopies::copies() == 0);
+    }
+    {
+      using Array = CountCopies[8][3];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::make_shared<Array>();
+      assert(CountCopies::copies() == 0);
+    }
+    {
+      using Array = CountCopies[8][3][2];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::make_shared<Array>();
+      assert(CountCopies::copies() == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = CountCopies[8];
+      int copies = 0;
+      CountCopies init(&copies);
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+      assert(copies == 8);
+    }
+    {
+      using Array = CountCopies[8][3];
+      int copies = 0;
+      CountCopies init[3] = {&copies, &copies, &copies};
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+      assert(copies == 8 * 3);
+    }
+    {
+      using Array = CountCopies[8][3][2];
+      int copies = 0;
+      CountCopies init[3][2] = {{&copies, &copies}, {&copies, &copies}, {&copies, &copies}};
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+      assert(copies == 8 * 3 * 2);
+    }
+  }
+
+  // Make sure array elements are aligned properly when the array contains an overaligned type.
+  //
+  // Here, we don't need to test both the with-initial-value and without-initial-value code paths,
+  // since we're just checking the alignment and both are going to use the same code path unless
+  // the implementation is completely crazy.
+  {
+    auto check_alignment = []<class T> {
+      {
+        using Array = T[8];
+        std::shared_ptr ptr = std::make_shared<Array>();
+        for (int i = 0; i < 8; ++i) {
+          T* p = std::addressof(ptr[i]);
+          assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+        }
+      }
+      {
+        using Array = T[8][3];
+        std::shared_ptr ptr = std::make_shared<Array>();
+        for (int i = 0; i < 8; ++i) {
+          for (int j = 0; j < 3; ++j) {
+            T* p = std::addressof(ptr[i][j]);
+            assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+          }
+        }
+      }
+      {
+        using Array = T[8][3][2];
+        std::shared_ptr ptr = std::make_shared<Array>();
+        for (int i = 0; i < 8; ++i) {
+          for (int j = 0; j < 3; ++j) {
+            for (int k = 0; k < 2; ++k) {
+              T* p = std::addressof(ptr[i][j][k]);
+              assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+            }
+          }
+        }
+      }
+    };
+
+    struct Empty { };
+    check_alignment.operator()<Empty>();
+    check_alignment.operator()<OverAligned>();
+    check_alignment.operator()<MaxAligned>();
+
+    // test non corner cases as well while we're at it
+    struct Foo { int i; char c; };
+    check_alignment.operator()<int>();
+    check_alignment.operator()<Foo>();
+  }
+
+  // Make sure that we destroy all the elements constructed so far when an exception
+  // is thrown. Also make sure that we do it in reverse order of construction.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    struct Sentinel : ThrowOnConstruction, DestroyInReverseOrder { };
+
+    // Without passing an initial value
+    {
+      using Array = Sentinel[8];
+      for (int i = 0; i < 8; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>();
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[8][3];
+      for (int i = 0; i < 8 * 3; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>();
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[8][3][2];
+      for (int i = 0; i < 8 * 3 * 2; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>();
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = Sentinel[8];
+      for (int i = 0; i < 8; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init;
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 1);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[8][3];
+      for (int i = 0; i < 8 * 3; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init[3] = {};
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 3);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[8][3][2];
+      for (int i = 0; i < 8 * 3 * 2; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init[3][2] = {};
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 3 * 2);
+        }
+      }
+    }
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // Make sure the version without an initialization argument works even for non-movable types
+  {
+    using Array = NonMovable[8][3];
+    std::shared_ptr<Array> ptr = std::make_shared<Array>();
+    (void)ptr;
+  }
+
+  // Make sure std::make_shared handles badly-behaved types properly
+  {
+    using Array = operator_hijacker[3];
+    std::shared_ptr<Array> p1 = std::make_shared<Array>();
+    std::shared_ptr<Array> p2 = std::make_shared<Array>(operator_hijacker());
+    assert(p1 != nullptr);
+    assert(p2 != nullptr);
+  }
+
+  // Check that we SFINAE-away for invalid arguments
+  {
+    struct T { };
+    static_assert( CanMakeShared<T[8]>);
+    static_assert( CanMakeShared<T[8], T>);
+    static_assert(!CanMakeShared<T[8], T, int>); // too many arguments
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.array.unbounded.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
+
+// Aligned deallocation isn't provided before macOS 10.14, and some tests for overaligned types
+// below require that feature.
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13}}
+
+// <memory>
+
+// shared_ptr
+
+// template<class T> shared_ptr<T> make_shared(size_t N); // T is U[]
+//
+// template<class T>
+// shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[]
+
+// Ignore error about requesting a large alignment not being ABI compatible with older AIX systems.
+#ifdef _AIX
+# pragma clang diagnostic ignored "-Waix-compat"
+#endif
+
+#include <cassert>
+#include <concepts>
+#include <cstdint> // std::uintptr_t
+#include <memory>
+#include <utility>
+
+#include "operator_hijacker.h"
+#include "test_macros.h"
+#include "types.h"
+
+template <class T, class ...Args>
+concept CanMakeShared = requires(Args&& ...args) {
+  { std::make_shared<T>(std::forward<Args>(args)...) } -> std::same_as<std::shared_ptr<T>>;
+};
+
+int main(int, char**) {
+  // Check behavior for a zero-sized array
+  {
+    // Without passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(0);
+      assert(ptr != nullptr);
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(0, 42);
+      assert(ptr != nullptr);
+    }
+  }
+
+  // Check behavior for a 1-sized array
+  {
+    // Without passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(1);
+      assert(ptr != nullptr);
+      assert(ptr[0] == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(1, 42);
+      assert(ptr != nullptr);
+      assert(ptr[0] == 42);
+    }
+  }
+
+  // Make sure we initialize elements correctly
+  {
+    // Without passing an initial value
+    {
+      using Array = int[];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i] == 0);
+      }
+    }
+    {
+      using Array = int[][3];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 0);
+        assert(ptr[i][1] == 0);
+        assert(ptr[i][2] == 0);
+      }
+    }
+    {
+      using Array = int[][3][2];
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0][0] == 0);
+        assert(ptr[i][0][1] == 0);
+        assert(ptr[i][1][0] == 0);
+        assert(ptr[i][1][1] == 0);
+        assert(ptr[i][2][0] == 0);
+        assert(ptr[i][2][1] == 0);
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = int[];
+      int init = 42;
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i] == init);
+      }
+    }
+    {
+      using Array = int[][3];
+      int init[3] = {42, 43, 44};
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0] == 42);
+        assert(ptr[i][1] == 43);
+        assert(ptr[i][2] == 44);
+      }
+    }
+    {
+      using Array = int[][3][2];
+      int init[3][2] = {{31, 32}, {41, 42}, {51, 52}};
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+      for (unsigned i = 0; i < 8; ++i) {
+        assert(ptr[i][0][0] == 31);
+        assert(ptr[i][0][1] == 32);
+        assert(ptr[i][1][0] == 41);
+        assert(ptr[i][1][1] == 42);
+        assert(ptr[i][2][0] == 51);
+        assert(ptr[i][2][1] == 52);
+      }
+    }
+  }
+
+  // Make sure array elements are destroyed in reverse order
+  {
+    // Without passing an initial value
+    {
+      using Array = DestroyInReverseOrder[];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+        assert(DestroyInReverseOrder::alive() == 8);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+    {
+      using Array = DestroyInReverseOrder[][3];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+        assert(DestroyInReverseOrder::alive() == 8 * 3);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+    {
+      using Array = DestroyInReverseOrder[][3][2];
+      DestroyInReverseOrder::reset();
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+        assert(DestroyInReverseOrder::alive() == 8 * 3 * 2);
+      }
+      assert(DestroyInReverseOrder::alive() == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = DestroyInReverseOrder[];
+      int count = 0;
+      DestroyInReverseOrder init(&count);
+      int init_count = 1;
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+        assert(count == 8 + init_count);
+      }
+      assert(count == init_count);
+    }
+    {
+      using Array = DestroyInReverseOrder[][3];
+      int count = 0;
+      DestroyInReverseOrder init[3] = {&count, &count, &count};
+      int init_count = 3;
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+        assert(count == 8 * 3 + init_count);
+      }
+      assert(count == init_count);
+    }
+    {
+      using Array = DestroyInReverseOrder[][3][2];
+      int count = 0;
+      DestroyInReverseOrder init[3][2] = {{&count, &count}, {&count, &count}, {&count, &count}};
+      int init_count = 3 * 2;
+      {
+        std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+        assert(count == 8 * 3 * 2 + init_count);
+      }
+      assert(count == init_count);
+    }
+  }
+
+  // Count the number of copies being made
+  {
+    // Without passing an initial value
+    {
+      using Array = CountCopies[];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+      assert(CountCopies::copies() == 0);
+    }
+    {
+      using Array = CountCopies[][3];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+      assert(CountCopies::copies() == 0);
+    }
+    {
+      using Array = CountCopies[][3][2];
+      CountCopies::reset();
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+      assert(CountCopies::copies() == 0);
+    }
+
+    // Passing an initial value
+    {
+      using Array = CountCopies[];
+      int copies = 0;
+      CountCopies init(&copies);
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+      assert(copies == 8);
+    }
+    {
+      using Array = CountCopies[][3];
+      int copies = 0;
+      CountCopies init[3] = {&copies, &copies, &copies};
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+      assert(copies == 8 * 3);
+    }
+    {
+      using Array = CountCopies[][3][2];
+      int copies = 0;
+      CountCopies init[3][2] = {{&copies, &copies}, {&copies, &copies}, {&copies, &copies}};
+      std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+      assert(copies == 8 * 3 * 2);
+    }
+  }
+
+  // Make sure array elements are aligned properly when the array contains an overaligned type.
+  //
+  // Here, we don't need to test both the with-initial-value and without-initial-value code paths,
+  // since we're just checking the alignment and both are going to use the same code path unless
+  // the implementation is completely crazy.
+  {
+    auto check_alignment = []<class T> {
+      {
+        using Array = T[];
+        std::shared_ptr ptr = std::make_shared<Array>(8);
+        for (int i = 0; i < 8; ++i) {
+          T* p = std::addressof(ptr[i]);
+          assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+        }
+      }
+      {
+        using Array = T[][3];
+        std::shared_ptr ptr = std::make_shared<Array>(8);
+        for (int i = 0; i < 8; ++i) {
+          for (int j = 0; j < 3; ++j) {
+            T* p = std::addressof(ptr[i][j]);
+            assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+          }
+        }
+      }
+      {
+        using Array = T[][3][2];
+        std::shared_ptr ptr = std::make_shared<Array>(8);
+        for (int i = 0; i < 8; ++i) {
+          for (int j = 0; j < 3; ++j) {
+            for (int k = 0; k < 2; ++k) {
+              T* p = std::addressof(ptr[i][j][k]);
+              assert(reinterpret_cast<std::uintptr_t>(p) % alignof(T) == 0);
+            }
+          }
+        }
+      }
+    };
+
+    struct Empty { };
+    check_alignment.operator()<Empty>();
+    check_alignment.operator()<OverAligned>();
+    check_alignment.operator()<MaxAligned>();
+
+    // test non corner cases as well while we're at it
+    struct Foo { int i; char c; };
+    check_alignment.operator()<int>();
+    check_alignment.operator()<Foo>();
+  }
+
+  // Make sure that we destroy all the elements constructed so far when an exception
+  // is thrown. Also make sure that we do it in reverse order of construction.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    struct Sentinel : ThrowOnConstruction, DestroyInReverseOrder { };
+
+    // Without passing an initial value
+    {
+      using Array = Sentinel[];
+      for (int i = 0; i < 8; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[][3];
+      for (int i = 0; i < 8 * 3; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[][3][2];
+      for (int i = 0; i < 8 * 3 * 2; ++i) {
+        ThrowOnConstruction::throw_after(i);
+        DestroyInReverseOrder::reset();
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 0);
+        }
+      }
+    }
+
+    // Passing an initial value
+    {
+      using Array = Sentinel[];
+      for (int i = 0; i < 8; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init;
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 1);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[][3];
+      for (int i = 0; i < 8 * 3; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init[3] = {};
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 3);
+        }
+      }
+    }
+    {
+      using Array = Sentinel[][3][2];
+      for (int i = 0; i < 8 * 3 * 2; ++i) {
+        DestroyInReverseOrder::reset();
+        ThrowOnConstruction::reset();
+        Sentinel init[3][2] = {};
+        ThrowOnConstruction::throw_after(i);
+        try {
+          std::shared_ptr<Array> ptr = std::make_shared<Array>(8, init);
+          assert(false);
+        } catch (ThrowOnConstruction::exception const&) {
+          assert(DestroyInReverseOrder::alive() == 3 * 2);
+        }
+      }
+    }
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // Make sure the version without an initialization argument works even for non-movable types
+  {
+    using Array = NonMovable[][3];
+    std::shared_ptr<Array> ptr = std::make_shared<Array>(8);
+    (void)ptr;
+  }
+
+    // Make sure std::make_shared handles badly-behaved types properly
+    {
+      using Array = operator_hijacker[];
+      std::shared_ptr<Array> p1 = std::make_shared<Array>(3);
+      std::shared_ptr<Array> p2 = std::make_shared<Array>(3, operator_hijacker());
+      assert(p1 != nullptr);
+      assert(p2 != nullptr);
+    }
+
+  // Check that we SFINAE-away for invalid arguments
+  {
+    struct T { };
+    static_assert( CanMakeShared<T[], std::size_t>);
+    static_assert( CanMakeShared<T[], std::size_t, T>);
+    static_assert(!CanMakeShared<T[], std::size_t, T, int>); // too many arguments
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 
-// template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
+// template<class T, class... Args>
+// shared_ptr<T> make_shared(Args&&... args); // T is not an array
 
 #include <memory>
 #include <cassert>
 
-#include "test_macros.h"
 #include "count_new.h"
+#include "operator_hijacker.h"
+#include "test_macros.h"
 
 struct A
 {
     static int count;
 
     A(int i, char c) : int_(i), char_(c) {++count;}
     A(const A& a)
         : int_(a.int_), char_(a.char_)
#if TEST_STD_VER >= 11
     assert(globalMemCounter.checkOutstandingNewEq(nc+1));
     assert(A::count == 1);
     assert(p->get_int() == 67);
     assert(p->get_char() == 'e');
     }
 #endif
     assert(A::count == 0);
 
+    // Make sure std::make_shared handles badly-behaved types properly
+    {
+      std::shared_ptr<operator_hijacker> p1 = std::make_shared<operator_hijacker>();
+      std::shared_ptr<operator_hijacker> p2 = std::make_shared<operator_hijacker>(operator_hijacker());
+      assert(p1 != nullptr);
+      assert(p2 != nullptr);
+    }
+
     test<bool>(true);
     test<int>(3);
     test<double>(5.0);
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.compile.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 
-// template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
+// template<class T, class... Args>
+// shared_ptr<T> make_shared(Args&&... args);
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct S {
 private:

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/types.h

+//===----------------------------------------------------------------------===//
+//
+// 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 TEST_STD_UTILITIES_MEMORY_UTIL_SMARTPTR_SHARED_CREATE_TYPES_H
+#define TEST_STD_UTILITIES_MEMORY_UTIL_SMARTPTR_SHARED_CREATE_TYPES_H
+
+#include <cassert>
+#include <cstddef>
+
+#include "test_macros.h"
+
+struct DestroyInReverseOrder {
+  static void reset() { global_count_ = 0; }
+  static int alive() { return global_count_; }
+
+  DestroyInReverseOrder()
+    : DestroyInReverseOrder(&global_count_)
+  { }
+
+  constexpr DestroyInReverseOrder(int* count)
+    : count_(count), value_(*count)
+  { ++*count_; }
+
+  constexpr DestroyInReverseOrder(DestroyInReverseOrder const& other)
+    : count_(other.count_), value_(*other.count_)
+  { ++*count_; }
+
+  constexpr int value() const { return value_; }
+
+  // Ensure that we destroy these objects in the reverse order as they were created.
+  constexpr ~DestroyInReverseOrder() {
+    --*count_;
+    assert(*count_ == value_);
+  }
+
+private:
+  int* count_;
+  int value_;
+  static int global_count_;
+};
+
+int DestroyInReverseOrder::global_count_ = 0;
+
+struct NonMovable {
+  NonMovable() = default;
+  NonMovable(NonMovable&&) = delete;
+};
+
+struct CountCopies {
+  static void reset() { global_count_ = 0; }
+  static int copies() { return global_count_; }
+
+  constexpr CountCopies() : copies_(&global_count_) { }
+  constexpr CountCopies(int* counter) : copies_(counter) { }
+  constexpr CountCopies(CountCopies const& other) : copies_(other.copies_) { ++*copies_; }
+
+private:
+  int* copies_;
+  static int global_count_;
+};
+
+int CountCopies::global_count_ = 0;
+
+struct alignas(alignof(std::max_align_t) * 2) OverAligned { };
+
+struct MaxAligned {
+  std::max_align_t foo;
+};
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+struct ThrowOnConstruction {
+  struct exception : std::exception { };
+
+  ThrowOnConstruction() { on_construct(); }
+  ThrowOnConstruction(ThrowOnConstruction const&) { on_construct(); }
+
+  static void reset() { throw_after_ = -1; }
+  static void throw_after(int n) { throw_after_ = n; }
+
+private:
+  static int throw_after_;
+  void on_construct() {
+    if (throw_after_ == 0)
+      throw exception{};
+
+    if (throw_after_ != -1)
+      --throw_after_;
+  }
+};
+
+int ThrowOnConstruction::throw_after_ = -1;
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+#endif // TEST_STD_UTILITIES_MEMORY_UTIL_SMARTPTR_SHARED_CREATE_TYPES_H

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_enable_shared_from_this",
     "values": { "c++17": 201603 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_endian",
     "values": { "c++20": 201907 },
     "headers": ["bit"],
   }, {
     "name": "__cpp_lib_erase_if",
     "values": { "c++20": 202002 },
     "headers": ["deque", "forward_list", "list", "map", "set", "string", "unordered_map", "unordered_set", "vector"],
   }, {
     "name": "__cpp_lib_exchange_function",
     "values": { "c++14": 201304 },
     "headers": ["utility"],
   }, {
     "name": "__cpp_lib_execution",
feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_shared_mutex",
     "values": { "c++17": 201505 },
     "headers": ["shared_mutex"],
     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)",
   }, {
     "name": "__cpp_lib_shared_ptr_arrays",
-    "values": { "c++17": 201611 },
+    "values": { "c++17": 201611, "c++20": 201707 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_shared_ptr_weak_type",
     "values": { "c++17": 201606 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_shared_timed_mutex",
     "values": { "c++14": 201402 },