Add partial implementation of std::to_address() as llvm::to_address()

[dsanders]

Summary

Following on from the review for D58088, this patch provides the
prerequisite to_address() implementation that's needed to have
pointer_iterator support unique_ptr.

'typename Ptr::element_type *' should be replaced with 'auto' once we move
to C++14 to better align with the C++20 declaration. Until then, this
implementation is limited to fancy pointers with an element_type typedef.
Also, this implementation can be removed once we move to C++20 where it's
defined as std::to_addres()

The std::pointer_traits<>::to_address(p) variations of these overloads has
not been implemented.

[dexonsmith]

include/llvm/ADT/STLExtras.h

1589–1592

Can you use decltype(std::declval<Ptr>().operator->()) instead of typename Ptr::element_type * to avoid requiring an element_type typedef?

[dblaikie]

include/llvm/ADT/STLExtras.h

1589–1592

Yep, or late bound return:

auto to_address(const Ptr &P) -> decltype(P.operator->()) { return P.operator->(); }

Also probably leave off the noexcept - LLVM doesn't build with exceptions anyway. So there's not a lot/much point in littering noexcept everywhere.

[dsanders]

Late bound return, remove noexcept, and update comments to match

include/llvm/ADT/STLExtras.h

1589–1592

I've gone with the late bound return, partly because it's a little shorter and partly because it means we just drop the -> onwards for C++14.

Also probably leave off the noexcept - LLVM doesn't build with exceptions anyway. So there's not a lot/much point in littering noexcept everywhere.

Sure. I only included it to match the std::to_address() declaration we're implementing. As you say, it's not doing anything for LLVM

[dblaikie]

Looks good - thanks!

[glenjofe]

llvm/trunk/include/llvm/ADT/STLExtras.h

1588 ↗

(On Diff #187609)

The fancy pointer overload should return to_address(p.operator->()) but this returns p.operator->().

[glenjofe]

llvm/trunk/include/llvm/ADT/STLExtras.h

1582–1583 ↗

(On Diff #187609)

Is this necessary because you do not have access to __to_raw_pointer() in libc++? That is available in pre-C++20. The actual implementation of std::to_address() in libc++ is what I implemented in __to_raw_pointer() in D35470.

[dblaikie]

llvm/trunk/include/llvm/ADT/STLExtras.h

1582–1583 ↗

(On Diff #187609)

Yeah, this code needs to be portable to other compilers and standard libraries (LLVM can be built with a bunch of different compilers).

1588 ↗

(On Diff #187609)

What sort of cases would this support (trying to think of what test coverage to add)?

I guess a multiply-indirect smart pointer? Pretty rare beast, not sure we'd really care/need to support that for LLVM's uses?

include/llvm/ADT/STLExtras.h

typename std::enable_if<
             std::random_access_iterator_tag>::value,
         void>::type * = nullptr) {
   for (; N; --N, ++Begin)
     if (Begin == End)
       return false; // Too few.
   return true;
 }
 
+/// Returns a raw pointer that represents the same address as the argument.
+///
+/// The late bound return should be removed once we move to C++14 to better
+/// align with the C++20 declaration. Also, this implementation can be removed
+/// once we move to C++20 where it's defined as std::to_addres()
+///
+/// The std::pointer_traits<>::to_address(p) variations of these overloads has
+/// not been implemented.
+template <class Ptr> auto to_address(const Ptr &P) -> decltype(P.operator->()) {
+  return P.operator->();
+}
+template <class T> constexpr T *to_address(T *P) { return P; }
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_STLEXTRAS_H

unittests/ADT/STLExtrasTest.cpp

TEST(STLExtrasTest, splat) {
   V.push_back(1);
   V.push_back(1);
   EXPECT_TRUE(is_splat(V));
 
   V.push_back(2);
   EXPECT_FALSE(is_splat(V));
 }
 
+TEST(STLExtrasTest, to_address) {
+  int *V1 = new int;
+  EXPECT_EQ(V1, to_address(V1));
+
+  // Check fancy pointer overload for unique_ptr
+  std::unique_ptr<int> V2 = make_unique<int>(0);
+  EXPECT_EQ(V2.get(), to_address(V2));
+
+  V2.reset(V1);
+  EXPECT_EQ(V1, to_address(V2));
+  V2.release();
+
+  // Check fancy pointer overload for shared_ptr
+  std::shared_ptr<int> V3 = std::make_shared<int>(0);
+  std::shared_ptr<int> V4 = V3;
+  EXPECT_EQ(V3.get(), V4.get());
+  EXPECT_EQ(V3.get(), to_address(V3));
+  EXPECT_EQ(V4.get(), to_address(V4));
+
+  V3.reset(V1);
+  EXPECT_EQ(V1, to_address(V3));
+}
+
 } // namespace