Index: include/experimental/memory
===================================================================
--- /dev/null
+++ include/experimental/memory
@@ -0,0 +1,201 @@
+// -*- C++ -*-
+//===-------------------------- algorithm ---------------------------------===//
+//
+// 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_EXPERIMENTAL_MEMORY
+#define _LIBCPP_EXPERIMENTAL_MEMORY
+
+/*
+namespace std {
+template <class W> class observer_ptr {
+public:
+    // publish our template parameter and variations thereof
+    using element_type = W;
+    using pointer = add_pointer_t<W>; // exposition-only
+    using reference = add_lvalue_reference_t<W>; // exposition-only
+
+    // default c’tor
+    constexpr observer_ptr() noexcept;
+
+    // pointer-accepting c’tors
+    constexpr observer_ptr(nullptr_t) noexcept;
+    constexpr explicit observer_ptr(pointer) noexcept;
+
+    // copying c’tors (in addition to compiler-generated copy c’tor)
+    template <class W2> constexpr observer_ptr(observer_ptr<W2>) noexcept;
+
+    // observers
+    constexpr pointer get() const noexcept;
+    constexpr reference operator*() const;
+    constexpr pointer operator->() const noexcept;
+    constexpr explicit operator bool() const noexcept;
+
+    // conversions
+    constexpr explicit operator pointer() const noexcept;
+
+    // modifiers
+    constexpr pointer release() noexcept;
+    constexpr void reset(pointer = nullptr) noexcept;
+    constexpr void swap(observer_ptr&) noexcept;
+};
+}
+*/
+
+#include <type_traits>
+#include <functional>
+
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCPP_BEGIN_NAMESPACE_STD // TODO: use _LIBCPP_BEGIN_NAMESPACE_LFTS?
+
+template<class _Wp>
+class observer_ptr
+{
+    typedef add_pointer_t<_Wp>          pointer;
+    typedef add_lvalue_reference_t<_Wp> reference;
+
+    pointer __ptr;
+
+public:
+    typedef _Wp                         element_type;
+
+    // constructors
+    constexpr observer_ptr() noexcept : __ptr(nullptr) { }
+    constexpr observer_ptr(nullptr_t) noexcept : __ptr(nullptr) { }
+    constexpr observer_ptr(pointer __p) noexcept : __ptr(__p) { }
+
+    template<class _W2,
+             class = enable_if_t<is_convertible<_W2*, _Wp*>::value>>
+    constexpr observer_ptr(observer_ptr<_W2> __other) noexcept
+        : __ptr(__other.get()) { }
+
+    observer_ptr(observer_ptr const&) = default;
+    observer_ptr(observer_ptr&&) = default;
+
+    // observers
+    constexpr pointer get() const noexcept { return __ptr; }
+    constexpr reference operator*() const { return *__ptr; }
+    constexpr pointer operator->() const noexcept { return __ptr; }
+    constexpr explicit operator bool() const noexcept { return __ptr != nullptr; }
+
+    // conversions
+    constexpr /*explicit*/ operator pointer() const noexcept { return __ptr; }
+
+    // modifiers
+    constexpr void swap(observer_ptr& __other) noexcept { _VSTD::swap(__ptr, __other.__ptr); }
+    constexpr void reset(pointer __p = nullptr) { __ptr = __p; }
+    constexpr pointer release() noexcept
+    {
+        observer_ptr __p;
+        __p.swap(*this);
+        return __p.get();
+    }
+};
+
+// specializations
+
+template<class _Wp>
+void swap(observer_ptr<_Wp>& __a, observer_ptr<_Wp>& __b)
+{
+    __a.swap(__b);
+}
+
+template<class _Wp>
+observer_ptr<_Wp> make_observer(_Wp* __ptr)
+{
+    return observer_ptr<_Wp>{__ptr};
+}
+
+template<class _W1, class _W2>
+bool operator==(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return __a.get() == __b.get();
+}
+
+template<class _W1, class _W2>
+bool operator!=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a == __b);
+}
+
+template<class _Wp>
+bool operator==(observer_ptr<_Wp> __p, nullptr_t)
+{
+    return !__p;
+}
+
+template<class _Wp>
+bool operator==(nullptr_t, observer_ptr<_Wp> __p)
+{
+    return !__p;
+}
+
+template<class _Wp>
+bool operator!=(observer_ptr<_Wp> __p, nullptr_t)
+{
+    return (bool)__p;
+}
+
+template<class _Wp>
+bool operator!=(nullptr_t, observer_ptr<_Wp> __p)
+{
+    return (bool)__p;
+}
+
+template<class _W1, class _W2>
+bool operator<(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return _VSTD::less<typename _VSTD::common_type<_W1*, _W2*>::type>()(__a.get(), __b.get());
+}
+
+template<class _W1, class _W2>
+bool operator>(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return __a < __b; // TODO: is this really correct?
+}
+
+template<class _W1, class _W2>
+bool operator<=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a > __b);
+}
+
+template<class _W1, class _W2>
+bool operator>=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a < __b);
+}
+
+// hash
+
+template<class _Tp>
+struct hash<observer_ptr<_Tp>>
+{
+    typedef observer_ptr<_Tp>    argument_type;
+    typedef size_t               result_type;
+
+    _LIBCPP_INLINE_VISIBILITY
+    result_type operator()(const argument_type& __ptr) const noexcept
+    {
+        return hash<_Tp*>()(__ptr.get());
+    }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif /* _LIBCPP_EXPERIMENTAL_MEMORY */
Index: test/std/experimental/memory/memory.observer.ptr/conv.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/conv.pass.cpp
@@ -0,0 +1,42 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+void test_convertibility()
+{
+    typedef std::observer_ptr<T> OP;
+    static_assert(std::is_convertible<OP, T*>::value, "");
+}
+
+struct Foo;
+
+struct Bar {};
+
+int main(int, char**)
+{
+    test_convertibility<void>();
+    test_convertibility<bool>();
+    test_convertibility<int>();
+    test_convertibility<Foo>();
+    test_convertibility<Bar>();
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/ctor.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/ctor.pass.cpp
@@ -0,0 +1,129 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+void custom_delete(T* ptr) { delete ptr; }
+void custom_delete(void* ptr) { delete (int*)ptr; }
+
+template<class T, class U>
+void assert_constructability()
+{
+    typedef std::observer_ptr<T> OP;
+    static_assert(std::is_nothrow_constructible<OP>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, std::nullptr_t>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, T*>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, OP const&>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, OP&&>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, std::observer_ptr<U>>::value ==
+                  std::is_convertible<U*, T*>::value, "");
+}
+
+template<class T>
+void constrct_nullptr()
+{
+    {
+        std::observer_ptr<T> ptr;
+        assert(ptr.get() == nullptr);
+    }
+    {
+        std::observer_ptr<T> ptr(nullptr);
+        assert(ptr.get() == nullptr);
+    }
+}
+
+template<class T>
+void constrct_ptr(T* raw_ptr)
+{
+    std::observer_ptr<T> ptr(raw_ptr);
+    assert(ptr.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+template<class T, class U>
+void constrct_other(U* raw_ptr)
+{
+    std::observer_ptr<U> uptr(raw_ptr);
+    std::observer_ptr<T> tptr(uptr);
+    assert(uptr.get() == raw_ptr);
+    assert(tptr.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+template<class T>
+void test_copy_move(T* raw_ptr)
+{
+    std::observer_ptr<T> ptr_a(raw_ptr);
+    std::observer_ptr<T> ptr_b(ptr_a);
+    std::observer_ptr<T> ptr_c(std::move(ptr_a));
+    assert(ptr_b.get() == raw_ptr);
+    assert(ptr_c.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+struct Foo;
+struct Bar
+{
+    Bar(int) {}
+};
+
+int main(int, char**)
+{
+    {
+        assert_constructability<void, void>();
+        assert_constructability<void, int>();
+        assert_constructability<void, Bar>();
+        assert_constructability<Foo,  void>();
+        assert_constructability<Foo,  int>();
+        assert_constructability<Foo,  Bar>();
+        assert_constructability<int,  void>();
+        assert_constructability<int,  int>();
+        assert_constructability<int,  Bar>();
+    }
+    {
+        constrct_nullptr<Foo>();
+        constrct_nullptr<Bar>();
+        constrct_nullptr<int>();
+        constrct_nullptr<void>();
+    }
+    {
+        constrct_ptr(new int);
+        constrct_ptr(new Bar(42));
+        constrct_ptr((void*)new int);
+    }
+    {
+        constrct_other<void>(new int);
+        constrct_other<void>(new Bar(42));
+
+        // overload resolution
+        typedef std::observer_ptr<int>  OP1;
+        typedef std::observer_ptr<Bar>  OP2;
+        typedef std::observer_ptr<char> OP3;
+        static_assert(!std::is_nothrow_constructible<OP1, OP2>::value, "");
+        static_assert(!std::is_nothrow_constructible<OP1, OP3>::value, "");
+    }
+    {
+        test_copy_move(new int);
+        test_copy_move((void*)new int);
+        test_copy_move(new Bar(42));
+    }
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/hash.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/hash.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <cassert>
+
+#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
+struct A {};
+
+int main(int, char**)
+{
+    {
+        int* ptr = new int;
+        std::observer_ptr<int> p(ptr);
+        std::hash<std::observer_ptr<int>> f;
+        std::size_t h = f(p);
+        assert(h == std::hash<int*>()(ptr));
+    }
+    {
+        test_hash_enabled_for_type<std::shared_ptr<int>>();
+        test_hash_enabled_for_type<std::shared_ptr<A>>();
+    }
+
+    return 0;
+}
Index: test/std/experimental/memory/memory.observer.ptr/mod/release.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/mod/release.pass.cpp
@@ -0,0 +1,38 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        std::observer_ptr<int> ptr;
+        assert(ptr.release() == nullptr);
+        assert(ptr.get() == nullptr);
+    }
+    {
+        int* raw_ptr = new int;
+        std::observer_ptr<int> ptr(raw_ptr);
+        assert(ptr.release() == raw_ptr);
+        assert(ptr.get() == nullptr);
+        delete raw_ptr;
+    }
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/mod/reset.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/mod/reset.pass.cpp
@@ -0,0 +1,42 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    int* raw_ptr1 = new int;
+    int* raw_ptr2 = new int;
+
+    {
+        std::observer_ptr<int> ptr;
+        ptr.reset(raw_ptr1);
+        assert(ptr.get() == raw_ptr1);
+    }
+    {
+        std::observer_ptr<int> ptr(raw_ptr1);
+        ptr.reset(raw_ptr2);
+        assert(ptr.get() == raw_ptr2);
+    }
+
+    delete raw_ptr1;
+    delete raw_ptr2;
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/mod/swap.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/mod/swap.pass.cpp
@@ -0,0 +1,60 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    int* raw_ptr1 = new int;
+    int* raw_ptr2 = new int;
+
+    {
+        std::observer_ptr<int> ptr1;
+        std::observer_ptr<int> ptr2;
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == nullptr);
+        assert(ptr2.get() == nullptr);
+    }
+    {
+        std::observer_ptr<int> ptr1(raw_ptr1);
+        std::observer_ptr<int> ptr2;
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == nullptr);
+        assert(ptr2.get() == raw_ptr1);
+    }
+    {
+        std::observer_ptr<int> ptr1;
+        std::observer_ptr<int> ptr2(raw_ptr2);
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == raw_ptr2);
+        assert(ptr2.get() == nullptr);
+    }
+    {
+        std::observer_ptr<int> ptr1(raw_ptr1);
+        std::observer_ptr<int> ptr2(raw_ptr2);
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == raw_ptr2);
+        assert(ptr2.get() == raw_ptr1);
+    }
+
+    delete raw_ptr1;
+    delete raw_ptr2;
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/obs.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/obs.pass.cpp
@@ -0,0 +1,53 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Foo {
+    int x;
+    Foo(int x) : x(x) {}
+};
+
+int main(int, char**)
+{
+    int* raw_ptr = new int;
+    {
+        std::observer_ptr<int> ptr(raw_ptr);
+        assert(ptr.get() == raw_ptr);
+    }
+    {
+        std::observer_ptr<int> ptr1;
+        bool check = ptr1;
+        assert(check == false);
+
+        std::observer_ptr<int> ptr2(raw_ptr);
+        check = ptr2;
+        assert(check == true);
+    }
+    {
+        Foo* foo_ptr = new Foo(42);
+        std::observer_ptr<Foo> ptr(foo_ptr);
+        assert(ptr->x == 42);
+        assert((*ptr).x == 42);
+
+    }
+    delete raw_ptr;
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/spec.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/spec.pass.cpp
@@ -0,0 +1,87 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        std::observer_ptr<int> ptr1(new int(42));
+        std::observer_ptr<int> ptr2(new int(101));
+        std::swap(ptr1, ptr2);
+
+        assert(*ptr1 == 101);
+        assert(*ptr2 == 42);
+
+        delete ptr1.get();
+        delete ptr2.get();
+    }
+    {
+        int* raw = new int;
+        std::observer_ptr<int> ptr = std::make_observer(raw);
+        assert(ptr.get() == raw);
+        delete raw;
+    }
+
+    std::observer_ptr<int> ptr1(new int);
+    std::observer_ptr<int> ptr2(new int);
+    std::observer_ptr<int> ptr3;
+    std::observer_ptr<void> vptr((void*)new int);
+    {
+        assert(ptr1 == ptr1);
+        assert(!(ptr1 == ptr2));
+    }
+    {
+        assert(ptr1 != ptr2);
+    }
+    {
+        assert(ptr3 == nullptr);
+        assert(nullptr == ptr3);
+        assert(!(ptr1 == nullptr));
+        assert(!(nullptr == ptr1));
+    }
+    {
+        assert(!(ptr3 != nullptr));
+        assert(!(nullptr != ptr3));
+        assert(ptr1 != nullptr);
+        assert(nullptr != ptr1);
+    }
+    {
+        assert((ptr1 < ptr1) == (ptr1.get() < ptr1.get()));
+        assert((ptr1 < vptr) == (ptr1.get() < vptr.get()));
+    }
+    { // TODO: is this correct?
+        assert((ptr1 > ptr1) == (ptr1.get() < ptr1.get()));
+        assert((ptr1 > vptr) == (ptr1.get() < vptr.get()));
+    }
+    { // TODO: same as above
+        assert((ptr1 <= ptr1) != (ptr1.get() < ptr1.get()));
+        assert((ptr1 <= vptr) != (ptr1.get() < vptr.get()));
+    }
+    {
+        assert((ptr1 >= ptr1) != (ptr1.get() < ptr1.get()));
+        assert((ptr1 >= vptr) != (ptr1.get() < vptr.get()));
+    }
+
+    delete ptr1.get();
+    delete ptr2.get();
+    delete (int*)vptr.get();
+
+    return 0;
+}