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> >;
@@ -5667,6 +5685,109 @@
        typename __void_t<decltype(_VSTD::declval<_Alloc&>().allocate(size_t(0)))>::type
      >
    : 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 _Un, class _Alloc, class... _Args>
+auto
+__uses_allocator_construction_args_no_pair(false_type, _Un, 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_no_pair(true_type, true_type, 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_no_pair(false_type, false_type, const _Alloc __alloc, _Args&&... __args) {
+	return _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)..., __alloc);
+}
+
+template<class _Tp, class _Alloc, class... _Args,
+	typename = enable_if_t<!__is_pair<_Tp>::value>>
+auto
+uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args) {
+	return __uses_allocator_construction_args_no_pair<_Tp>(
+		_VSTD::uses_allocator<_Tp, _Alloc>(),
+		_VSTD::is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>(),
+		__alloc, _VSTD::forward<_Args>(__args)...);
+}
+	
+template<class _Tp, class _Alloc, class _T1, class _T2,
+	typename = enable_if_t<__is_pair<_Tp>::value>>
+auto
+uses_allocator_construction_args(const _Alloc& __alloc,
+								 piecewise_construct_t,
+								 _T1&& __a, _T2&& __b) {
+	return std::make_tuple(piecewise_construct,
+						   _VSTD::apply( [&__alloc](auto&&... __args) {
+		return _VSTD::uses_allocator_construction_args<_T1>(__alloc, _VSTD::forward<decltype(__args)>(__args)...);
+	}, _VSTD::forward<_T1>(__a)),
+						   _VSTD::apply( [&__alloc](auto&&... __args) {
+		return _VSTD::uses_allocator_construction_args<_T2>(__alloc, _VSTD::forward<decltype(__args)>(__args)...);
+	}, _VSTD::forward<_T2>(__b)));
+}
+
+template<class _Tp, class _Alloc,
+	typename = enable_if_t<__is_pair<_Tp>::value>>
+auto
+uses_allocator_construction_args(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,
+	typename = enable_if_t<__is_pair<_Tp>::value>>
+auto
+uses_allocator_construction_args(const _Alloc& __alloc, _T1&& __a, _T2&& __b) {
+	return uses_allocator_construction_args<_Tp>(
+		__alloc, piecewise_construct,
+		_VSTD::forward_as_tuple(_VSTD::forward<_T1>(__a)),
+		_VSTD::forward_as_tuple(_VSTD::forward<_T2>(__b)));
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2,
+	typename = enable_if_t<__is_pair<_Tp>::value>>
+auto
+uses_allocator_construction_args(const _Alloc& __alloc, const _VSTD::pair<_T1, _T2>& __p) {
+	return uses_allocator_construction_args<_Tp>(__alloc, piecewise_construct,
+		forward_as_tuple(__p.first),
+		forward_as_tuple(__p.second));
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2,
+	typename = enable_if_t<__is_pair<_Tp>::value>>
+auto
+uses_allocator_construction_args(const _Alloc& __alloc, _VSTD::pair<_T1, _T2>&& __p) {
+	return uses_allocator_construction_args<_Tp>(__alloc,
+		piecewise_construct,
+		forward_as_tuple(_VSTD::move(__p).first),
+		forward_as_tuple(_VSTD::move(__p).first));
+}
+
+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
 
Index: test/std/utilities/memory/uses_allocator_construction_args.pass.cpp
===================================================================
--- /dev/null
+++ test/std/utilities/memory/uses_allocator_construction_args.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+using pair_t = std::pair<int, double>;
+
+struct A
+{
+	int a;
+	float b;
+
+	A(int a, float b): a(a), b(b) { }
+};
+
+template <class... Args>
+void test_pair (Args&&... args)
+{
+	auto args_tuple = std::uses_allocator_construction_args<pair_t>(std::forward<Args>(args)...);
+	auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+	assert(arg_count == 3);
+}
+
+int main(int, char**)
+{
+	// non pair contruction
+	std::allocator<A> alloc;
+	auto a = std::make_obj_using_allocator<A>(alloc, 10, 5.0);
+
+	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(b->a == 20);
+	assert(b->b == 10.0);
+	
+	assert(&a == b);
+	
+	// pair construction
+	std::allocator<pair_t> p_alloc;
+	pair_t p { 10, 5.0 };
+	
+	test_pair(p_alloc);
+	test_pair(p_alloc, 10, 5.0);
+	test_pair(p_alloc, p);
+
+	return 0;
+}