[gcc r16-610] Add std::to_underlying to the set of stdlib functions that are always folded

[Ville Voutilainen via Gcc-cvs]

https://gcc.gnu.org/g:3ecca8f3ad7e7fe3da0e600fb66fca3dc6bae006

commit r16-610-g3ecca8f3ad7e7fe3da0e600fb66fca3dc6bae006
Author: Ville Voutilainen <ville.voutilai...@gmail.com>
Date:   Mon May 12 23:16:46 2025 +0300

    Add std::to_underlying to the set of stdlib functions that are always folded
    
    gcc/cp/ChangeLog:
            * cp-gimplify.cc (cp_fold): Add to_underlying.
    
    gcc/testsuite/ChangeLog:
            * g++.dg/opt/pr96780_cpp23.C: New.
    
    libstdc++-v3/ChangeLog:
            * include/std/utility (to_underlying): Add the __always_inline__ 
attribute.
    
    Signed-off-by: Ville Voutilainen <ville.voutilai...@gmail.com>

Diff:
---
 gcc/cp/cp-gimplify.cc                    | 13 +++++--------
 gcc/testsuite/g++.dg/opt/pr96780_cpp23.C | 16 ++++++++++++++++
 libstdc++-v3/include/std/utility         |  2 +-
 3 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/gcc/cp/cp-gimplify.cc b/gcc/cp/cp-gimplify.cc
index d2423fd1848a..4e5d383daeb6 100644
--- a/gcc/cp/cp-gimplify.cc
+++ b/gcc/cp/cp-gimplify.cc
@@ -3343,19 +3343,16 @@ cp_fold (tree x, fold_flags_t flags)
                || id_equal (DECL_NAME (callee), "addressof")
                /* This addressof equivalent is used heavily in libstdc++.  */
                || id_equal (DECL_NAME (callee), "__addressof")
+               || id_equal (DECL_NAME (callee), "to_underlying")
                || id_equal (DECL_NAME (callee), "as_const")))
          {
            r = CALL_EXPR_ARG (x, 0);
            /* Check that the return and argument types are sane before
               folding.  */
-           if (INDIRECT_TYPE_P (TREE_TYPE (x))
-               && INDIRECT_TYPE_P (TREE_TYPE (r)))
-             {
-               if (!same_type_p (TREE_TYPE (x), TREE_TYPE (r)))
-                 r = build_nop (TREE_TYPE (x), r);
-               x = cp_fold (r, flags);
-               break;
-             }
+           if (!same_type_p (TREE_TYPE (x), TREE_TYPE (r)))
+             r = build_nop (TREE_TYPE (x), r);
+           x = cp_fold (r, flags);
+           break;
          }
 
        int sv = optimize, nw = sv;
diff --git a/gcc/testsuite/g++.dg/opt/pr96780_cpp23.C 
b/gcc/testsuite/g++.dg/opt/pr96780_cpp23.C
new file mode 100644
index 000000000000..ba4a837ddedb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr96780_cpp23.C
@@ -0,0 +1,16 @@
+// PR c++/96780
+// Verify calls to std::move/forward are folded away by the frontend.
+// { dg-do compile { target c++23 } }
+// { dg-additional-options "-ffold-simple-inlines -fdump-tree-gimple" }
+
+#include <utility>
+
+enum class A : char {a};
+
+extern A& x;
+
+void f() {
+  auto&& x1 = std::to_underlying(x);
+}
+
+// { dg-final { scan-tree-dump-not "= std::to_underlying" "gimple" } }
diff --git a/libstdc++-v3/include/std/utility b/libstdc++-v3/include/std/utility
index 1c15c75f92b0..8a85ccfd09ba 100644
--- a/libstdc++-v3/include/std/utility
+++ b/libstdc++-v3/include/std/utility
@@ -201,7 +201,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #ifdef __cpp_lib_to_underlying // C++ >= 23
   /// Convert an object of enumeration type to its underlying type.
   template<typename _Tp>
-    [[nodiscard]]
+    [[nodiscard, __gnu__::__always_inline__]]
     constexpr underlying_type_t<_Tp>
     to_underlying(_Tp __value) noexcept
     { return static_cast<underlying_type_t<_Tp>>(__value); }