diff --git a/libstdc++-v3/include/bits/ranges_base.h b/libstdc++-v3/include/bits/ranges_base.h
index 02e13a2027d1..c1a9f6a90009 100644
--- a/libstdc++-v3/include/bits/ranges_base.h
+++ b/libstdc++-v3/include/bits/ranges_base.h
@@ -61,29 +61,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 namespace ranges
 {
   template<typename>
     inline constexpr bool disable_sized_range = false;
 
   template<typename _Tp>
     inline constexpr bool enable_borrowed_range = false;
 
   namespace __detail
   {
+    [[__gnu__::__always_inline__]]
     constexpr __max_size_type
     __to_unsigned_like(__max_size_type __t) noexcept
     { return __t; }
 
+    [[__gnu__::__always_inline__]]
     constexpr __max_size_type
     __to_unsigned_like(__max_diff_type __t) noexcept
     { return __max_size_type(__t); }
 
     template<integral _Tp>
+      [[__gnu__::__always_inline__]]
       constexpr auto
       __to_unsigned_like(_Tp __t) noexcept
       { return static_cast<make_unsigned_t<_Tp>>(__t); }
 
     template<typename _Tp>
       using __make_unsigned_like_t
 	= decltype(__detail::__to_unsigned_like(std::declval<_Tp>()));
 
     // Part of the constraints of ranges::borrowed_range
     template<typename _Tp>
@@ -111,22 +114,23 @@ namespace ranges
 	  else if constexpr (__member_begin<_Tp>)
 	    return noexcept(_GLIBCXX_AUTO_CAST(std::declval<_Tp&>().begin()));
 	  else
 	    return noexcept(_GLIBCXX_AUTO_CAST(begin(std::declval<_Tp&>())));
 	}
 
     public:
       template<__maybe_borrowed_range _Tp>
 	requires is_array_v<remove_reference_t<_Tp>> || __member_begin<_Tp>
 	  || __adl_begin<_Tp>
+	[[nodiscard, __gnu__::__always_inline__]]
 	constexpr auto
-	operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
+	operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 	{
 	  if constexpr (is_array_v<remove_reference_t<_Tp>>)
 	    {
 	      static_assert(is_lvalue_reference_v<_Tp>);
 	      return __t + 0;
 	    }
 	  else if constexpr (__member_begin<_Tp>)
 	    return __t.begin();
 	  else
 	    return begin(__t);
@@ -161,22 +165,23 @@ namespace ranges
 	  else if constexpr (__member_end<_Tp>)
 	    return noexcept(_GLIBCXX_AUTO_CAST(std::declval<_Tp&>().end()));
 	  else
 	    return noexcept(_GLIBCXX_AUTO_CAST(end(std::declval<_Tp&>())));
 	}
 
     public:
       template<__maybe_borrowed_range _Tp>
 	requires is_bounded_array_v<remove_reference_t<_Tp>>
 	  || __member_end<_Tp> || __adl_end<_Tp>
+	[[nodiscard, __gnu__::__always_inline__]]
 	constexpr auto
-	operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
+	operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 	{
 	  if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
 	    {
 	      static_assert(is_lvalue_reference_v<_Tp>);
 	      return __t + extent_v<remove_reference_t<_Tp>>;
 	    }
 	  else if constexpr (__member_end<_Tp>)
 	    return __t.end();
 	  else
 	    return end(__t);
@@ -225,22 +230,23 @@ namespace ranges
 		  return is_nothrow_copy_constructible_v<_It>;
 		}
 	      else
 		return false;
 	    }
 	}
 
     public:
       template<__maybe_borrowed_range _Tp>
 	requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
+	[[nodiscard, __gnu__::__always_inline__]]
 	constexpr auto
-	operator()[[nodiscard]](_Tp&& __t) const
+	operator()(_Tp&& __t) const
 	noexcept(_S_noexcept<_Tp&>())
 	{
 	  if constexpr (__member_rbegin<_Tp>)
 	    return __t.rbegin();
 	  else if constexpr (__adl_rbegin<_Tp>)
 	    return rbegin(__t);
 	  else
 	    return std::make_reverse_iterator(_End{}(__t));
 	}
     };
@@ -282,22 +288,23 @@ namespace ranges
 		  return is_nothrow_copy_constructible_v<_It>;
 		}
 	      else
 		return false;
 	    }
 	}
 
     public:
       template<__maybe_borrowed_range _Tp>
 	requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
+	[[nodiscard, __gnu__::__always_inline__]]
 	constexpr auto
-	operator()[[nodiscard]](_Tp&& __t) const
+	operator()(_Tp&& __t) const
 	noexcept(_S_noexcept<_Tp&>())
 	{
 	  if constexpr (__member_rend<_Tp>)
 	    return __t.rend();
 	  else if constexpr (__adl_rend<_Tp>)
 	    return rend(__t);
 	  else
 	    return std::make_reverse_iterator(_Begin{}(__t));
 	}
     };
@@ -346,42 +353,44 @@ namespace ranges
 	    return noexcept(_GLIBCXX_AUTO_CAST(size(std::declval<_Tp&>())));
 	  else if constexpr (__sentinel_size<_Tp>)
 	    return noexcept(_End{}(std::declval<_Tp&>())
 			    - _Begin{}(std::declval<_Tp&>()));
 	}
 
     public:
       template<typename _Tp>
 	requires is_bounded_array_v<remove_reference_t<_Tp>>
 	  || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
+	[[nodiscard, __gnu__::__always_inline__]]
 	constexpr auto
-	operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
+	operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 	{
 	  if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
 	    return extent_v<remove_reference_t<_Tp>>;
 	  else if constexpr (__member_size<_Tp>)
 	    return __t.size();
 	  else if constexpr (__adl_size<_Tp>)
 	    return size(__t);
 	  else if constexpr (__sentinel_size<_Tp>)
 	    return __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
 	}
     };
 
     struct _SSize
     {
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 3403. Domain of ranges::ssize(E) doesn't match ranges::size(E)
       template<typename _Tp>
 	requires requires (_Tp& __t) { _Size{}(__t); }
+	[[nodiscard, __gnu__::__always_inline__]]
 	constexpr auto
-	operator()[[nodiscard]](_Tp&& __t) const noexcept(noexcept(_Size{}(__t)))
+	operator()(_Tp&& __t) const noexcept(noexcept(_Size{}(__t)))
 	{
 	  auto __size = _Size{}(__t);
 	  using __size_type = decltype(__size);
 	  // Return the wider of ptrdiff_t and make-signed-like-t<__size_type>.
 	  if constexpr (integral<__size_type>)
 	    {
 	      using __gnu_cxx::__int_traits;
 	      if constexpr (__int_traits<__size_type>::__digits
 			    < __int_traits<ptrdiff_t>::__digits)
 		return static_cast<ptrdiff_t>(__size);
@@ -422,22 +431,23 @@ namespace ranges
 	    return noexcept(_Size{}(std::declval<_Tp&>()) == 0);
 	  else
 	    return noexcept(bool(_Begin{}(std::declval<_Tp&>())
 		== _End{}(std::declval<_Tp&>())));
 	}
 
     public:
       template<typename _Tp>
 	requires __member_empty<_Tp> || __size0_empty<_Tp>
 	  || __eq_iter_empty<_Tp>
+	[[nodiscard, __gnu__::__always_inline__]]
 	constexpr bool
-	operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
+	operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 	{
 	  if constexpr (__member_empty<_Tp>)
 	    return bool(__t.empty());
 	  else if constexpr (__size0_empty<_Tp>)
 	    return _Size{}(__t) == 0;
 	  else
 	    return bool(_Begin{}(__t) == _End{}(__t));
 	}
     };
 
@@ -463,22 +473,23 @@ namespace ranges
 	{
 	  if constexpr (__member_data<_Tp>)
 	    return noexcept(_GLIBCXX_AUTO_CAST(std::declval<_Tp&>().data()));
 	  else
 	    return noexcept(_Begin{}(std::declval<_Tp&>()));
 	}
 
     public:
       template<__maybe_borrowed_range _Tp>
 	requires __member_data<_Tp> || __begin_data<_Tp>
+	[[nodiscard, __gnu__::__always_inline__]]
 	constexpr auto
-	operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
+	operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
 	{
 	  if constexpr (__member_data<_Tp>)
 	    return __t.data();
 	  else
 	    return std::to_address(_Begin{}(__t));
 	}
     };
 
   } // namespace __access
 
@@ -625,33 +636,35 @@ namespace ranges
 #if __glibcxx_ranges_as_const // >= C++23
   template<typename _Tp>
     concept constant_range
       = input_range<_Tp> && std::__detail::__constant_iterator<iterator_t<_Tp>>;
 #endif
 
   namespace __access
   {
 #if __glibcxx_ranges_as_const // >= C++23
     template<input_range _Range>
+      [[__gnu__::__always_inline__]]
       constexpr auto&
       __possibly_const_range(_Range& __r) noexcept
       {
 	// _GLIBCXX_RESOLVE_LIB_DEFECTS
 	// 4027. possibly-const-range should prefer returning const R&
 	if constexpr (input_range<const _Range>)
 	  return const_cast<const _Range&>(__r);
 	else
 	  return __r;
       }
 #else
     // If _To is an lvalue-reference, return const _Tp&, otherwise const _Tp&&.
     template<typename _To, typename _Tp>
+      [[__gnu__::__always_inline__]]
       constexpr decltype(auto)
       __as_const(_Tp& __t) noexcept
       {
 	static_assert(std::is_same_v<_To&, _Tp&>);
 
 	if constexpr (is_lvalue_reference_v<_To>)
 	  return const_cast<const _Tp&>(__t);
 	else
 	  return static_cast<const _Tp&&>(__t);
       }
@@ -960,106 +973,106 @@ namespace ranges
 	iter_difference_t<_It> __n = 0;
 	while (__first != __last)
 	  {
 	    ++__first;
 	    ++__n;
 	  }
 	return __n;
       }
 
     template<typename _It, sized_sentinel_for<decay_t<_It>> _Sent>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr iter_difference_t<decay_t<_It>>
       operator()(_It&& __first, _Sent __last) const
       { return __last - static_cast<const decay_t<_It>&>(__first); }
 
     template<range _Range>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr range_difference_t<_Range>
       operator()(_Range&& __r) const
       {
 	if constexpr (sized_range<_Range>)
 	  return static_cast<range_difference_t<_Range>>(ranges::size(__r));
 	else
 	  return (*this)(ranges::begin(__r), ranges::end(__r));
       }
 
     void operator&() const = delete;
   };
 
   inline constexpr __distance_fn distance{};
 
   struct __next_fn final
   {
     template<input_or_output_iterator _It>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr _It
       operator()(_It __x) const
       {
 	++__x;
 	return __x;
       }
 
     template<input_or_output_iterator _It>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr _It
       operator()(_It __x, iter_difference_t<_It> __n) const
       {
 	ranges::advance(__x, __n);
 	return __x;
       }
 
     template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr _It
       operator()(_It __x, _Sent __bound) const
       {
 	ranges::advance(__x, __bound);
 	return __x;
       }
 
     template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr _It
       operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound) const
       {
 	ranges::advance(__x, __n, __bound);
 	return __x;
       }
 
     void operator&() const = delete;
   };
 
   inline constexpr __next_fn next{};
 
   struct __prev_fn final
   {
     template<bidirectional_iterator _It>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr _It
       operator()(_It __x) const
       {
 	--__x;
 	return __x;
       }
 
     template<bidirectional_iterator _It>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr _It
       operator()(_It __x, iter_difference_t<_It> __n) const
       {
 	ranges::advance(__x, -__n);
 	return __x;
       }
 
     template<bidirectional_iterator _It>
-      [[nodiscard]]
+      [[nodiscard, __gnu__::__always_inline__]]
       constexpr _It
       operator()(_It __x, iter_difference_t<_It> __n, _It __bound) const
       {
 	ranges::advance(__x, -__n, __bound);
 	return __x;
       }
 
     void operator&() const = delete;
   };