From 08fb13163ce5e7dcf61c3ce898a63bb54f1b6d3d Mon Sep 17 00:00:00 2001 From: Nathan Sidwell Date: Fri, 30 Jun 2017 18:46:01 +0000 Subject: [PATCH] config-lang.in (gtfiles): Add cp/lex.c. * config-lang.in (gtfiles): Add cp/lex.c. * cp-tree.h (mangle_convop_name_for_type): Rename ... (make_conv_op_name): ... here. Move to lex. * lambda.c (maybe_add_lambda_conv_op): Update. * parser.c (cp_parser_conversion_function_id): Update. * pt.c (tsubst_decl, tsubst_baselink, tsubst_copy, tsubst_copy_and_build): Update. * semantics.c (apply_deduced_return_type): Update. * mangle.c (conv_type_hasher, conv_type_names, mangle_conv_op_name_for_type): Move to ... * lex.c (conv_type_hasher, conv_type_names, make_convop_name): ... here. Rename. * libcp1plugin.cc (plugin_build_decl): Use make_conv_op_name. (plugin_build_dependent_expr): Likewise. From-SVN: r249852 --- gcc/cp/ChangeLog | 15 +++++++++ gcc/cp/config-lang.in | 2 +- gcc/cp/cp-tree.h | 2 +- gcc/cp/lambda.c | 2 +- gcc/cp/lex.c | 70 ++++++++++++++++++++++++++++++++++++++++++ gcc/cp/mangle.c | 69 ----------------------------------------- gcc/cp/parser.c | 2 +- gcc/cp/pt.c | 8 ++--- gcc/cp/semantics.c | 2 +- libcc1/ChangeLog | 5 +++ libcc1/libcp1plugin.cc | 4 +-- 11 files changed, 101 insertions(+), 80 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 6c230a9c4c5..ff57214535f 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,18 @@ +2017-06-30 Nathan Sidwell + + * config-lang.in (gtfiles): Add cp/lex.c. + * cp-tree.h (mangle_convop_name_for_type): Rename ... + (make_conv_op_name): ... here. Move to lex. + * lambda.c (maybe_add_lambda_conv_op): Update. + * parser.c (cp_parser_conversion_function_id): Update. + * pt.c (tsubst_decl, tsubst_baselink, tsubst_copy, + tsubst_copy_and_build): Update. + * semantics.c (apply_deduced_return_type): Update. + * mangle.c (conv_type_hasher, conv_type_names, + mangle_conv_op_name_for_type): Move to ... + * lex.c (conv_type_hasher, conv_type_names, make_convop_name): + ... here. Rename. + 2017-06-30 David Malcolm PR c++/80014 diff --git a/gcc/cp/config-lang.in b/gcc/cp/config-lang.in index d0a96a07b5a..c009570b63d 100644 --- a/gcc/cp/config-lang.in +++ b/gcc/cp/config-lang.in @@ -45,7 +45,7 @@ gtfiles="\ \$(srcdir)/cp/except.c \ \$(srcdir)/cp/friend.c \ \$(srcdir)/cp/init.c \ -\$(srcdir)/cp/lambda.c \ +\$(srcdir)/cp/lambda.c \$(srcdir)/cp/lex.c \ \$(srcdir)/cp/mangle.c \$(srcdir)/cp/method.c \ \$(srcdir)/cp/name-lookup.c \ \$(srcdir)/cp/parser.c \$(srcdir)/cp/pt.c \ diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 4b5ff69a1a8..abaef68fda9 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -6326,6 +6326,7 @@ extern void yyungetc (int, int); extern tree unqualified_name_lookup_error (tree, location_t = UNKNOWN_LOCATION); extern tree unqualified_fn_lookup_error (cp_expr); +extern tree make_conv_op_name (tree); extern tree build_lang_decl (enum tree_code, tree, tree); extern tree build_lang_decl_loc (location_t, enum tree_code, tree, tree); extern void retrofit_lang_decl (tree); @@ -7180,7 +7181,6 @@ extern tree mangle_vtbl_for_type (tree); extern tree mangle_vtt_for_type (tree); extern tree mangle_ctor_vtbl_for_type (tree, tree); extern tree mangle_thunk (tree, int, tree, tree, tree); -extern tree mangle_conv_op_name_for_type (tree); extern tree mangle_guard_variable (tree); extern tree mangle_tls_init_fn (tree); extern tree mangle_tls_wrapper_fn (tree); diff --git a/gcc/cp/lambda.c b/gcc/cp/lambda.c index 41d4921c1db..0e02375fa1b 100644 --- a/gcc/cp/lambda.c +++ b/gcc/cp/lambda.c @@ -1088,7 +1088,7 @@ maybe_add_lambda_conv_op (tree type) /* First build up the conversion op. */ tree rettype = build_pointer_type (stattype); - tree name = mangle_conv_op_name_for_type (rettype); + tree name = make_conv_op_name (rettype); tree thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST); tree fntype = build_method_type_directly (thistype, rettype, void_list_node); tree convfn = build_lang_decl (FUNCTION_DECL, name, fntype); diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c index d763716bfa3..961b705a546 100644 --- a/gcc/cp/lex.c +++ b/gcc/cp/lex.c @@ -531,6 +531,74 @@ unqualified_fn_lookup_error (cp_expr name_expr) return unqualified_name_lookup_error (name, loc); } +struct conv_type_hasher : ggc_ptr_hash +{ + static hashval_t hash (tree); + static bool equal (tree, tree); +}; + +/* This hash table maps TYPEs to the IDENTIFIER for a conversion + operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the + TYPE. */ + +static GTY (()) hash_table *conv_type_names; + +/* Hash a node (VAL1) in the table. */ + +hashval_t +conv_type_hasher::hash (tree val) +{ + return (hashval_t) TYPE_UID (TREE_TYPE (val)); +} + +/* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */ + +bool +conv_type_hasher::equal (tree val1, tree val2) +{ + return TREE_TYPE (val1) == val2; +} + +/* Return an identifier for a conversion operator to TYPE. We can + get from the returned identifier to the type. */ + +tree +make_conv_op_name (tree type) +{ + tree *slot; + tree identifier; + + if (type == error_mark_node) + return error_mark_node; + + if (conv_type_names == NULL) + conv_type_names = hash_table::create_ggc (31); + + slot = conv_type_names->find_slot_with_hash (type, + (hashval_t) TYPE_UID (type), + INSERT); + identifier = *slot; + if (!identifier) + { + char buffer[64]; + + /* Create a unique name corresponding to TYPE. */ + sprintf (buffer, "operator %lu", + (unsigned long) conv_type_names->elements ()); + identifier = get_identifier (buffer); + *slot = identifier; + + /* Hang TYPE off the identifier so it can be found easily later + when performing conversions. */ + TREE_TYPE (identifier) = type; + + /* Set the identifier kind so we know later it's a conversion. */ + set_identifier_kind (identifier, cik_conv_op); + } + + return identifier; +} + /* Wrapper around build_lang_decl_loc(). Should gradually move to build_lang_decl_loc() and then rename build_lang_decl_loc() back to build_lang_decl(). */ @@ -799,3 +867,5 @@ in_main_input_context (void) else return filename_cmp (main_input_filename, LOCATION_FILE (input_location)) == 0; } + +#include "gt-cp-lex.h" diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c index 0ba33753339..8bb26a9902b 100644 --- a/gcc/cp/mangle.c +++ b/gcc/cp/mangle.c @@ -4176,75 +4176,6 @@ mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset, return result; } -struct conv_type_hasher : ggc_ptr_hash -{ - static hashval_t hash (tree); - static bool equal (tree, tree); -}; - -/* This hash table maps TYPEs to the IDENTIFIER for a conversion - operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the - TYPE. */ - -static GTY (()) hash_table *conv_type_names; - -/* Hash a node (VAL1) in the table. */ - -hashval_t -conv_type_hasher::hash (tree val) -{ - return (hashval_t) TYPE_UID (TREE_TYPE (val)); -} - -/* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */ - -bool -conv_type_hasher::equal (tree val1, tree val2) -{ - return TREE_TYPE (val1) == val2; -} - -/* Return an identifier for the mangled unqualified name for a - conversion operator to TYPE. This mangling is not specified by the - ABI spec; it is only used internally. */ - -tree -mangle_conv_op_name_for_type (const tree type) -{ - tree *slot; - tree identifier; - - if (type == error_mark_node) - return error_mark_node; - - if (conv_type_names == NULL) - conv_type_names = hash_table::create_ggc (31); - - slot = conv_type_names->find_slot_with_hash (type, - (hashval_t) TYPE_UID (type), - INSERT); - identifier = *slot; - if (!identifier) - { - char buffer[64]; - - /* Create a unique name corresponding to TYPE. */ - sprintf (buffer, "operator %lu", - (unsigned long) conv_type_names->elements ()); - identifier = get_identifier (buffer); - *slot = identifier; - - /* Hang TYPE off the identifier so it can be found easily later - when performing conversions. */ - TREE_TYPE (identifier) = type; - - /* Set the identifier kind so we know later it's a conversion. */ - set_identifier_kind (identifier, cik_conv_op); - } - - return identifier; -} - /* Handle ABI backwards compatibility for past bugs where we didn't call check_abi_tags in places where it's needed: call check_abi_tags and warn if it makes a difference. If FOR_DECL is non-null, it's the declaration diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index c6a8e374d8b..ea5a5103565 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -14081,7 +14081,7 @@ cp_parser_conversion_function_id (cp_parser* parser) /* If the TYPE is invalid, indicate failure. */ if (type == error_mark_node) return error_mark_node; - return mangle_conv_op_name_for_type (type); + return make_conv_op_name (type); } /* Parse a conversion-type-id: diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 6b6a1a694b7..bd02951cb85 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -12385,7 +12385,7 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) if (member && DECL_CONV_FN_P (r)) /* Type-conversion operator. Reconstruct the name, in case it's the name of one of the template's parameters. */ - DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type)); + DECL_NAME (r) = make_conv_op_name (TREE_TYPE (type)); DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args, complain, t); @@ -14242,7 +14242,7 @@ tsubst_baselink (tree baselink, tree object_type, tree name = OVL_NAME (fns); if (IDENTIFIER_CONV_OP_P (name)) - name = mangle_conv_op_name_for_type (optype); + name = make_conv_op_name (optype); baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1); if (!baselink) @@ -15032,7 +15032,7 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl) if (IDENTIFIER_CONV_OP_P (t)) { tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - return mangle_conv_op_name_for_type (new_type); + return make_conv_op_name (new_type); } else return t; @@ -16665,7 +16665,7 @@ tsubst_copy_and_build (tree t, if (IDENTIFIER_CONV_OP_P (t)) { tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - t = mangle_conv_op_name_for_type (new_type); + t = make_conv_op_name (new_type); } /* Look up the name. */ diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index e13943aaa32..f6177b32a32 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -9399,7 +9399,7 @@ apply_deduced_return_type (tree fco, tree return_type) } if (DECL_CONV_FN_P (fco)) - DECL_NAME (fco) = mangle_conv_op_name_for_type (return_type); + DECL_NAME (fco) = make_conv_op_name (return_type); TREE_TYPE (fco) = change_return_type (return_type, TREE_TYPE (fco)); diff --git a/libcc1/ChangeLog b/libcc1/ChangeLog index 6a2d6238004..ec795c78fcd 100644 --- a/libcc1/ChangeLog +++ b/libcc1/ChangeLog @@ -1,3 +1,8 @@ +2017-06-30 Nathan Sidwell + + * libcp1plugin.cc (plugin_build_decl): Use make_conv_op_name. + (plugin_build_dependent_expr): Likewise. + 2017-06-26 Nathan Sidwell * libcp1plugin.cc (plugin_build_decl): Don't set diff --git a/libcc1/libcp1plugin.cc b/libcc1/libcp1plugin.cc index bbe32e38bdc..7397888373b 100644 --- a/libcc1/libcp1plugin.cc +++ b/libcc1/libcp1plugin.cc @@ -1321,7 +1321,7 @@ plugin_build_decl (cc1_plugin::connection *self, opcode = ARRAY_REF; break; case CHARS2 ('c', 'v'): // operator (conversion operator) - identifier = mangle_conv_op_name_for_type (TREE_TYPE (sym_type)); + identifier = make_conv_op_name (TREE_TYPE (sym_type)); break; // C++11-only: case CHARS2 ('l', 'i'): // operator "" @@ -2622,7 +2622,7 @@ plugin_build_dependent_expr (cc1_plugin::connection *self, break; case CHARS2 ('c', 'v'): // operator (conversion operator) convop = true; - identifier = mangle_conv_op_name_for_type (conv_type); + identifier = make_conv_op_name (conv_type); break; // C++11-only: case CHARS2 ('l', 'i'): // operator "" -- 2.30.2