diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 6367f519dcef..676b431b1ffd 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,15 @@ +2009-10-30 Jerry Quinn + + * mangle.c (mangle_type_string_for_rtti): Revert 153734. + (needs_fake_anon): Likewise. + (write_name): Likewise. + (write_nested_name): Likewise. + * cp-tree.h (mangle_type_string_for_rtti): Likewise. + (get_anonymous_namespace): Likewise. + * name-lookup.c (get_anonymous_namespace_name): Likewise. + * rtti.c (tinfo_name): Likewise. + (tinfo_base_init): Likewise. + 2009-10-30 Dodji Seketeli PR c++/41863 diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 4ffd899ef094..5c51a6fd7b62 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -4517,6 +4517,7 @@ extern tree type_promotes_to (tree); extern tree perform_qualification_conversions (tree, tree); /* in name-lookup.c */ +extern tree get_anonymous_namespace_name (void); extern tree pushdecl (tree); extern tree pushdecl_maybe_friend (tree, bool); extern void maybe_push_cleanup_level (tree); @@ -5298,7 +5299,7 @@ extern tree merge_exception_specifiers (tree, tree); /* in mangle.c */ extern void init_mangle (void); extern void mangle_decl (tree); -extern const char *mangle_type_string (tree); +extern const char *mangle_type_string_for_rtti (tree); extern tree mangle_typeinfo_for_type (tree); extern tree mangle_typeinfo_string_for_type (tree); extern tree mangle_vtbl_for_type (tree); diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c index 7489665bfa8d..874df748f81d 100644 --- a/gcc/cp/mangle.c +++ b/gcc/cp/mangle.c @@ -105,6 +105,10 @@ typedef struct GTY(()) globals { static GTY (()) globals G; +/* Whether or not to pretend that a static function is in an anonymous + namespace. */ +static bool fake_anon_scope; + /* The obstack on which we build mangled names. */ static struct obstack *mangle_obstack; @@ -730,6 +734,20 @@ write_encoding (const tree decl) } } +/* Since we now use strcmp to compare typeinfos on all targets because of + the RTLD_LOCAL problem, we need to munge the typeinfo name used for + local classes of static functions to fix g++.dg/abi/local1.C. We do + that by pretending that the function is in an anonymous namespace. */ + +static bool +needs_fake_anon (const_tree decl) +{ + /* Pretend there's an anonymous namespace right around a static + function if we're mangling for RTTI. */ + return (fake_anon_scope && !TREE_PUBLIC (decl) + && TREE_CODE (decl) == FUNCTION_DECL); +} + /* Lambdas can have a bit more context for mangling, specifically VAR_DECL or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */ @@ -773,13 +791,18 @@ write_name (tree decl, const int ignore_local_scope) context = decl_mangling_context (decl); + gcc_assert (context != NULL_TREE); + + /* If we need a fake anonymous namespace, force the nested name path. */ + if (needs_fake_anon (decl) && context == global_namespace) + context = error_mark_node; + /* A decl in :: or ::std scope is treated specially. The former is mangled using or , the latter with a special substitution. Also, a name that is directly in a local function scope is also mangled with rather than a full . */ - if (context == NULL - || context == global_namespace + if (context == global_namespace || DECL_NAMESPACE_STD_P (context) || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL)) { @@ -797,6 +820,9 @@ write_name (tree decl, const int ignore_local_scope) } else { + if (context == error_mark_node) + context = global_namespace; + /* Handle local names, unless we asked not to (that is, invoked under , to handle only the part of the name under the local scope). */ @@ -809,10 +835,10 @@ write_name (tree decl, const int ignore_local_scope) directly in that function's scope, either decl or one of its enclosing scopes. */ tree local_entity = decl; - while (context != NULL && context != global_namespace) + while (context != global_namespace) { /* Make sure we're always dealing with decls. */ - if (context != NULL && TYPE_P (context)) + if (TYPE_P (context)) context = TYPE_NAME (context); /* Is this a function? */ if (TREE_CODE (context) == FUNCTION_DECL @@ -857,7 +883,6 @@ write_unscoped_name (const tree decl) /* If not, it should be either in the global namespace, or directly in a local function scope. */ gcc_assert (context == global_namespace - || context != NULL || TREE_CODE (context) == FUNCTION_DECL); write_unqualified_name (decl); @@ -929,6 +954,9 @@ write_nested_name (const tree decl) { /* No, just use */ write_prefix (DECL_CONTEXT (decl)); + if (needs_fake_anon (decl)) + /* Pretend this static function is in an anonymous namespace. */ + write_source_name (get_anonymous_namespace_name ()); write_unqualified_name (decl); } write_char ('E'); @@ -2984,15 +3012,18 @@ mangle_decl (const tree decl) SET_DECL_ASSEMBLER_NAME (decl, id); } -/* Generate the mangled representation of TYPE. */ +/* Generate the mangled representation of TYPE for the typeinfo name. */ const char * -mangle_type_string (const tree type) +mangle_type_string_for_rtti (const tree type) { const char *result; start_mangling (type); + /* Mangle in a fake anonymous namespace if necessary. */ + fake_anon_scope = true; write_type (type); + fake_anon_scope = false; result = finish_mangling (/*warn=*/false); if (DEBUG_MANGLE) fprintf (stderr, "mangle_type_string = '%s'\n\n", result); diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c index 8089427f956e..9a6991269f8f 100644 --- a/gcc/cp/name-lookup.c +++ b/gcc/cp/name-lookup.c @@ -62,19 +62,14 @@ static GTY(()) tree anonymous_namespace_name; /* Initialize anonymous_namespace_name if necessary, and return it. */ -static tree +tree get_anonymous_namespace_name (void) { if (!anonymous_namespace_name) { /* The anonymous namespace has to have a unique name if typeinfo objects are being compared by name. */ - if (! flag_weak || ! SUPPORTS_ONE_ONLY) - anonymous_namespace_name = get_file_function_name ("N"); - else - /* The demangler expects anonymous namespaces to be called - something starting with '_GLOBAL__N_'. */ - anonymous_namespace_name = get_identifier ("_GLOBAL__N_1"); + anonymous_namespace_name = get_file_function_name ("N"); } return anonymous_namespace_name; } diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c index fad3144a84ba..8dde479a6c48 100644 --- a/gcc/cp/rtti.c +++ b/gcc/cp/rtti.c @@ -102,7 +102,7 @@ VEC(tree,gc) *unemitted_tinfo_decls; static GTY (()) VEC(tinfo_s,gc) *tinfo_descs; static tree ifnonnull (tree, tree); -static tree tinfo_name (tree, bool); +static tree tinfo_name (tree); static tree build_dynamic_cast_1 (tree, tree, tsubst_flags_t); static tree throw_bad_cast (void); static tree throw_bad_typeid (void); @@ -349,30 +349,16 @@ build_typeid (tree exp) return exp; } -/* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that - comparisons will be done by pointer rather than string comparison. */ +/* Generate the NTBS name of a type. */ static tree -tinfo_name (tree type, bool mark_private) +tinfo_name (tree type) { const char *name; - int length; tree name_string; - name = mangle_type_string (type); - length = strlen (name); - - if (mark_private) - { - /* Inject '*' at beginning of name to force pointer comparison. */ - char* buf = (char*) XALLOCAVEC (char, length + 1); - buf[0] = '*'; - memcpy (buf + 1, name, length); - name_string = build_string (length + 1, buf); - } - else - name_string = build_string (length, name); - - return fix_string_type (name_string); + name = mangle_type_string_for_rtti (type); + name_string = fix_string_type (build_string (strlen (name) + 1, name)); + return name_string; } /* Return a VAR_DECL for the internal ABI defined type_info object for @@ -853,12 +839,13 @@ tinfo_base_init (tinfo_s *ti, tree target) tree vtable_ptr; { - tree name_name, name_string; + tree name_name; /* Generate the NTBS array variable. */ tree name_type = build_cplus_array_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST), NULL_TREE); + tree name_string = tinfo_name (target); /* Determine the name of the variable -- and remember with which type it is associated. */ @@ -875,7 +862,6 @@ tinfo_base_init (tinfo_s *ti, tree target) DECL_TINFO_P (name_decl) = 1; set_linkage_according_to_type (target, name_decl); import_export_decl (name_decl); - name_string = tinfo_name (target, !TREE_PUBLIC (name_decl)); DECL_INITIAL (name_decl) = name_string; mark_used (name_decl); pushdecl_top_level_and_finish (name_decl, name_string); diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 972a44d88a03..a59710da9ef4 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,9 @@ +2009-10-30 Jerry Quinn + + * libsupc++/tinfo.cc (operator=(const type_info&)): Revert 153734. + * libsupc++/typeinfo (type_info::name()): Likewise. + * libsupc++/tinfo2.cc (before): Likewise. + 2009-10-28 Jerry Quinn * libsupc++/tinfo.cc (operator=(const type_info&)): Compare by diff --git a/libstdc++-v3/libsupc++/tinfo.cc b/libstdc++-v3/libsupc++/tinfo.cc index d939a3fdab7c..1ce6f8f46ab8 100644 --- a/libstdc++-v3/libsupc++/tinfo.cc +++ b/libstdc++-v3/libsupc++/tinfo.cc @@ -41,8 +41,7 @@ operator== (const std::type_info& arg) const #if __GXX_MERGED_TYPEINFO_NAMES return name () == arg.name (); #else - return (&arg == this) - || (name ()[0] != '*' && (__builtin_strcmp (name (), arg.name ()) == 0)); + return (&arg == this) || (__builtin_strcmp (name (), arg.name ()) == 0); #endif } diff --git a/libstdc++-v3/libsupc++/tinfo2.cc b/libstdc++-v3/libsupc++/tinfo2.cc index 0182c6cc0deb..4b01037f3b96 100644 --- a/libstdc++-v3/libsupc++/tinfo2.cc +++ b/libstdc++-v3/libsupc++/tinfo2.cc @@ -37,8 +37,7 @@ type_info::before (const type_info &arg) const #if __GXX_MERGED_TYPEINFO_NAMES return name () < arg.name (); #else - return (name ()[0] == '*') ? name () < arg.name () - : __builtin_strcmp (name (), arg.name ()) < 0; + return __builtin_strcmp (name (), arg.name ()) < 0; #endif } diff --git a/libstdc++-v3/libsupc++/typeinfo b/libstdc++-v3/libsupc++/typeinfo index f7f9d4e2cc2f..4c470430deff 100644 --- a/libstdc++-v3/libsupc++/typeinfo +++ b/libstdc++-v3/libsupc++/typeinfo @@ -94,7 +94,7 @@ namespace std /** Returns an @e implementation-defined byte string; this is not * portable between compilers! */ const char* name() const - { return __name[0] == '*' ? __name + 1 : __name; } + { return __name; } #if !__GXX_TYPEINFO_EQUALITY_INLINE // In old abi, or when weak symbols are not supported, there can @@ -110,15 +110,12 @@ namespace std // we can run into cases where type_info names aren't merged, // so we still need to do string comparison. bool before(const type_info& __arg) const - { return (__name[0] == '*' && __arg.__name[0] == '*') - ? __name < __arg.__name - : __builtin_strcmp (__name, __arg.__name) < 0; } + { return __builtin_strcmp (__name, __arg.__name) < 0; } bool operator==(const type_info& __arg) const { return ((__name == __arg.__name) - || (__name[0] != '*' && - __builtin_strcmp (__name, __arg.__name) == 0)); + || __builtin_strcmp (__name, __arg.__name) == 0); } #else // On some targets we can rely on type_info's NTBS being unique,