From: Nathan Sidwell Date: Wed, 22 Jul 2020 15:20:31 +0000 (-0700) Subject: c++: More cleanups for modern C++ X-Git-Tag: upstream/12.2.0~14680 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=0f32c94fc72313798b3a9033c92ceb34f7b7febc;p=platform%2Fupstream%2Fgcc.git c++: More cleanups for modern C++ Here are some more places where we can declare variables at the assignment point, rather than use C89. Also, let's name our variables by what they contain -- the register allocator is perfectly able to track liveness for us. gcc/cp/ * decl.c (decls_match): Move variables into scopes they're needed in. (duplicate_decls): Use STRIP_TEMPLATE. (build_typename_type): Move var decls to their assignments. (begin_function_body): Likewise. * decl2.c (get_guard): Likewise. (mark_used): Use true for truthiness. * error.c (dump_aggr_type): Hold the decl in a var called 'decl', not 'name'. --- diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 7d71745..de53a7b 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -974,12 +974,6 @@ decls_match (tree newdecl, tree olddecl, bool record_versions /* = true */) if (TREE_CODE (newdecl) == FUNCTION_DECL) { - tree f1 = TREE_TYPE (newdecl); - tree f2 = TREE_TYPE (olddecl); - tree p1 = TYPE_ARG_TYPES (f1); - tree p2 = TYPE_ARG_TYPES (f2); - tree r2; - /* Specializations of different templates are different functions even if they have the same type. */ tree t1 = (DECL_USE_TEMPLATE (newdecl) @@ -1002,14 +996,20 @@ decls_match (tree newdecl, tree olddecl, bool record_versions /* = true */) && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl)) return 0; + tree f1 = TREE_TYPE (newdecl); + tree f2 = TREE_TYPE (olddecl); if (TREE_CODE (f1) != TREE_CODE (f2)) return 0; /* A declaration with deduced return type should use its pre-deduction type for declaration matching. */ - r2 = fndecl_declared_return_type (olddecl); + tree r2 = fndecl_declared_return_type (olddecl); + tree r1 = fndecl_declared_return_type (newdecl); + + tree p1 = TYPE_ARG_TYPES (f1); + tree p2 = TYPE_ARG_TYPES (f2); - if (same_type_p (TREE_TYPE (f1), r2)) + if (same_type_p (r1, r2)) { if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl) && fndecl_built_in_p (olddecl)) @@ -2457,14 +2457,7 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend) || (TREE_CODE (olddecl) == TEMPLATE_DECL && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL)))) - { - tree fn = olddecl; - - if (TREE_CODE (fn) == TEMPLATE_DECL) - fn = DECL_TEMPLATE_RESULT (olddecl); - - new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn); - } + new_redefines_gnu_inline = GNU_INLINE_P (STRIP_TEMPLATE (olddecl)); if (!new_redefines_gnu_inline) { @@ -3852,11 +3845,7 @@ tree build_typename_type (tree context, tree name, tree fullname, enum tag_types tag_type) { - tree t; - tree d; typename_info ti; - tree *e; - hashval_t hash; if (typename_htab == NULL) typename_htab = hash_table::create_ggc (61); @@ -3868,11 +3857,12 @@ build_typename_type (tree context, tree name, tree fullname, ti.class_p = (tag_type == class_type || tag_type == record_type || tag_type == union_type); - hash = (htab_hash_pointer (ti.scope) - ^ htab_hash_pointer (ti.name)); + hashval_t hash = (htab_hash_pointer (ti.scope) + ^ htab_hash_pointer (ti.name)); /* See if we already have this type. */ - e = typename_htab->find_slot_with_hash (&ti, hash, INSERT); + tree *e = typename_htab->find_slot_with_hash (&ti, hash, INSERT); + tree t = *e; if (*e) t = *e; else @@ -3885,10 +3875,10 @@ build_typename_type (tree context, tree name, tree fullname, TYPENAME_IS_CLASS_P (t) = ti.class_p; /* Build the corresponding TYPE_DECL. */ - d = build_decl (input_location, TYPE_DECL, name, t); - TYPE_NAME (TREE_TYPE (d)) = d; - TYPE_STUB_DECL (TREE_TYPE (d)) = d; - DECL_CONTEXT (d) = FROB_CONTEXT (context); + tree d = build_decl (input_location, TYPE_DECL, name, t); + TYPE_NAME (t) = d; + TYPE_STUB_DECL (t) = d; + DECL_CONTEXT (d) = ti.scope; DECL_ARTIFICIAL (d) = 1; /* Store it in the hash table. */ @@ -4061,9 +4051,6 @@ tree make_unbound_class_template (tree context, tree name, tree parm_list, tsubst_flags_t complain) { - tree t; - tree d; - if (TYPE_P (name)) name = TYPE_IDENTIFIER (name); else if (DECL_P (name)) @@ -4108,16 +4095,16 @@ make_unbound_class_template (tree context, tree name, tree parm_list, } /* Build the UNBOUND_CLASS_TEMPLATE. */ - t = cxx_make_type (UNBOUND_CLASS_TEMPLATE); + tree t = cxx_make_type (UNBOUND_CLASS_TEMPLATE); TYPE_CONTEXT (t) = FROB_CONTEXT (context); TREE_TYPE (t) = NULL_TREE; SET_TYPE_STRUCTURAL_EQUALITY (t); /* Build the corresponding TEMPLATE_DECL. */ - d = build_decl (input_location, TEMPLATE_DECL, name, t); - TYPE_NAME (TREE_TYPE (d)) = d; - TYPE_STUB_DECL (TREE_TYPE (d)) = d; - DECL_CONTEXT (d) = FROB_CONTEXT (context); + tree d = build_decl (input_location, TEMPLATE_DECL, name, t); + TYPE_NAME (t) = d; + TYPE_STUB_DECL (t) = d; + DECL_CONTEXT (d) = TYPE_CONTEXT (t); DECL_ARTIFICIAL (d) = 1; DECL_TEMPLATE_PARMS (d) = parm_list; @@ -16819,8 +16806,6 @@ finish_destructor_body (void) tree begin_function_body (void) { - tree stmt; - if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl)) return NULL_TREE; @@ -16832,7 +16817,7 @@ begin_function_body (void) operation of dwarfout.c. */ keep_next_level (true); - stmt = begin_compound_stmt (BCS_FN_BODY); + tree stmt = begin_compound_stmt (BCS_FN_BODY); if (processing_template_decl) /* Do nothing now. */; diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 5bada50..33c8377 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -3294,11 +3294,8 @@ copy_linkage (tree guard, tree decl) tree get_guard (tree decl) { - tree sname; - tree guard; - - sname = mangle_guard_variable (decl); - guard = get_global_binding (sname); + tree sname = mangle_guard_variable (decl); + tree guard = get_global_binding (sname); if (! guard) { tree guard_type; @@ -5536,10 +5533,11 @@ mark_used (tree decl, tsubst_flags_t complain) return true; /* Set TREE_USED for the benefit of -Wunused. */ - TREE_USED (decl) = 1; + TREE_USED (decl) = true; + /* And for structured bindings also the underlying decl. */ if (DECL_DECOMPOSITION_P (decl) && DECL_DECOMP_BASE (decl)) - TREE_USED (DECL_DECOMP_BASE (decl)) = 1; + TREE_USED (DECL_DECOMP_BASE (decl)) = true; if (TREE_CODE (decl) == TEMPLATE_DECL) return true; diff --git a/gcc/cp/error.c b/gcc/cp/error.c index 0d6375e..ecb41e8 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -701,7 +701,6 @@ class_key_or_enum_as_string (tree t) static void dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags) { - tree name; const char *variety = class_key_or_enum_as_string (t); int typdef = 0; int tmplate = 0; @@ -711,23 +710,23 @@ dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags) if (flags & TFF_CLASS_KEY_OR_ENUM) pp_cxx_ws_string (pp, variety); - name = TYPE_NAME (t); + tree decl = TYPE_NAME (t); - if (name) + if (decl) { - typdef = (!DECL_ARTIFICIAL (name) + typdef = (!DECL_ARTIFICIAL (decl) /* An alias specialization is not considered to be a typedef. */ && !alias_template_specialization_p (t, nt_opaque)); if ((typdef && ((flags & TFF_CHASE_TYPEDEF) - || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name) - && DECL_TEMPLATE_INFO (name)))) - || DECL_SELF_REFERENCE_P (name)) + || (!flag_pretty_templates && DECL_LANG_SPECIFIC (decl) + && DECL_TEMPLATE_INFO (decl)))) + || DECL_SELF_REFERENCE_P (decl)) { t = TYPE_MAIN_VARIANT (t); - name = TYPE_NAME (t); + decl = TYPE_NAME (t); typdef = 0; } @@ -737,7 +736,7 @@ dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags) || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))); if (! (flags & TFF_UNQUALIFIED_NAME)) - dump_scope (pp, CP_DECL_CONTEXT (name), flags | TFF_SCOPE); + dump_scope (pp, CP_DECL_CONTEXT (decl), flags | TFF_SCOPE); flags &= ~TFF_UNQUALIFIED_NAME; if (tmplate) { @@ -747,9 +746,8 @@ dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags) while (DECL_TEMPLATE_INFO (tpl)) tpl = DECL_TI_TEMPLATE (tpl); - name = tpl; + decl = tpl; } - name = DECL_NAME (name); } if (LAMBDA_TYPE_P (t)) @@ -762,7 +760,7 @@ dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags) flags); pp_greater (pp); } - else if (!name || IDENTIFIER_ANON_P (name)) + else if (!decl || IDENTIFIER_ANON_P (DECL_NAME (decl))) { if (flags & TFF_CLASS_KEY_OR_ENUM) pp_string (pp, M_("")); @@ -770,7 +768,7 @@ dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags) pp_printf (pp, M_(""), variety); } else - pp_cxx_tree_identifier (pp, name); + pp_cxx_tree_identifier (pp, DECL_NAME (decl)); if (tmplate) dump_template_parms (pp, TYPE_TEMPLATE_INFO (t),