Index: include/memory
===================================================================
--- include/memory
+++ include/memory
@@ -626,6 +626,24 @@
     atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
                                             shared_ptr<T> w, memory_order success,
                                             memory_order failure);
+
+template <class T, class Alloc, class... Args>
+    auto uses_allocator_construction_args(const Alloc& alloc, Args&&... args);
+template <class T, class Alloc, class Tuple1, class Tuple2>
+    auto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t, Tuple1&& x, Tuple2&& y);
+template <class T>
+    auto uses_allocator_construction_args(const Alloc& alloc);
+template <class T, class Alloc, class U, class V>
+    auto uses_allocator_construction_args(const Alloc& alloc, U&& u, V&& v);
+template <class T, class Alloc, class U, class V>
+    auto uses_allocator_construction_args(const Alloc& alloc, const pair<U,V>& pr);
+template <class T, class Alloc, class U, class V>
+    auto uses_allocator_construction_args(const Alloc& alloc, pair<U,V>&& pr);
+template <class T, class Alloc, class... Args>
+    T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
+template <class T, class Alloc, class... Args>
+    T* uninitialized_construct_using_allocator(T* p, const Alloc& alloc, Args&&... args);
+
 // Hash support
 template <class T> struct hash;
 template <class T, class D> struct hash<unique_ptr<T, D> >;
@@ -5668,6 +5686,149 @@
      >
    : true_type {};
 
+#if _LIBCPP_STD_VER > 17
+
+template <class _Tp> struct __is_pair : false_type { };
+
+template <class _T1, class _T2>
+struct __is_pair<pair<_T1, _T2>> : true_type { };
+
+template<class _Tp, class _Alloc>
+struct __pair_uses_allocator : _VSTD::uses_allocator<_Tp, _Alloc> {};
+
+template<class _T1, class _T2, class _Alloc>
+struct __pair_uses_allocator<_VSTD::pair<_T1, _T2>, _Alloc>
+    : _VSTD::integral_constant<bool,
+                               __pair_uses_allocator<_T1, _Alloc>::value ||
+                               __pair_uses_allocator<_T2, _Alloc>::value> {};
+
+template<class _Tp, class _Alloc, class... _Args>
+auto uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args); // this needs to be forward declared for some __uses_allocator_construction_args_impl overloads
+
+template<class _Tp, class _Un1, class _Un2, class _Alloc, class... _Args>
+auto
+__uses_allocator_construction_args_impl(_Un1, // is pair
+                                        false_type, // uses allocator
+                                        _Un2,        // is constructible
+                                        const _Alloc&, _Args&&... __args)
+{
+    return _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...);
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+auto
+__uses_allocator_construction_args_impl(false_type, // is pair
+                                        true_type,  // uses allocator
+                                        true_type,  // is constructible
+                                        const _Alloc& __alloc, _Args&&... __args)
+{
+    return _VSTD::forward_as_tuple(allocator_arg, __alloc, _VSTD::forward<_Args>(__args)...);
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+auto
+ __uses_allocator_construction_args_impl(false_type, // is pair
+                                         true_type,  // uses allocator
+                                         false_type, // is constructible
+                                         const _Alloc& __alloc, _Args&&... __args)
+{
+    return _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)..., __alloc);
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        false_type, // is constructible
+                                        const _Alloc& __alloc,
+                                        piecewise_construct_t,
+                                        _T1&& __a, _T2&& __b)
+{
+    using _First = typename _Tp::first_type;
+    using _Second = typename _Tp::second_type;
+
+    return _VSTD::make_tuple(_VSTD::piecewise_construct,
+                             _VSTD::apply([&__alloc](auto&&... __args_a) -> auto {
+                                return uses_allocator_construction_args<_First>(__alloc,
+                                                                                _VSTD::forward<decltype(__args_a)>(__args_a)...);
+                             }, _VSTD::forward<_T1>(__a)),
+                             _VSTD::apply([&__alloc](auto&&... __args_b) -> auto {
+                                return uses_allocator_construction_args<_Second>(__alloc,
+                                                                                 _VSTD::forward<decltype(__args_b)>(__args_b)...);
+                             }, _VSTD::forward<_T2>(__b)));
+}
+
+template<class _Tp, class _Alloc>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        false_type, // is constructible
+                                        const _Alloc& __alloc)
+{
+    return uses_allocator_construction_args<_Tp>(__alloc,
+                                                 piecewise_construct,
+                                                 _VSTD::tuple<>{},
+                                                 _VSTD::tuple<>{});
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        false_type, // is constructible
+                                        const _Alloc& __alloc,
+                                        const _VSTD::pair<_T1, _T2>& __p)
+{
+    return uses_allocator_construction_args<_Tp>(__alloc,
+                                                 piecewise_construct,
+                                                 _VSTD::forward_as_tuple(__p.first),
+                                                 _VSTD::forward_as_tuple(__p.second));
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        false_type, // is constructible
+                                        const _Alloc& __alloc,
+                                        _VSTD::pair<_T1, _T2>&& __p)
+{
+    return uses_allocator_construction_args<_Tp>(__alloc,
+                                                 piecewise_construct,
+                                                 _VSTD::forward_as_tuple(_VSTD::forward<_T1>(__p.first)),
+                                                 _VSTD::forward_as_tuple(_VSTD::forward<_T2>(__p.second)));
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+auto
+uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args)
+{
+    return __uses_allocator_construction_args_impl<_Tp>(
+        __is_pair<_Tp>{}, // TODO: vstd::is_pair
+        __pair_uses_allocator<_Tp, _Alloc>{},
+        _VSTD::is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>{},
+        __alloc,
+        _VSTD::forward<_Args>(__args)...);
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+_Tp
+make_obj_using_allocator(const _Alloc& __alloc, _Args&&... __args)
+{
+    return make_from_tuple<_Tp>(uses_allocator_construction_args<_Tp>(__alloc,
+                                                                      _VSTD::forward<_Args>(__args)...));
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+_Tp*
+uninitialized_construct_using_allocator(_Tp* __p, const _Alloc& __alloc, _Args&&... __args)
+{
+    return ::new(static_cast<void*>(__p)) _Tp(make_obj_using_allocator<_Tp>(__alloc,
+                                                                            _VSTD::forward<_Args>(__args)...));
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
Index: include/tuple
===================================================================
--- include/tuple
+++ include/tuple
@@ -1374,7 +1374,7 @@
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
 _LIBCPP_NOEXCEPT_RETURN(
-    _Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
+    _Tp(_VSTD::move(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t)))...)
 )
 
 template <class _Tp, class _Tuple>
Index: test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
===================================================================
--- /dev/null
+++ test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
@@ -0,0 +1,306 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+#include <memory>
+#include <utility>
+#include <cassert>
+#include <iostream>
+
+#include "test_macros.h"
+
+struct A
+{
+    int a;
+    float b;
+
+    A(int a, float b) : a(a), b(b) { }
+};
+
+struct B : A
+{
+    using allocator_type = std::allocator<B>;
+    B(std::allocator_arg_t, std::allocator<B>, int a, int b) : A(a, b) { }
+};
+
+struct C : A
+{
+    using allocator_type = std::allocator<C>;
+    C(int a, int b, std::allocator<C>) : A(a, b) { }
+};
+
+struct D
+{
+    using allocator_type = std::allocator<D>;
+};
+
+struct E
+{
+    using allocator_type = std::allocator<E>;
+
+    int i;
+
+    E(std::allocator_arg_t, std::allocator<B>, int i) : i(i) { }
+};
+
+template <class T, class... Args>
+T test_uses_alloc(Args&&... args)
+{
+    auto args_tuple = std::uses_allocator_construction_args<T>(std::forward<Args>(args)...);
+    const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+    static_assert(arg_count == sizeof...(Args) - 1);
+
+    return std::make_from_tuple<T>(args_tuple);
+}
+
+void general_tests()
+{
+    using pair_t = std::pair<int, int>;
+
+    // non pair contruction
+    std::allocator<A> alloc;
+    auto a = std::make_obj_using_allocator<A>(alloc, 10, 5.0);
+
+    ASSERT_SAME_TYPE(decltype(a), A);
+    assert(a.a == 10);
+    assert(a.b == 5.0);
+
+    auto* b = std::uninitialized_construct_using_allocator(&a, alloc, 20, 10.0);
+
+    assert(a.a == 20);
+    assert(a.b == 10.0);
+
+    ASSERT_SAME_TYPE(decltype(b), A*);
+    assert(b->a == 20);
+    assert(b->b == 10.0);
+
+    assert(&a == b);
+
+    // pair construction
+    std::allocator<pair_t> p_alloc;
+    pair_t p { 10, 5 };
+
+    test_uses_alloc<pair_t>(p_alloc);
+    auto res = test_uses_alloc<pair_t>(p_alloc, 10, 5);
+    auto res1 = test_uses_alloc<pair_t>(p_alloc, p);
+    assert(res.first == res1.first &&
+           res.second == res1.second &&
+           res.first == 10 &&
+           res.second == 5);
+
+    auto res2 = test_uses_alloc<A>(std::allocator<A>(), 10, 10.0);
+    assert(res2.a == res2.b && res2.a == 10);
+}
+
+void test_no_allocator()
+{
+    auto args_tuple = std::uses_allocator_construction_args<A>(std::allocator<void>{}, 10, 5.0);
+    const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+    static_assert(arg_count == 2);
+
+    assert(std::get<0>(args_tuple) == 10);
+    assert(std::get<1>(args_tuple) == 5.0);
+
+    auto a = std::make_from_tuple<A>(args_tuple);
+    assert(a.a == 10);
+    assert(a.b == 5.0);
+}
+
+void test_no_pair()
+{
+    { // make sure we are calling the correct overload
+        static_assert(!std::uses_allocator<A, std::allocator<A>>::value);
+        static_assert(!std::is_constructible<A, std::allocator_arg_t, std::allocator<A>, int, int>::value);
+        static_assert( std::is_constructible<A, int, int>::value);
+        static_assert( std::uses_allocator<B, std::allocator<B>>::value);
+        static_assert( std::is_constructible<B, std::allocator_arg_t, std::allocator<B>, int, int>::value);
+        static_assert( std::uses_allocator<C, std::allocator<C>>::value);
+        static_assert( std::is_constructible<C, int, int, std::allocator<C>>::value); // TODO: should this be checked?
+    }
+    {
+        auto args_tuple = std::uses_allocator_construction_args<B>(std::allocator<B>{}, 10, 5.0);
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        static_assert(arg_count == 4);
+
+        assert(std::get<2>(args_tuple) == 10);
+        assert(std::get<3>(args_tuple) == 5.0);
+
+        auto b = std::make_from_tuple<B>(args_tuple);
+        assert(b.a == 10);
+        assert(b.b == 5.0);
+    }
+    {
+        auto args_tuple = std::uses_allocator_construction_args<C>(std::allocator<C>{}, 10, 5.0);
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        static_assert(arg_count == 3);
+
+        assert(std::get<0>(args_tuple) == 10);
+        assert(std::get<1>(args_tuple) == 5.0);
+
+        auto c = std::make_from_tuple<C>(args_tuple);
+        assert(c.a == 10);
+        assert(c.b == 5.0);
+    }
+}
+
+void test_pair()
+{
+    using pair_t = std::pair<B, B>;
+
+    {
+        auto args_tuple = std::uses_allocator_construction_args<pair_t>(std::allocator<B>{},
+                                                                        std::piecewise_construct,
+                                                                        std::make_tuple(10, 5),
+                                                                        std::make_tuple(4, 2));
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 4);
+        static_assert(arg_count2 == 4);
+
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(args_tuple)), decltype(std::piecewise_construct));
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator_arg_t);
+        // ASSERT_SAME_TYPE(decltype(std::get<1>(std::get<1>(args_tuple))), std::allocator<B>);
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator_arg_t);
+        // ASSERT_SAME_TYPE(decltype(std::get<1>(std::get<2>(args_tuple))), std::allocator<B>);
+
+        assert(std::get<2>(std::get<1>(args_tuple)) == 10);
+        assert(std::get<3>(std::get<1>(args_tuple)) == 5);
+        assert(std::get<2>(std::get<2>(args_tuple)) == 4);
+        assert(std::get<3>(std::get<2>(args_tuple)) == 2);
+
+        auto p = std::make_from_tuple<pair_t>(args_tuple);
+        assert(p.first.a == 10);
+        assert(p.first.b == 5);
+        assert(p.second.a == 4);
+        assert(p.second.b == 2);
+    }
+    {
+        auto args_tuple = std::uses_allocator_construction_args<pair_t>(std::allocator<B>{});
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 1);
+        static_assert(arg_count2 == 1);
+
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(args_tuple)), decltype(std::piecewise_construct));
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator_arg_t);
+        // ASSERT_SAME_TYPE(decltype(std::get<1>(std::get<1>(args_tuple))), std::allocator<D>);
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator_arg_t);
+        // ASSERT_SAME_TYPE(decltype(std::get<1>(std::get<2>(args_tuple))), std::allocator<D>);
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        auto args_pair = std::make_pair(10, 5);
+        auto args_tuple = std::uses_allocator_construction_args<pair_e>(std::allocator<E>{},
+                                                                        args_pair);
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 3);
+        static_assert(arg_count2 == 3);
+
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(args_tuple)), decltype(std::piecewise_construct));
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator_arg_t);
+        // ASSERT_SAME_TYPE(decltype(std::get<1>(std::get<1>(args_tuple))), std::allocator<B>);
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator_arg_t);
+        // ASSERT_SAME_TYPE(decltype(std::get<1>(std::get<2>(args_tuple))), std::allocator<B>);
+
+        assert(std::get<2>(std::get<1>(args_tuple)) == 10);
+        assert(std::get<2>(std::get<2>(args_tuple)) == 5);
+
+        auto p = std::make_from_tuple<pair_e>(args_tuple);
+        assert(p.first.i == 10);
+        assert(p.second.i == 5);
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        auto args_pair = std::make_pair(10, 5);
+        auto args_tuple = std::uses_allocator_construction_args<pair_e>(std::allocator<E>{},
+                                                                        std::move(args_pair));
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 3);
+        static_assert(arg_count2 == 3);
+
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(args_tuple)), decltype(std::piecewise_construct));
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator_arg_t);
+        // ASSERT_SAME_TYPE(decltype(std::get<1>(std::get<1>(args_tuple))), std::allocator<B>);
+        // ASSERT_SAME_TYPE(decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator_arg_t);
+        // ASSERT_SAME_TYPE(decltype(std::get<1>(std::get<2>(args_tuple))), std::allocator<B>);
+
+        assert(std::get<2>(std::get<1>(args_tuple)) == 10);
+        assert(std::get<2>(std::get<2>(args_tuple)) == 5);
+
+        auto p = std::make_from_tuple<pair_e>(args_tuple);
+        assert(p.first.i == 10);
+        assert(p.second.i == 5);
+    }
+}
+
+void test_make_obj()
+{
+    using pair_t = std::pair<B, B>;
+
+    {
+        pair_t p = std::make_obj_using_allocator<pair_t>(std::allocator<B>{},
+                                                         std::piecewise_construct,
+                                                         std::make_tuple(10, 5),
+                                                         std::make_tuple(4, 2));
+        assert(p.first.a == 10);
+        assert(p.first.b == 5);
+        assert(p.second.a == 4);
+        assert(p.second.b == 2);
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        auto args_pair = std::make_pair(10, 5);
+        auto p = std::make_obj_using_allocator<pair_e>(std::allocator<E>{}, args_pair);
+
+        assert(p.first.i == 10);
+        assert(p.second.i == 5);
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        auto args_pair = std::make_pair(10, 5);
+        auto p = std::make_obj_using_allocator<pair_e>(std::allocator<E>{},
+                                                       std::move(args_pair));
+
+        assert(p.first.i == 10);
+        assert(p.second.i == 5);
+    }
+    {
+        auto b = std::make_obj_using_allocator<B>(std::allocator<B>{}, 10, 5.0);
+
+        assert(b.a == 10);
+        assert(b.b == 5.0);
+    }
+    {
+        auto c = std::make_obj_using_allocator<C>(std::allocator<C>{}, 10, 5.0);
+
+        assert(c.a == 10);
+        assert(c.b == 5.0);
+    }
+}
+
+int main(int, char**)
+{
+    general_tests();
+    test_no_allocator();
+    test_no_pair();
+    test_pair();
+    test_make_obj();
+
+    return 0;
+}