From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2153) id CEB9E3858C62; Thu, 2 Mar 2023 23:39:31 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org CEB9E3858C62 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1677800371; bh=+ztY3afqTWXiMlZeAEEjMrHa/hnFWV/meCRgUxvPH70=; h=From:To:Subject:Date:From; b=ppElt5ohMIgeeixIhWY3bJchvtTiAzreD56U33bEXn66P9imFvyaFUxtTU4YM7QTp VKdDzSRCcdCleYD0UcR2h0pD1wzQZVI43SdKfI4KryqVyL0FspKMhdn551ErH7v4w1 YVQU7Zc0io1TMX8AR6bpytI6PoAnkaZ++2eyXNGs= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jakub Jelinek To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-6426] c++, v3: Emit fundamental tinfos for _Float16/decltype(0.0bf16) types on ia32 with -mno-sse2 [PR1088 X-Act-Checkin: gcc X-Git-Author: Jakub Jelinek X-Git-Refname: refs/heads/master X-Git-Oldrev: 6b432c0f777ab9b8436fb07f71de6ea4d259b869 X-Git-Newrev: 6978df2c04df165eaa6aac9e17b6c770bed460e3 Message-Id: <20230302233931.CEB9E3858C62@sourceware.org> Date: Thu, 2 Mar 2023 23:39:31 +0000 (GMT) List-Id: https://gcc.gnu.org/g:6978df2c04df165eaa6aac9e17b6c770bed460e3 commit r13-6426-g6978df2c04df165eaa6aac9e17b6c770bed460e3 Author: Jakub Jelinek Date: Fri Mar 3 00:34:59 2023 +0100 c++, v3: Emit fundamental tinfos for _Float16/decltype(0.0bf16) types on ia32 with -mno-sse2 [PR108883] _Float16 and decltype(0.0bf16) types are on x86 supported only with -msse2. On x86_64 that is the default, but on ia32 it is not. We should still emit fundamental type tinfo for those types in libsupc++.a/libstdc++.*, regardless of whether libsupc++/libstdc++ is compiled with -msse2 or not, as user programs can be compiled with different ISA flags from libsupc++/libstdc++ and if they are compiled with -msse2 and use std::float16_t or std::bfloat16_t and need RTTI for it, it should work out of the box. Furthermore, libstdc++ ABI on ia32 shouldn't depend on whether the library is compiled with -mno-sse or -msse2. Unfortunately, just hacking up libsupc++ Makefile/configure so that a single source is compiled with -msse2 isn't appropriate, because that TU emits also code and the code should be able to run on CPUs which libstdc++ supports. We could add [[gnu::attribute ("no-sse2")]] there perhaps conditionally, but it all gets quite ugly. The following patch instead adds a target hook which allows the backend to temporarily tweak registered types such that emit_support_tinfos emits whatever is needed. Additionally, it makes emit_support_tinfos_1 call emit_tinfo_decl immediately, so that temporarily created dummy types for emit_support_tinfo purposes only can be nullified again afterwards. And removes the previous fallback_* types used for dfloat*_type_node tinfos even when decimal types aren't supported. 2023-03-03 Jakub Jelinek PR target/108883 gcc/ * target.h (emit_support_tinfos_callback): New typedef. * targhooks.h (default_emit_support_tinfos): Declare. * targhooks.cc (default_emit_support_tinfos): New function. * target.def (emit_support_tinfos): New target hook. * doc/tm.texi.in (emit_support_tinfos): Document it. * doc/tm.texi: Regenerated. * config/i386/i386.cc (ix86_emit_support_tinfos): New function. (TARGET_EMIT_SUPPORT_TINFOS): Redefine. gcc/cp/ * cp-tree.h (enum cp_tree_index): Remove CPTI_FALLBACK_DFLOAT*_TYPE enumerators. (fallback_dfloat32_type, fallback_dfloat64_type, fallback_dfloat128_type): Remove. * rtti.cc (emit_support_tinfo_1): If not emitted already, call emit_tinfo_decl and remove from unemitted_tinfo_decls right away. (emit_support_tinfos): Move &dfloat*_type_node from fundamentals array into new fundamentals_with_fallback array. Call emit_support_tinfo_1 on elements of that array too, with the difference that if the type is NULL, use a fallback REAL_TYPE for it temporarily. Drop the !targetm.decimal_float_supported_p () handling. Call targetm.emit_support_tinfos at the end. * mangle.cc (write_builtin_type): Remove references to fallback_dfloat*_type. Handle bfloat16_type_node mangling. Diff: --- gcc/config/i386/i386.cc | 24 ++++++++++++++++++++++++ gcc/cp/cp-tree.h | 11 ----------- gcc/cp/mangle.cc | 8 +++++--- gcc/cp/rtti.cc | 47 ++++++++++++++++++++++++++++++++--------------- gcc/doc/tm.texi | 9 +++++++++ gcc/doc/tm.texi.in | 2 ++ gcc/target.def | 13 +++++++++++++ gcc/target.h | 2 ++ gcc/targhooks.cc | 5 +++++ gcc/targhooks.h | 2 ++ 10 files changed, 94 insertions(+), 29 deletions(-) diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index 22f444be23c..5d0e4739a84 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -22775,6 +22775,27 @@ ix86_mangle_type (const_tree type) } } +/* Create C++ tinfo symbols for only conditionally available fundamental + types. */ + +static void +ix86_emit_support_tinfos (emit_support_tinfos_callback callback) +{ + extern tree ix86_float16_type_node; + extern tree ix86_bf16_type_node; + + if (!TARGET_SSE2) + { + gcc_checking_assert (!float16_type_node && !bfloat16_type_node); + float16_type_node = ix86_float16_type_node; + bfloat16_type_node = ix86_bf16_type_node; + callback (float16_type_node); + callback (bfloat16_type_node); + float16_type_node = NULL_TREE; + bfloat16_type_node = NULL_TREE; + } +} + static GTY(()) tree ix86_tls_stack_chk_guard_decl; static tree @@ -24954,6 +24975,9 @@ ix86_libgcc_floating_mode_supported_p #undef TARGET_MANGLE_TYPE #define TARGET_MANGLE_TYPE ix86_mangle_type +#undef TARGET_EMIT_SUPPORT_TINFOS +#define TARGET_EMIT_SUPPORT_TINFOS ix86_emit_support_tinfos + #undef TARGET_STACK_PROTECT_GUARD #define TARGET_STACK_PROTECT_GUARD ix86_stack_protect_guard diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 83633ddc7f2..fb21c064141 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -235,10 +235,6 @@ enum cp_tree_index CPTI_PSEUDO_CONTRACT_VIOLATION, - CPTI_FALLBACK_DFLOAT32_TYPE, - CPTI_FALLBACK_DFLOAT64_TYPE, - CPTI_FALLBACK_DFLOAT128_TYPE, - CPTI_MAX }; @@ -397,13 +393,6 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX]; access nodes in tree.h. */ #define access_default_node null_node - -/* Variant of dfloat{32,64,128}_type_node only used for fundamental - rtti purposes if DFP is disabled. */ -#define fallback_dfloat32_type cp_global_trees[CPTI_FALLBACK_DFLOAT32_TYPE] -#define fallback_dfloat64_type cp_global_trees[CPTI_FALLBACK_DFLOAT64_TYPE] -#define fallback_dfloat128_type cp_global_trees[CPTI_FALLBACK_DFLOAT128_TYPE] - #include "name-lookup.h" diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc index f2761d22bba..242b3f31cba 100644 --- a/gcc/cp/mangle.cc +++ b/gcc/cp/mangle.cc @@ -2732,11 +2732,11 @@ write_builtin_type (tree type) write_char ('d'); else if (type == long_double_type_node) write_char ('e'); - else if (type == dfloat32_type_node || type == fallback_dfloat32_type) + else if (type == dfloat32_type_node) write_string ("Df"); - else if (type == dfloat64_type_node || type == fallback_dfloat64_type) + else if (type == dfloat64_type_node) write_string ("Dd"); - else if (type == dfloat128_type_node || type == fallback_dfloat128_type) + else if (type == dfloat128_type_node) write_string ("De"); else if (type == float16_type_node) write_string ("DF16_"); @@ -2752,6 +2752,8 @@ write_builtin_type (tree type) write_string ("DF64x"); else if (type == float128x_type_node) write_string ("DF128x"); + else if (type == bfloat16_type_node) + write_string ("DF16b"); else gcc_unreachable (); break; diff --git a/gcc/cp/rtti.cc b/gcc/cp/rtti.cc index d6dae504af4..2a253a43861 100644 --- a/gcc/cp/rtti.cc +++ b/gcc/cp/rtti.cc @@ -1577,6 +1577,15 @@ emit_support_tinfo_1 (tree bltn) gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo)); DECL_INTERFACE_KNOWN (tinfo) = 1; } + + /* Emit it right away if not emitted already. */ + if (DECL_INITIAL (tinfo) == NULL_TREE) + { + gcc_assert (unemitted_tinfo_decls->last () == tinfo); + bool ok = emit_tinfo_decl (tinfo); + gcc_assert (ok); + unemitted_tinfo_decls->pop (); + } } } @@ -1602,12 +1611,18 @@ emit_support_tinfos (void) &long_integer_type_node, &long_unsigned_type_node, &long_long_integer_type_node, &long_long_unsigned_type_node, &float_type_node, &double_type_node, &long_double_type_node, - &dfloat32_type_node, &dfloat64_type_node, &dfloat128_type_node, &bfloat16_type_node, &float16_type_node, &float32_type_node, &float64_type_node, &float128_type_node, &float32x_type_node, &float64x_type_node, &float128x_type_node, &nullptr_type_node, 0 }; + /* Similar, but for floating point types only which should get type info + regardless whether they are non-NULL or NULL. */ + static tree *const fundamentals_with_fallback[] = + { + &dfloat32_type_node, &dfloat64_type_node, &dfloat128_type_node, + 0 + }; int ix; /* Look for a defined class. */ @@ -1627,8 +1642,20 @@ emit_support_tinfos (void) location_t saved_loc = input_location; input_location = BUILTINS_LOCATION; doing_runtime = 1; + tree fallback = NULL_TREE; for (ix = 0; fundamentals[ix]; ix++) emit_support_tinfo_1 (*fundamentals[ix]); + for (ix = 0; fundamentals_with_fallback[ix]; ix++) + if (*fundamentals_with_fallback[ix]) + emit_support_tinfo_1 (*fundamentals_with_fallback[ix]); + else + { + if (fallback == NULL_TREE) + fallback = make_node (REAL_TYPE); + *fundamentals_with_fallback[ix] = fallback; + emit_support_tinfo_1 (fallback); + *fundamentals_with_fallback[ix] = NULL_TREE; + } for (ix = 0; ix < NUM_INT_N_ENTS; ix ++) if (int_n_enabled_p[ix]) { @@ -1637,20 +1664,10 @@ emit_support_tinfos (void) } for (tree t = registered_builtin_types; t; t = TREE_CHAIN (t)) emit_support_tinfo_1 (TREE_VALUE (t)); - /* For compatibility, emit DFP typeinfos even when DFP isn't enabled, - because we've emitted that in the past. */ - if (!targetm.decimal_float_supported_p ()) - { - gcc_assert (dfloat32_type_node == NULL_TREE - && dfloat64_type_node == NULL_TREE - && dfloat128_type_node == NULL_TREE); - fallback_dfloat32_type = make_node (REAL_TYPE); - fallback_dfloat64_type = make_node (REAL_TYPE); - fallback_dfloat128_type = make_node (REAL_TYPE); - emit_support_tinfo_1 (fallback_dfloat32_type); - emit_support_tinfo_1 (fallback_dfloat64_type); - emit_support_tinfo_1 (fallback_dfloat128_type); - } + + /* Emit additional typeinfos as requested by target. */ + targetm.emit_support_tinfos (emit_support_tinfo_1); + input_location = saved_loc; } diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 09eab4131ce..ec90c46ea2f 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -1525,6 +1525,15 @@ appropriate for a target that does not define any new fundamental types. @end deftypefn +@deftypefn {Target Hook} void TARGET_EMIT_SUPPORT_TINFOS (emit_support_tinfos_callback @var{callback}) +If your target defines any fundamental types which depend on ISA flags, +they might need C++ tinfo symbols in libsupc++/libstdc++ regardless of +ISA flags the library is compiled with. +This hook allows creating tinfo symbols even for those cases, by temporarily +creating each corresponding fundamental type trees, calling the +@var{callback} function on it and setting the type back to @code{nullptr}. +@end deftypefn + @node Type Layout @section Layout of Source Language Data Types diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index 83aa3e732b1..930b109863f 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -1286,6 +1286,8 @@ pattern needs to support both a 32- and a 64-bit mode. @hook TARGET_MANGLE_TYPE +@hook TARGET_EMIT_SUPPORT_TINFOS + @node Type Layout @section Layout of Source Language Data Types diff --git a/gcc/target.def b/gcc/target.def index db8af0cbe81..4b2c53aba14 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -2606,6 +2606,19 @@ types.", const char *, (const_tree type), hook_constcharptr_const_tree_null) +/* Temporarily add conditional target specific types for the purpose of + emitting C++ fundamental type tinfos. */ +DEFHOOK +(emit_support_tinfos, + "If your target defines any fundamental types which depend on ISA flags,\n\ +they might need C++ tinfo symbols in libsupc++/libstdc++ regardless of\n\ +ISA flags the library is compiled with.\n\ +This hook allows creating tinfo symbols even for those cases, by temporarily\n\ +creating each corresponding fundamental type trees, calling the\n\ +@var{callback} function on it and setting the type back to @code{nullptr}.", + void, (emit_support_tinfos_callback callback), + default_emit_support_tinfos) + /* Make any adjustments to libfunc names needed for this target. */ DEFHOOK (init_libfuncs, diff --git a/gcc/target.h b/gcc/target.h index fdb364ca451..39de5226026 100644 --- a/gcc/target.h +++ b/gcc/target.h @@ -260,6 +260,8 @@ enum poly_value_estimate_kind POLY_VALUE_LIKELY }; +typedef void (*emit_support_tinfos_callback) (tree); + extern bool verify_type_context (location_t, type_context_kind, const_tree, bool = false); diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc index fe0116521fe..ea1a17cb1ab 100644 --- a/gcc/targhooks.cc +++ b/gcc/targhooks.cc @@ -752,6 +752,11 @@ default_builtin_reciprocal (tree) return NULL_TREE; } +void +default_emit_support_tinfos (emit_support_tinfos_callback) +{ +} + bool hook_bool_CUMULATIVE_ARGS_arg_info_false (cumulative_args_t, const function_arg_info &) diff --git a/gcc/targhooks.h b/gcc/targhooks.h index a1df260f548..8725f1bb7d6 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -98,6 +98,8 @@ extern int default_builtin_vectorization_cost (enum vect_cost_for_stmt, tree, in extern tree default_builtin_reciprocal (tree); +extern void default_emit_support_tinfos (emit_support_tinfos_callback); + extern HOST_WIDE_INT default_static_rtx_alignment (machine_mode); extern HOST_WIDE_INT default_constant_alignment (const_tree, HOST_WIDE_INT); extern HOST_WIDE_INT constant_alignment_word_strings (const_tree,