mdspan/extents: hide more things from ABI

[crtrott]

Summary

addressing output by

libcxx/include/__mdspan/extents.h

 struct __static_array_impl<_Idx, _Tp, _FirstExt, _Extents...> {
   constexpr static _Tp get(size_t __r) noexcept {
     if (__r == _Idx)
       return _FirstExt;
     else
       return __static_array_impl<_Idx + 1, _Tp, _Extents...>::get(__r);
   }
   template <size_t __r>
-  constexpr static _Tp get() {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Tp get() {
     if constexpr (__r == _Idx)
       return _FirstExt;
     else
       return __static_array_impl<_Idx + 1, _Tp, _Extents...>::template get<__r>();
   }
 };
 
 // End the recursion
 template <size_t _Idx, class _Tp, _Tp _FirstExt>
 struct __static_array_impl<_Idx, _Tp, _FirstExt> {
   constexpr static _Tp get(size_t) noexcept { return _FirstExt; }
   template <size_t>
-  constexpr static _Tp get() {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Tp get() {
     return _FirstExt;
   }
 };
 
 // Don't start recursion if size 0
 template <class _Tp>
 struct __static_array_impl<0, _Tp> {
   constexpr static _Tp get(size_t) noexcept { return _Tp(); }
   template <size_t>
-  constexpr static _Tp get() {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Tp get() {
     return _Tp();
   }
 };
 
 // Static array, provides get<r>(), get(r) and operator[r]
 template <class _Tp, _Tp... _Values>
 struct __static_array : public __static_array_impl<0, _Tp, _Values...> {
 public:
-  constexpr static size_t size() { return sizeof...(_Values); }
+  _LIBCPP_HIDE_FROM_ABI constexpr static size_t size() { return sizeof...(_Values); }
 };
 
 // ------------------------------------------------------------------
 // ------------ index_sequence_scan ---------------------------------
 // ------------------------------------------------------------------
 
 // index_sequence_scan takes compile time values and provides get(r)
 //  which return the sum of the first r-1 values.

 // array like class which provides get function and operator [], and
 // has a specialization for the size 0 case.
 // This is needed to make the __maybe_static_array be truly empty, for
 // all static values.
 
 template <class _Tp, size_t _Num>
 struct __possibly_empty_array {
   _Tp __vals_[_Num];
-  constexpr _Tp& operator[](size_t __r) { return __vals_[__r]; }
-  constexpr const _Tp& operator[](size_t __r) const { return __vals_[__r]; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator[](size_t __r) { return __vals_[__r]; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](size_t __r) const { return __vals_[__r]; }
 };
 
 template <class _Tp>
 struct __possibly_empty_array<_Tp, 0> {
-  constexpr _Tp operator[](size_t) { return _Tp(); }
-  constexpr const _Tp operator[](size_t) const { return _Tp(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp operator[](size_t) { return _Tp(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp operator[](size_t) const { return _Tp(); }
 };
 
 // ------------------------------------------------------------------
 // ------------ __maybe_static_array --------------------------------
 // ------------------------------------------------------------------
 
 // array like class which has a mix of static and runtime values but
 // only stores the runtime values.
private:
 
   // Dynamic values member
   [[no_unique_address]] __possibly_empty_array<_TDynamic, __size_dynamic_> __dyn_vals_;
 
   // static mapping of indices to the position in the dynamic values array
   using __dyn_map_t = __index_sequence_scan_impl<0, static_cast<size_t>(_Values == _DynTag)...>;
 
 public:
-  constexpr __maybe_static_array() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array() = default;
 
   // constructor for all static values
   // TODO: add precondition check?
   template <class... _Vals>
     requires((__size_dynamic_ == 0) && (sizeof...(_Vals) > 0))
-  constexpr __maybe_static_array(_Vals...) : __dyn_vals_{} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(_Vals...) : __dyn_vals_{} {}
 
   // constructors from dynamic values only
   template <class... _DynVals>
     requires(sizeof...(_DynVals) == __size_dynamic_ && __size_dynamic_ > 0)
-  constexpr __maybe_static_array(_DynVals... __vals) : __dyn_vals_{static_cast<_TDynamic>(__vals)...} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(_DynVals... __vals)
+      : __dyn_vals_{static_cast<_TDynamic>(__vals)...} {}
 
   template <class _Tp, size_t _Num>
     requires(_Num == __size_dynamic_ && _Num > 0)
-  constexpr __maybe_static_array(const std::array<_Tp, _Num>& __vals) {
+  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(const std::array<_Tp, _Num>& __vals) {
     for (size_t __r = 0; __r < _Num; __r++)
       __dyn_vals_[__r] = static_cast<_TDynamic>(__vals[__r]);
   }
 
   template <class _Tp, size_t _Num>
     requires(_Num == __size_dynamic_ && _Num == 0)
-  constexpr __maybe_static_array(const std::array<_Tp, _Num>&) : __dyn_vals_{} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(const std::array<_Tp, _Num>&) : __dyn_vals_{} {}
 
   template <class _Tp, size_t _Num >
     requires(_Num == __size_dynamic_ && _Num > 0)
-  constexpr __maybe_static_array(const std::span<_Tp, _Num>& __vals) {
+  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(const std::span<_Tp, _Num>& __vals) {
     for (size_t __r = 0; __r < _Num; __r++)
       __dyn_vals_[__r] = static_cast<_TDynamic>(__vals[__r]);
   }
 
   template <class _Tp, size_t _Num>
     requires(_Num == __size_dynamic_ && _Num == 0)
-  constexpr __maybe_static_array(const std::span<_Tp, _Num>&) : __dyn_vals_{} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(const std::span<_Tp, _Num>&) : __dyn_vals_{} {}
 
   // constructors from all values
   template <class... _DynVals>
     requires(sizeof...(_DynVals) != __size_dynamic_ && __size_dynamic_ > 0)
   constexpr __maybe_static_array(_DynVals... __vals) {
     static_assert((sizeof...(_DynVals) == __size_), "Invalid number of values.");
     _TDynamic __values[__size_]{static_cast<_TDynamic>(__vals)...};
     for (size_t __r = 0; __r < __size_; __r++) {
for (size_t __r = 0; __r < __size_; __r++) {
       else
         _LIBCPP_ASSERT(static_cast<_TDynamic>(__vals[__r]) == static_cast<_TDynamic>(__static_val),
                        "extents construction: mismatch of provided arguments with static extents.");
     }
   }
 
   template <class _Tp, size_t _Num>
     requires(_Num != __size_dynamic_ && __size_dynamic_ > 0)
-  constexpr __maybe_static_array(const std::span<_Tp, _Num>& __vals) {
+  _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(const std::span<_Tp, _Num>& __vals) {
     static_assert((_Num == __size_) || (__size_ == dynamic_extent));
     for (size_t __r = 0; __r < __size_; __r++) {
       _TStatic __static_val = __static_vals_t::get(__r);
       if (__static_val == _DynTag) {
         __dyn_vals_[__dyn_map_t::get(__r)] = static_cast<_TDynamic>(__vals[__r]);
       }
       // Precondition check
       else
         _LIBCPP_ASSERT(static_cast<_TDynamic>(__vals[__r]) == static_cast<_TDynamic>(__static_val),
                        "extents construction: mismatch of provided arguments with static extents.");
     }
   }
 
   // access functions
-  constexpr static _TStatic __static_value(size_t __r) noexcept { return __static_vals_t::get(__r); }
+  _LIBCPP_HIDE_FROM_ABI constexpr static _TStatic __static_value(size_t __r) noexcept {
+    return __static_vals_t::get(__r);
+  }
 
-  constexpr _TDynamic __value(size_t __r) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _TDynamic __value(size_t __r) const {
     _TStatic __static_val = __static_vals_t::get(__r);
     return __static_val == _DynTag ? __dyn_vals_[__dyn_map_t::get(__r)] : static_cast<_TDynamic>(__static_val);
   }
-  constexpr _TDynamic operator[](size_t __r) const { return __value(__r); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _TDynamic operator[](size_t __r) const { return __value(__r); }
 
   // observers
-  constexpr static size_t __size() { return __size_; }
-  constexpr static size_t __size_dynamic() { return __size_dynamic_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr static size_t __size() { return __size_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr static size_t __size_dynamic() { return __size_dynamic_; }
 };
 
 } // namespace __mdspan_detail
 
 // ------------------------------------------------------------------
 // ------------ extents ---------------------------------------------
 // ------------------------------------------------------------------
 
private:
   constexpr static rank_type __rank_dynamic_ = ((_Extents == dynamic_extent) + ... + 0);
 
   // internal storage type using __maybe_static_array
   using __vals_t = __mdspan_detail::__maybe_static_array<_IndexType, size_t, dynamic_extent, _Extents...>;
   [[no_unique_address]] __vals_t __vals_;
 
 public:
   // [mdspan.extents.obs], observers of multidimensional index space
-  constexpr static rank_type rank() noexcept { return __rank_; }
-  constexpr static rank_type rank_dynamic() noexcept { return __rank_dynamic_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr static rank_type rank() noexcept { return __rank_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr static rank_type rank_dynamic() noexcept { return __rank_dynamic_; }
 
-  constexpr index_type extent(rank_type __r) const noexcept { return __vals_.__value(__r); }
-  constexpr static size_t static_extent(rank_type __r) noexcept { return __vals_t::__static_value(__r); }
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type extent(rank_type __r) const noexcept { return __vals_.__value(__r); }
+  _LIBCPP_HIDE_FROM_ABI constexpr static size_t static_extent(rank_type __r) noexcept {
+    return __vals_t::__static_value(__r);
+  }
 
   // [mdspan.extents.cons], constructors
-  constexpr extents() noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr extents() noexcept = default;
 
   // Construction from just dynamic or all values.
   // Precondition check is deferred to __maybe_static_array constructor
   template <class... _OtherIndexTypes>
     requires((is_convertible_v<_OtherIndexTypes, index_type> && ...) &&
              (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...) &&
              (sizeof...(_OtherIndexTypes) == __rank_ || sizeof...(_OtherIndexTypes) == __rank_dynamic_))
-  constexpr explicit extents(_OtherIndexTypes... __dynvals) noexcept : __vals_(static_cast<index_type>(__dynvals)...) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit extents(_OtherIndexTypes... __dynvals) noexcept
+      : __vals_(static_cast<index_type>(__dynvals)...) {}
 
   template <class _OtherIndexType, size_t _Num>
     requires(is_convertible_v<_OtherIndexType, index_type> && is_nothrow_constructible_v<index_type, _OtherIndexType> &&
              (_Num == __rank_ || _Num == __rank_dynamic_))
-  explicit(_Num != __rank_dynamic_) constexpr extents(const array<_OtherIndexType, _Num>& __exts) noexcept
+  explicit(_Num != __rank_dynamic_)
+      _LIBCPP_HIDE_FROM_ABI constexpr extents(const array<_OtherIndexType, _Num>& __exts) noexcept
       : __vals_(std::move(__exts)) {}
 
   template <class _OtherIndexType, size_t _Num>
     requires(is_convertible_v<_OtherIndexType, index_type> && is_nothrow_constructible_v<index_type, _OtherIndexType> &&
              (_Num == __rank_ || _Num == __rank_dynamic_))
-  explicit(_Num != __rank_dynamic_) constexpr extents(const span<_OtherIndexType, _Num>& __exts) noexcept
+  explicit(_Num != __rank_dynamic_)
+      _LIBCPP_HIDE_FROM_ABI constexpr extents(const span<_OtherIndexType, _Num>& __exts) noexcept
       : __vals_(std::move(__exts)) {}
 
 private:
   // Function to construct extents storage from other extents.
   // With C++ 17 the first two variants could be collapsed using if constexpr
   // in which case you don't need all the requires clauses.
   // in C++ 14 mode that doesn't work due to infinite recursion
   template <size_t _DynCount, size_t _Idx, class _OtherExtents, class... _DynamicValues>
     requires((_Idx < __rank_) && (static_extent(_Idx) == dynamic_extent))
-  __vals_t __construct_vals_from_extents(
+  _LIBCPP_HIDE_FROM_ABI __vals_t __construct_vals_from_extents(
       std::integral_constant<size_t, _DynCount>,
       std::integral_constant<size_t, _Idx>,
       const _OtherExtents& __exts,
       _DynamicValues... __dynamic_values) noexcept {
     return __construct_vals_from_extents(
         std::integral_constant<size_t, _DynCount + 1>(),
         std::integral_constant<size_t, _Idx + 1>(),
         __exts,
         __dynamic_values...,
         __exts.extent(_Idx));
   }
 
   template <size_t _DynCount, size_t _Idx, class _OtherExtents, class... _DynamicValues>
     requires((_Idx < __rank_) && (static_extent(_Idx) != dynamic_extent))
-  __vals_t __construct_vals_from_extents(
+  _LIBCPP_HIDE_FROM_ABI __vals_t __construct_vals_from_extents(
       std::integral_constant<size_t, _DynCount>,
       std::integral_constant<size_t, _Idx>,
       const _OtherExtents& __exts,
       _DynamicValues... __dynamic_values) noexcept {
     return __construct_vals_from_extents(
         std::integral_constant<size_t, _DynCount>(),
         std::integral_constant<size_t, _Idx + 1>(),
         __exts,
         __dynamic_values...);
   }
 
   template <size_t _DynCount, size_t _Idx, class _OtherExtents, class... _DynamicValues>
     requires((_Idx == __rank_) && (_DynCount == __rank_dynamic_))
-  __vals_t __construct_vals_from_extents(
+  _LIBCPP_HIDE_FROM_ABI __vals_t __construct_vals_from_extents(
       std::integral_constant<size_t, _DynCount>,
       std::integral_constant<size_t, _Idx>,
       const _OtherExtents&,
       _DynamicValues... __dynamic_values) noexcept {
     return __vals_t{static_cast<index_type>(__dynamic_values)...};
   }
 
 public:
   // Converting constructor from other extents specializations
   template <class _OtherIndexType, size_t... _OtherExtents>
     requires((sizeof...(_OtherExtents) == sizeof...(_Extents)) &&
              ((_OtherExtents == dynamic_extent || _Extents == dynamic_extent || _OtherExtents == _Extents) && ...))
-  explicit(
-      (((_Extents != dynamic_extent) && (_OtherExtents == dynamic_extent)) || ...) ||
+  explicit((((_Extents != dynamic_extent) && (_OtherExtents == dynamic_extent)) || ...) ||
            (static_cast<make_unsigned_t<index_type>>(numeric_limits<index_type>::max()) <
-       static_cast<make_unsigned_t<_OtherIndexType>>(
-           numeric_limits<_OtherIndexType>::max()))) constexpr extents(const extents<_OtherIndexType, _OtherExtents...>&
-                                                                           __other) noexcept
+            static_cast<make_unsigned_t<_OtherIndexType>>(numeric_limits<_OtherIndexType>::max())))
+      _LIBCPP_HIDE_FROM_ABI constexpr extents(const extents<_OtherIndexType, _OtherExtents...>& __other) noexcept
       : __vals_(__construct_vals_from_extents(
             std::integral_constant<size_t, 0>(), std::integral_constant<size_t, 0>(), __other)) {}
 
   // Comparison operator
   template <class _OtherIndexType, size_t... _OtherExtents>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool
   operator==(const extents& __lhs, const extents<_OtherIndexType, _OtherExtents...>& __rhs) noexcept {
     bool __value = true;