From 499193a692efa33c9b2fe3ad8da0f4d5e5fd0e0c Mon Sep 17 00:00:00 2001 From: Nathan Sidwell Date: Wed, 3 Mar 2021 11:22:56 -0800 Subject: [PATCH] c++: Defer specialization registration [PR 99170] This defers inserting specializations into the specialization table, until we have completed their streaming. When streaming a cluster we ensure that all imports are populated before any of the cluster, so they need no visibility of other specializations. Further within the same import, we've already partitioned the graph, so no earlier cluster can be refering to a specialization in a later cluster. Inserting them early causes problems when other specializations of the same template are inserted. (This doesn't fix 99170, but is a necessary change for that PR). Earlier on, I had less deferred processing, but it has become clearer that deferred worklists are the right way of handling a few things. This patch highlights a fixme, in that we're streaming a key twice, and need not do that, but I wanted to get correctness first. Besides the second streaming will end up being a back reference, which is of course much cheaper than a by-value stream. PR c++/99170 gcc/cp/ * module.cc (trees_out::decl_value): Stream specialization keys after decl. (trees_in::decl_value): Stream them back and insert after completing the decl. (trees_out::key_mergeable): Drop some streaming here ... (trees_in::key_mergeable): ... and here. Don't insert into specialization tables. --- gcc/cp/module.cc | 94 ++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 58 insertions(+), 36 deletions(-) diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc index 3117282..b068ace 100644 --- a/gcc/cp/module.cc +++ b/gcc/cp/module.cc @@ -7808,7 +7808,31 @@ trees_out::decl_value (tree decl, depset *dep) } if (!is_key_order ()) - tree_node (get_constraints (decl)); + { + if (mk & MK_template_mask + || mk == MK_partial + || mk == MK_friend_spec) + { + if (mk != MK_partial) + { + // FIXME: We should make use of the merge-key by + // exposing it outside of key_mergeable. But this gets + // the job done. + auto *entry = reinterpret_cast (dep->deps[0]); + + if (streaming_p ()) + u (get_mergeable_specialization_flags (entry->tmpl, decl)); + tree_node (entry->tmpl); + tree_node (entry->args); + } + else + { + tree_node (CLASSTYPE_TI_TEMPLATE (TREE_TYPE (inner))); + tree_node (CLASSTYPE_TI_ARGS (TREE_TYPE (inner))); + } + } + tree_node (get_constraints (decl)); + } if (streaming_p ()) { @@ -8096,7 +8120,22 @@ trees_in::decl_value () || (stub_decl && !tree_node_vals (stub_decl)))) goto bail; - tree constraints = tree_node (); + spec_entry spec; + unsigned spec_flags = 0; + if (mk & MK_template_mask + || mk == MK_partial + || mk == MK_friend_spec) + { + if (mk == MK_partial) + spec_flags = 2; + else + spec_flags = u (); + + spec.tmpl = tree_node (); + spec.args = tree_node (); + } + /* Hold constraints on the spec field, for a short while. */ + spec.spec = tree_node (); dump (dumper::TREE) && dump ("Read:%d %C:%N", tag, TREE_CODE (decl), decl); @@ -8157,8 +8196,13 @@ trees_in::decl_value () } } - if (constraints) - set_constraints (decl, constraints); + if (spec.spec) + set_constraints (decl, spec.spec); + if (mk & MK_template_mask + || mk == MK_partial) + /* Add to specialization tables now that constraints etc are + added. */ + add_mergeable_specialization (spec.tmpl, spec.args, decl, spec_flags); if (TREE_CODE (decl) == INTEGER_CST && !TREE_OVERFLOW (decl)) { @@ -8247,6 +8291,15 @@ trees_in::decl_value () decl = existing; } + if (mk == MK_friend_spec) + { + tree e = match_mergeable_specialization (true, &spec); + if (!e) + add_mergeable_specialization (spec.tmpl, spec.args, decl, spec_flags); + else if (e != existing) + set_overrun (); + } + if (is_typedef) { /* Insert the type into the array now. */ @@ -10415,8 +10468,6 @@ trees_out::key_mergeable (int tag, merge_kind mk, tree decl, tree inner, tree_node (entry->tmpl); tree_node (entry->args); - if (streaming_p ()) - u (get_mergeable_specialization_flags (entry->tmpl, decl)); if (mk & MK_tmpl_decl_mask) if (flag_concepts && TREE_CODE (inner) == VAR_DECL) { @@ -10504,16 +10555,6 @@ trees_out::key_mergeable (int tag, merge_kind mk, tree decl, tree inner, key.ret = fndecl_declared_return_type (inner); } - if (mk == MK_friend_spec) - { - gcc_checking_assert (dep && dep->is_special ()); - spec_entry *entry = reinterpret_cast (dep->deps[0]); - - tree_node (entry->tmpl); - tree_node (entry->args); - if (streaming_p ()) - u (get_mergeable_specialization_flags (entry->tmpl, decl)); - } break; case MK_field: @@ -10763,7 +10804,6 @@ trees_in::key_mergeable (int tag, merge_kind mk, tree decl, tree inner, spec_entry spec; spec.tmpl = tree_node (); spec.args = tree_node (); - unsigned flags = u (); DECL_NAME (decl) = DECL_NAME (spec.tmpl); DECL_CONTEXT (decl) = DECL_CONTEXT (spec.tmpl); @@ -10800,7 +10840,7 @@ trees_in::key_mergeable (int tag, merge_kind mk, tree decl, tree inner, remove_constraints (inner); if (!existing) - add_mergeable_specialization (spec.tmpl, spec.args, decl, flags); + ; /* We'll add to the table once read. */ else if (mk & MK_tmpl_decl_mask) { /* A declaration specialization. */ @@ -10885,8 +10925,6 @@ trees_in::key_mergeable (int tag, merge_kind mk, tree decl, tree inner, break; } } - if (!existing) - add_mergeable_specialization (key.ret, key.args, decl, 2); } else switch (TREE_CODE (container)) @@ -11054,22 +11092,6 @@ trees_in::key_mergeable (int tag, merge_kind mk, tree decl, tree inner, } } } - - if (mk == MK_friend_spec) - { - spec_entry spec; - spec.tmpl = tree_node (); - spec.args = tree_node (); - spec.spec = decl; - unsigned flags = u (); - - tree e = match_mergeable_specialization (true, &spec); - if (!e) - add_mergeable_specialization (spec.tmpl, spec.args, - existing ? existing : decl, flags); - else if (e != existing) - set_overrun (); - } } dump (dumper::MERGE) -- 2.7.4