On Sat, 12 Oct 2024, Nathaniel Shead wrote:
> This version rewords all "ignored exposures" language.
>
> I haven't fixed up the issue with DECL_TEMPLATE_INSTANTIATIONS for this
> patch. I'll try to get to that as a separate patch if I find the time,
> but it's not 100% needed here I don't think.
>
> It seems the discussion around PR115126 RE: the libgcc changes that
> people are leaning towards reverting the changes I made to the gthread
> static variables and instead having some sort of attribute to instruct
> the compiler to ignore the ODR issues; that should be relatively
> straight-forward to add (maybe something like [[gnu::ignore_tu_local]]?)
> but I'll probably handle that as a separate patch once I'm sure that's
> what we actually want to do, and would probably be worth corresponding
> with the Clang folks to see what thoughts they have.
>
> Finally, I wasn't able to work out a good way to fold non-ODR usages of
> TU-local constants early. I attempted modifying 'mark_use', which
> helped for 'constexpr' usages (though I ran into issues with e.g.
>
> constexpr int n[1] = 0;
> constexpr int x = n ? 1 : 2;
>
> segfaulting as build_address was not expecting to see a constructor
> rather than a declaration here). But I didn't look too hard into
> solving this as it appears that any modifications made by 'mark_use' are
> not actually applied to the primary template at all, and this is
> consistent across many places I investigated.
>
> Given that erroring on these cases is still the status-quo, how easy it
> is to workaround most of the time, and that I'm still not sure how to
> solve this, I've also left this as a FIXME (with an XFAILed testcase) to
> revisit later.
>
> OK for trunk?
>
> -- >8 --
>
> [basic.link] p14 lists a number of circumstances where a declaration
> naming a TU-local entity is not an exposure, notably the bodies of
> non-inline templates and friend declarations in classes. This patch
> ensures that these references do not error when exporting the module.
>
> We do need to still error on instantiation from a different module,
> however, in case this refers to a TU-local entity. As such this patch
> adds a new tree TU_LOCAL_ENTITY which is used purely as a placeholder to
> poison any attempted template instantiations that refer to it.
I'm a bit late to the party, but this is a nice patch series! I have a
couple of comments below.
>
> This is also streamed for friend decls so that merging (based on the
> index of an entity into the friend decl list) doesn't break and to
> prevent complicating the logic; I imagine this shouldn't ever come up
> though.
>
> We also add a new warning, '-Wtemplate-names-tu-local', to handle the
> case where someone accidentally refers to a TU-local value from within a
> non-inline function template. This will compile without errors as-is,
> but any attempt to instantiate the decl will fail; this warning can be
> used to ensure that this doesn't happen. Unfortunately the warning has
> quite some false positives; for instance, a user could deliberately only
> call explicit instantiations of the decl, or use 'if constexpr' to avoid
> instantiating the TU-local entity from other TUs, neither of which are
> currently detected.
>
> The main piece that this patch doesn't yet attempt to solve is ADL: as
> specified, if ADL adds an overload set that includes a translation-unit
> local entity when instantiating a template, that overload set is now
> poisoned and counts as an exposure. Unfortunately, we don't currently
> differentiate between decls that are hidden due to not being exported,
> or decls that are hidden due to being hidden friends, so this patch
> instead just keeps the current (wrong) behaviour of non-exported
> entities not being visible to ADL at all.
>
> Additionally, this patch doesn't attempt to ignore non-ODR uses of
> constants in constexpr functions or templates. The obvious approach of
> folding them early in 'mark_use' doesn't seem to work (for a variety of
> reasons), so this leaves this to a later patch to implement, as it's at
> least no worse than the current behaviour and easy enough to workaround.
>
> For completeness this patch adds a new xtreme-header testcase to ensure
> that we have no regressions with regards to exposures of TU-local
> declarations in the standard library header files. A more restrictive
> test would be to do 'export extern "C++"' here, but unfortunately the
> system headers on some targets declare TU-local entities, so we'll make
> do with checking that at least the C++ standard library headers don't
> refer to such entities.
>
> gcc/c-family/ChangeLog:
>
> * c.opt: New warning '-Wtemplate-names-tu-local'.
>
> gcc/cp/ChangeLog:
>
> * cp-objcp-common.cc (cp_tree_size): Add TU_LOCAL_ENTITY.
> * cp-tree.def (TU_LOCAL_ENTITY): New tree code.
> * cp-tree.h (struct tree_tu_local_entity): New type.
> (TU_LOCAL_ENTITY_NAME): New accessor.
> (TU_LOCAL_ENTITY_LOCATION): New accessor.
> (enum cp_tree_node_structure_enum): Add TS_CP_TU_LOCAL_ENTITY.
> (union GTY): Add tu_local_entity field.
> * module.cc (enum tree_tag): New flag DB_REFS_TU_LOCAL_BIT.
> (depset::has_defn): Override for TU-local entities.
> (depset::refs_tu_local): New accessor.
> (depset::hash::ignore_tu_local): New field.
> (depset::hash::hash): Initialize it.
> (trees_out::tree_tag::tt_tu_local): New flag.
> (trees_out::writing_local_entities): New field.
> (trees_out::is_initial_scan): New function.
> (trees_out::tu_local_count): New counter.
> (trees_out::trees_out): Initialize writing_local_entities.
> (dumper::impl::nested_name): Handle TU_LOCAL_ENTITY.
> (trees_out::instrument): Report TU-local entity counts.
> (trees_out::decl_value): Early exit for TU-local entities.
> (trees_in::decl_value): Handle typedefs of TU-local entities.
> (trees_out::decl_node): Adjust assertion to cope with early exit
> of TU-local deps. Always write TU-local entities by value.
> (trees_out::type_node): Handle TU-local types.
> (trees_out::has_tu_local_dep): New function.
> (trees_out::find_tu_local_decl): New function.
> (trees_out::tree_node): Intercept TU-local entities and write
> placeholder values for them instead of normal streaming.
> (trees_in::tree_node): Handle TU-local entities and TU-local
> template results.
> (trees_out::write_function_def): Ignore exposures in non-inline
> function bodies.
> (trees_out::write_var_def): Ignore exposures in initializers.
> (trees_out::write_class_def): Ignore exposures in friend decls.
> (trees_in::read_class_def): Skip TU-local friends.
> (trees_out::write_definition): Record whether we're writing a
> decl which refers to TU-local entities.
> (depset::hash::add_dependency): Only mark as exposure if we're not
> ignoring TU-local entities.
> (depset::hash::find_dependencies): Use depset's own is_key_order
> function rather than delegating via walker. Pass whether the
> decl has ignored TU-local entities in its definition.
> (depset::hash::finalize_dependencies): Implement new warning
> Wtemplate-names-tu-local.
> (module_state::intercluster_seed): Don't seed TU-local deps.
> (module_state::write_cluster): Pass whether the decl has ignored
> TU-local entities in its definition.
> * pt.cc (complain_about_tu_local_entity): New function.
> (expr_contains_tu_local_entity): New function.
> (function_contains_tu_local_entity): New function.
> (instantiate_class_template): Skip TU-local friends.
> (tsubst_decl): Handle typedefs of TU-local entities.
> (tsubst): Complain about TU-local entities.
> (dependent_operand_p): Early exit for TU-local entities so we
> don't attempt to constant-evaluate them.
> (tsubst_expr): Detect and complain about TU-local entities.
>
> gcc/ChangeLog:
>
> * doc/invoke.texi: Document -Wtemplate-names-tu-local.
>
> gcc/testsuite/ChangeLog:
>
> * g++.dg/modules/internal-5_a.C: New test.
> * g++.dg/modules/internal-5_b.C: New test.
> * g++.dg/modules/internal-6.C: New test.
> * g++.dg/modules/internal-7_a.C: New test.
> * g++.dg/modules/internal-7_b.C: New test.
> * g++.dg/modules/internal-8_a.C: New test.
> * g++.dg/modules/xtreme-header-8.C: New test.
>
> Signed-off-by: Nathaniel Shead <nathanielosh...@gmail.com>
> Reviewed-by: Jason Merrill <ja...@redhat.com>
> ---
> gcc/c-family/c.opt | 4 +
> gcc/cp/cp-objcp-common.cc | 1 +
> gcc/cp/cp-tree.def | 6 +
> gcc/cp/cp-tree.h | 21 +-
> gcc/cp/module.cc | 318 +++++++++++++++---
> gcc/cp/pt.cc | 98 +++++-
> gcc/doc/invoke.texi | 19 +-
> gcc/testsuite/g++.dg/modules/internal-5_a.C | 110 ++++++
> gcc/testsuite/g++.dg/modules/internal-5_b.C | 30 ++
> gcc/testsuite/g++.dg/modules/internal-6.C | 24 ++
> gcc/testsuite/g++.dg/modules/internal-7_a.C | 75 +++++
> gcc/testsuite/g++.dg/modules/internal-7_b.C | 21 ++
> gcc/testsuite/g++.dg/modules/internal-8_a.C | 35 ++
> .../g++.dg/modules/xtreme-header-8.C | 8 +
> 14 files changed, 721 insertions(+), 49 deletions(-)
> create mode 100644 gcc/testsuite/g++.dg/modules/internal-5_a.C
> create mode 100644 gcc/testsuite/g++.dg/modules/internal-5_b.C
> create mode 100644 gcc/testsuite/g++.dg/modules/internal-6.C
> create mode 100644 gcc/testsuite/g++.dg/modules/internal-7_a.C
> create mode 100644 gcc/testsuite/g++.dg/modules/internal-7_b.C
> create mode 100644 gcc/testsuite/g++.dg/modules/internal-8_a.C
> create mode 100644 gcc/testsuite/g++.dg/modules/xtreme-header-8.C
>
> diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt
> index 9d1fccadbf9..6e5ddefd0e2 100644
> --- a/gcc/c-family/c.opt
> +++ b/gcc/c-family/c.opt
> @@ -1450,6 +1450,10 @@ Wtemplate-id-cdtor
> C++ ObjC++ Var(warn_template_id_cdtor) Warning
> Warn about simple-template-id in a constructor or destructor.
>
> +Wtemplate-names-tu-local
> +C++ ObjC++ Var(warn_template_names_tu_local) Warning EnabledBy(Wextra)
> +Warn about templates naming TU-local entities in a module.
> +
> Wterminate
> C++ ObjC++ Warning Var(warn_terminate) Init(1)
> Warn if a throw expression will always result in a call to terminate().
> diff --git a/gcc/cp/cp-objcp-common.cc b/gcc/cp/cp-objcp-common.cc
> index cd379514991..b959533bcb1 100644
> --- a/gcc/cp/cp-objcp-common.cc
> +++ b/gcc/cp/cp-objcp-common.cc
> @@ -233,6 +233,7 @@ cp_tree_size (enum tree_code code)
> case ASSERTION_STMT: return sizeof (tree_exp);
> case PRECONDITION_STMT: return sizeof (tree_exp);
> case POSTCONDITION_STMT: return sizeof (tree_exp);
> + case TU_LOCAL_ENTITY: return sizeof (tree_tu_local_entity);
> default:
> switch (TREE_CODE_CLASS (code))
> {
> diff --git a/gcc/cp/cp-tree.def b/gcc/cp/cp-tree.def
> index 18f75108c7b..7580dc3667d 100644
> --- a/gcc/cp/cp-tree.def
> +++ b/gcc/cp/cp-tree.def
> @@ -573,6 +573,12 @@ DEFTREECODE (ASSERTION_STMT, "assertion_stmt",
> tcc_statement, 3)
> DEFTREECODE (PRECONDITION_STMT, "precondition_stmt", tcc_statement, 3)
> DEFTREECODE (POSTCONDITION_STMT, "postcondition_stmt", tcc_statement, 4)
>
> +/* A reference to a translation-unit local entity.
> +
> + This is emitted by modules streaming when writing a TU-local entity that
> + wasn't an exposure (e.g. in a non-inline function template). */
> +DEFTREECODE (TU_LOCAL_ENTITY, "tu_local_entity", tcc_exceptional, 0)
> +
> /*
> Local variables:
> mode:c
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index dc153a97dc4..a71d0704f8b 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -1778,6 +1778,22 @@ check_constraint_info (tree t)
> it for unscoped enums. */
> #define DECL_MODULE_EXPORT_P(NODE) TREE_LANG_FLAG_3 (NODE)
>
> +/* Represents a streamed-in translation-unit-local entity. Any use of
> + this node when instantiating a template should emit an error. */
> +struct GTY(()) tree_tu_local_entity {
> + struct tree_base base;
> + tree name;
> + location_t loc;
> +};
> +
> +/* The name of a translation-unit-local entity. */
> +#define TU_LOCAL_ENTITY_NAME(NODE) \
> + (((struct tree_tu_local_entity *)TU_LOCAL_ENTITY_CHECK (NODE))->name)
> +
> +/* The source location of the translation-unit-local entity. */
> +#define TU_LOCAL_ENTITY_LOCATION(NODE) \
> + (((struct tree_tu_local_entity *)TU_LOCAL_ENTITY_CHECK (NODE))->loc)
> +
>
> /* The list of local parameters introduced by this requires-expression,
> in the form of a chain of PARM_DECLs. */
> @@ -1811,7 +1827,8 @@ enum cp_tree_node_structure_enum {
> TS_CP_LAMBDA_EXPR,
> TS_CP_TEMPLATE_INFO,
> TS_CP_CONSTRAINT_INFO,
> - TS_CP_USERDEF_LITERAL
> + TS_CP_USERDEF_LITERAL,
> + TS_CP_TU_LOCAL_ENTITY
> };
>
> /* The resulting tree type. */
> @@ -1842,6 +1859,8 @@ union GTY((desc ("cp_tree_node_structure (&%h)"),
> constraint_info;
> struct tree_userdef_literal GTY ((tag ("TS_CP_USERDEF_LITERAL")))
> userdef_literal;
> + struct tree_tu_local_entity GTY ((tag ("TS_CP_TU_LOCAL_ENTITY")))
> + tu_local_entity;
> };
>
>
> diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc
> index 136ffb1a7ac..4b26dc5d367 100644
> --- a/gcc/cp/module.cc
> +++ b/gcc/cp/module.cc
> @@ -2330,7 +2330,9 @@ private:
> DB_KIND_BITS = EK_BITS,
> DB_DEFN_BIT = DB_KIND_BIT + DB_KIND_BITS,
> DB_IS_MEMBER_BIT, /* Is an out-of-class member. */
> - DB_TU_LOCAL_BIT, /* It is a TU-local entity. */
> + DB_TU_LOCAL_BIT, /* Is a TU-local entity. */
> + DB_REFS_TU_LOCAL_BIT, /* Refers to a TU-local entity (but is not
> + necessarily an exposure.) */
> DB_EXPOSURE_BIT, /* Exposes a TU-local entity. */
> DB_IMPORTED_BIT, /* An imported entity. */
> DB_UNREACHED_BIT, /* A yet-to-be reached entity. */
> @@ -2401,7 +2403,9 @@ public:
> public:
> bool has_defn () const
> {
> - return get_flag_bit<DB_DEFN_BIT> ();
> + /* Never consider TU-local entities as having definitions, since
> + we will never be accessing them from importers anyway. */
> + return get_flag_bit<DB_DEFN_BIT> () && !is_tu_local ();
> }
>
> public:
> @@ -2416,6 +2420,10 @@ public:
> {
> return get_flag_bit<DB_TU_LOCAL_BIT> ();
> }
> + bool refs_tu_local () const
> + {
> + return get_flag_bit<DB_REFS_TU_LOCAL_BIT> ();
> + }
> bool is_exposure () const
> {
> return get_flag_bit<DB_EXPOSURE_BIT> ();
> @@ -2543,11 +2551,13 @@ public:
> depset *current; /* Current depset being depended. */
> unsigned section; /* When writing out, the section. */
> bool reached_unreached; /* We reached an unreached entity. */
> + bool ignore_tu_local; /* In a context where referencing a TU-local
> + entity is not an exposure. */
>
> public:
> hash (size_t size, hash *c = NULL)
> : parent (size), chain (c), current (NULL), section (0),
> - reached_unreached (false)
> + reached_unreached (false), ignore_tu_local (false)
> {
> worklist.create (size);
> }
> @@ -2748,6 +2758,7 @@ static GTY((cache)) decl_tree_cache_map
> *imported_temploid_friends;
> /* Tree tags. */
> enum tree_tag {
> tt_null, /* NULL_TREE. */
> + tt_tu_local, /* A TU-local entity. */
> tt_fixed, /* Fixed vector index. */
>
> tt_node, /* By-value node. */
> @@ -3032,6 +3043,8 @@ private:
> depset::hash *dep_hash; /* Dependency table. */
> int ref_num; /* Back reference number. */
> unsigned section;
> + bool writing_local_entities; /* Whether we might walk into a TU-local
> + entity we need to emit placeholders for. */
> #if CHECKING_P
> int importedness; /* Checker that imports not occurring
> inappropriately. +ve imports ok,
> @@ -3061,6 +3074,18 @@ public:
> };
>
> public:
> + /* The walk is used for three similar purposes:
> +
> + 1. The initial scan for dependencies.
> + 2. Once dependencies have been found, ordering them.
> + 3. Writing dependencies to file (streaming_p).
> +
> + For cases where it matters, these accessers can be used to determine
> + which state we're in. */
> + bool is_initial_scan () const
> + {
> + return !streaming_p () && !is_key_order ();
> + }
> bool is_key_order () const
> {
> return dep_hash->is_key_order ();
> @@ -3101,6 +3126,10 @@ private:
> void tree_pair_vec (vec<tree_pair_s, va_gc> *);
> void tree_list (tree, bool has_purpose);
>
> +private:
> + bool has_tu_local_dep (tree) const;
> + tree find_tu_local_decl (tree);
> +
> public:
> /* Mark a node for by-value walking. */
> void mark_by_value (tree);
> @@ -3138,7 +3167,7 @@ public:
>
> public:
> /* Serialize various definitions. */
> - void write_definition (tree decl);
> + void write_definition (tree decl, bool refs_tu_local = false);
> void mark_declaration (tree decl, bool do_defn);
>
> private:
> @@ -3166,6 +3195,7 @@ private:
> static unsigned tree_val_count;
> static unsigned decl_val_count;
> static unsigned back_ref_count;
> + static unsigned tu_local_count;
> static unsigned null_count;
> };
> } // anon namespace
> @@ -3174,12 +3204,14 @@ private:
> unsigned trees_out::tree_val_count;
> unsigned trees_out::decl_val_count;
> unsigned trees_out::back_ref_count;
> +unsigned trees_out::tu_local_count;
> unsigned trees_out::null_count;
>
> trees_out::trees_out (allocator *mem, module_state *state, depset::hash
> &deps,
> unsigned section)
> :parent (mem), state (state), tree_map (500),
> - dep_hash (&deps), ref_num (0), section (section)
> + dep_hash (&deps), ref_num (0), section (section),
> + writing_local_entities (false)
> {
> #if CHECKING_P
> importedness = 0;
> @@ -4301,6 +4333,9 @@ dumper::impl::nested_name (tree t)
> int origin = -1;
> tree name = NULL_TREE;
>
> + if (t && TREE_CODE (t) == TU_LOCAL_ENTITY)
> + t = TU_LOCAL_ENTITY_NAME (t);
> +
> if (t && TREE_CODE (t) == TREE_BINFO)
> t = BINFO_TYPE (t);
>
> @@ -4853,6 +4888,7 @@ trees_out::instrument ()
> dump (" %u decl trees", decl_val_count);
> dump (" %u other trees", tree_val_count);
> dump (" %u back references", back_ref_count);
> + dump (" %u TU-local entities", tu_local_count);
> dump (" %u null trees", null_count);
> }
> }
> @@ -7809,6 +7845,17 @@ trees_out::decl_value (tree decl, depset *dep)
> || DECL_ORIGINAL_TYPE (decl)
> || !TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)));
>
> + /* There's no need to walk any of the contents of a known TU-local entity,
> + since importers should never see any of it regardless. But make sure we
> + at least note its location so importers can use it for diagnostics. */
> + if (dep && dep->is_tu_local ())
> + {
> + gcc_checking_assert (is_initial_scan ());
> + insert (decl, WK_value);
> + state->note_location (DECL_SOURCE_LOCATION (decl));
> + return;
> + }
> +
> merge_kind mk = get_merge_kind (decl, dep);
> bool is_imported_temploid_friend = imported_temploid_friends->get (decl);
>
> @@ -8390,14 +8437,17 @@ trees_in::decl_value ()
> /* Frob it to be ready for cloning. */
> TREE_TYPE (inner) = DECL_ORIGINAL_TYPE (inner);
> DECL_ORIGINAL_TYPE (inner) = NULL_TREE;
> - set_underlying_type (inner);
> - if (tdef_flags & 2)
> + if (TREE_CODE (TREE_TYPE (inner)) != TU_LOCAL_ENTITY)
> {
> - /* Match instantiate_alias_template's handling. */
> - tree type = TREE_TYPE (inner);
> - TYPE_DEPENDENT_P (type) = true;
> - TYPE_DEPENDENT_P_VALID (type) = true;
> - SET_TYPE_STRUCTURAL_EQUALITY (type);
> + set_underlying_type (inner);
> + if (tdef_flags & 2)
> + {
> + /* Match instantiate_alias_template's handling. */
> + tree type = TREE_TYPE (inner);
> + TYPE_DEPENDENT_P (type) = true;
> + TYPE_DEPENDENT_P_VALID (type) = true;
> + SET_TYPE_STRUCTURAL_EQUALITY (type);
> + }
> }
> }
>
> @@ -8902,10 +8952,14 @@ trees_out::decl_node (tree decl, walk_kind ref)
> }
> tree_node (tpl);
>
> - /* Streaming TPL caused us to visit DECL and maybe its type. */
> - gcc_checking_assert (TREE_VISITED (decl));
> - if (DECL_IMPLICIT_TYPEDEF_P (decl))
> - gcc_checking_assert (TREE_VISITED (TREE_TYPE (decl)));
> + /* Streaming TPL caused us to visit DECL and maybe its type,
> + if it wasn't TU-local. */
> + if (CHECKING_P && !has_tu_local_dep (tpl))
> + {
> + gcc_checking_assert (TREE_VISITED (decl));
> + if (DECL_IMPLICIT_TYPEDEF_P (decl))
> + gcc_checking_assert (TREE_VISITED (TREE_TYPE (decl)));
> + }
> return false;
> }
>
> @@ -8925,10 +8979,10 @@ trees_out::decl_node (tree decl, walk_kind ref)
> dep = dep_hash->add_dependency (decl, kind);
> }
>
> - if (!dep)
> + if (!dep || dep->is_tu_local ())
> {
> /* Some internal entity of context. Do by value. */
> - decl_value (decl, NULL);
> + decl_value (decl, dep);
> return false;
> }
>
> @@ -9084,7 +9138,10 @@ trees_out::type_node (tree type)
> if (streaming_p ())
> dump (dumper::TREE) && dump ("Wrote typedef %C:%N%S",
> TREE_CODE (name), name, name);
> - gcc_checking_assert (TREE_VISITED (type));
> +
> + /* We'll have either visited this type or have newly discovered
> + that it's TU-local; either way we won't need to visit it again. */
> + gcc_checking_assert (TREE_VISITED (type) || has_tu_local_dep (name));
> return;
> }
>
> @@ -9363,6 +9420,64 @@ trees_in::tree_value ()
> return existing;
> }
>
> +/* Whether DECL has a TU-local dependency in the hash. */
> +
> +bool
> +trees_out::has_tu_local_dep (tree decl) const
> +{
> + /* Only the contexts of fields or enums remember that they're
> + TU-local. */
> + if (DECL_CONTEXT (decl)
> + && (TREE_CODE (decl) == FIELD_DECL
> + || TREE_CODE (decl) == CONST_DECL))
> + decl = TYPE_NAME (DECL_CONTEXT (decl));
> +
> + depset *dep = dep_hash->find_dependency (decl);
> + return dep && dep->is_tu_local ();
> +}
> +
> +/* If T depends on a TU-local entity, return that decl. */
> +
> +tree
> +trees_out::find_tu_local_decl (tree t)
> +{
> + /* We need to have walked all deps first before we can check. */
> + gcc_checking_assert (!is_initial_scan ());
> +
> + auto walker = [](tree *tp, int *walk_subtrees, void *data) -> tree
> + {
> + auto self = (trees_out *)data;
> +
> + tree decl = NULL_TREE;
> + if (TYPE_P (*tp))
> + {
> + /* A PMF type is a record type, which we otherwise wouldn't walk;
> + return whether the function type is TU-local. */
> + if (TYPE_PTRMEMFUNC_P (*tp))
> + {
> + *walk_subtrees = 0;
> + return self->find_tu_local_decl (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
> + }
> + else
> + decl = TYPE_MAIN_DECL (*tp);
> + }
> + else if (DECL_P (*tp))
> + decl = *tp;
> +
> + if (decl)
> + {
> + /* We found a DECL, this will tell us whether we're TU-local. */
> + *walk_subtrees = 0;
> + return self->has_tu_local_dep (decl) ? decl : NULL_TREE;
> + }
> + return NULL_TREE;
> + };
> +
> + /* We need to walk without duplicates so that we step into the pointed-to
> + types of array types. */
> + return cp_walk_tree_without_duplicates (&t, walker, this);
> +}
> +
> /* Stream out tree node T. We automatically create local back
> references, which is essentially a single pass lisp
> self-referential structure pretty-printer. */
> @@ -9375,6 +9490,46 @@ trees_out::tree_node (tree t)
> if (ref == WK_none)
> goto done;
>
> + /* Find TU-local entities and intercept streaming to instead write a
> + placeholder value; this way we don't need to emit such decls.
> + We only need to do this when writing a definition of an entity
> + that we know names a TU-local entity. */
> + if (!is_initial_scan () && writing_local_entities)
> + {
> + tree local_decl = NULL_TREE;
> + if (DECL_P (t) && has_tu_local_dep (t))
> + local_decl = t;
> + /* Consider a type to be TU-local if it refers to any TU-local decl,
> + no matter how deep.
> +
> + This worsens diagnostics slightly, as we often no longer point
> + directly to the at-fault entity when instantiating. However, this
> + reduces the module size slightly and means that much less of pt.cc
> + needs to know about us. */
> + else if (TYPE_P (t))
> + local_decl = find_tu_local_decl (t);
> + else if (EXPR_P (t))
> + local_decl = find_tu_local_decl (TREE_TYPE (t));
> +
> + if (local_decl)
> + {
> + int tag = insert (t, WK_value);
> + if (streaming_p ())
> + {
> + tu_local_count++;
> + i (tt_tu_local);
> + dump (dumper::TREE)
> + && dump ("Writing TU-local entity:%d %C:%N",
> + tag, TREE_CODE (t), t);
> + }
> + /* TODO: Get a more descriptive name? */
> + tree_node (DECL_NAME (local_decl));
> + if (state)
> + state->write_location (*this, DECL_SOURCE_LOCATION (local_decl));
> + goto done;
> + }
> + }
> +
> if (ref != WK_normal)
> goto skip_normal;
>
> @@ -9531,6 +9686,18 @@ trees_in::tree_node (bool is_use)
> /* NULL_TREE. */
> break;
>
> + case tt_tu_local:
> + {
> + /* A translation-unit-local entity. */
> + res = make_node (TU_LOCAL_ENTITY);
> + int tag = insert (res);
> +
> + TU_LOCAL_ENTITY_NAME (res) = tree_node ();
> + TU_LOCAL_ENTITY_LOCATION (res) = state->read_location (*this);
> + dump (dumper::TREE) && dump ("Read TU-local entity:%d %N", tag, res);
> + }
> + break;
> +
> case tt_fixed:
> /* A fixed ref, find it in the fixed_ref array. */
> {
> @@ -10147,7 +10314,8 @@ trees_in::tree_node (bool is_use)
> /* A template. */
> if (tree tpl = tree_node ())
> {
> - res = DECL_TEMPLATE_RESULT (tpl);
> + res = (TREE_CODE (tpl) == TU_LOCAL_ENTITY ?
> + tpl : DECL_TEMPLATE_RESULT (tpl));
> dump (dumper::TREE)
> && dump ("Read template %C:%N", TREE_CODE (res), res);
> }
> @@ -11917,8 +12085,18 @@ void
> trees_out::write_function_def (tree decl)
> {
> tree_node (DECL_RESULT (decl));
> - tree_node (DECL_INITIAL (decl));
> - tree_node (DECL_SAVED_TREE (decl));
> +
> + {
> + /* The function body for a non-inline function or function template
> + is ignored for determining exposures. This should only matter
> + for templates (we don't emit the bodies of non-inline functions
> + to begin with). */
> + auto ovr = make_temp_override (dep_hash->ignore_tu_local,
> + !DECL_DECLARED_INLINE_P (decl));
> + tree_node (DECL_INITIAL (decl));
> + tree_node (DECL_SAVED_TREE (decl));
> + }
> +
> tree_node (DECL_FRIEND_CONTEXT (decl));
>
> constexpr_fundef *cexpr = retrieve_constexpr_fundef (decl);
> @@ -12020,6 +12198,10 @@ trees_in::read_function_def (tree decl, tree
> maybe_template)
> void
> trees_out::write_var_def (tree decl)
> {
> + /* The initializer of a variable or variable template is ignored for
> + determining exposures. */
> + auto ovr = make_temp_override (dep_hash->ignore_tu_local, VAR_P (decl));
> +
> tree init = DECL_INITIAL (decl);
> tree_node (init);
> if (!init)
> @@ -12207,21 +12389,28 @@ trees_out::write_class_def (tree defn)
> for (; vtables; vtables = TREE_CHAIN (vtables))
> write_definition (vtables);
>
> - /* Write the friend classes. */
> - tree_list (CLASSTYPE_FRIEND_CLASSES (type), false);
> + {
> + /* Friend declarations in class definitions are ignored when
> + determining exposures. */
> + auto ovr = make_temp_override (dep_hash->ignore_tu_local, true);
>
> - /* Write the friend functions. */
> - for (tree friends = DECL_FRIENDLIST (defn);
> - friends; friends = TREE_CHAIN (friends))
> - {
> - /* Name of these friends. */
> - tree_node (TREE_PURPOSE (friends));
> - tree_list (TREE_VALUE (friends), false);
> - }
> - /* End of friend fns. */
> - tree_node (NULL_TREE);
> + /* Write the friend classes. */
> + tree_list (CLASSTYPE_FRIEND_CLASSES (type), false);
>
> - /* Write the decl list. */
> + /* Write the friend functions. */
> + for (tree friends = DECL_FRIENDLIST (defn);
> + friends; friends = TREE_CHAIN (friends))
> + {
> + tree_node (FRIEND_NAME (friends));
> + tree_list (FRIEND_DECLS (friends), false);
> + }
> + /* End of friend fns. */
> + tree_node (NULL_TREE);
> + }
> +
> + /* Write the decl list. We don't need to ignore exposures of friend
> + decls here as any such decls should already have been added and
> + ignored above. */
> tree_list (CLASSTYPE_DECL_LIST (type), true);
>
> if (TYPE_CONTAINS_VPTR_P (type))
> @@ -12574,6 +12763,8 @@ trees_in::read_class_def (tree defn, tree
> maybe_template)
> friend_decls; friend_decls = TREE_CHAIN (friend_decls))
> {
> tree f = TREE_VALUE (friend_decls);
> + if (TREE_CODE (f) == TU_LOCAL_ENTITY)
> + continue;
>
> DECL_BEFRIENDING_CLASSES (f)
> = tree_cons (NULL_TREE, type, DECL_BEFRIENDING_CLASSES (f));
> @@ -12722,8 +12913,11 @@ trees_in::read_enum_def (tree defn, tree
> maybe_template)
> /* Write out the body of DECL. See above circularity note. */
>
> void
> -trees_out::write_definition (tree decl)
> +trees_out::write_definition (tree decl, bool refs_tu_local)
> {
> + auto ovr = make_temp_override (writing_local_entities,
> + writing_local_entities || refs_tu_local);
> +
> if (streaming_p ())
> {
> assert_definition (decl);
> @@ -13309,7 +13503,11 @@ depset::hash::add_dependency (depset *dep)
> current->deps.safe_push (dep);
>
> if (dep->is_tu_local ())
> - current->set_flag_bit<DB_EXPOSURE_BIT> ();
> + {
> + current->set_flag_bit<DB_REFS_TU_LOCAL_BIT> ();
> + if (!ignore_tu_local)
> + current->set_flag_bit<DB_EXPOSURE_BIT> ();
> + }
>
> if (current->get_entity_kind () == EK_USING
> && DECL_IMPLICIT_TYPEDEF_P (dep->get_entity ())
> @@ -13959,7 +14157,7 @@ depset::hash::find_dependencies (module_state *module)
> {
> walker.mark_declaration (decl, current->has_defn ());
>
> - if (!walker.is_key_order ()
> + if (!is_key_order ()
> && (item->get_entity_kind () == EK_SPECIALIZATION
> || item->get_entity_kind () == EK_PARTIAL
> || (item->get_entity_kind () == EK_DECL
> @@ -13971,15 +14169,15 @@ depset::hash::find_dependencies (module_state
> *module)
>
> walker.decl_value (decl, current);
> if (current->has_defn ())
> - walker.write_definition (decl);
> + walker.write_definition (decl, current->refs_tu_local ());
> }
> walker.end ();
>
> - if (!walker.is_key_order ()
> + if (!is_key_order ()
> && DECL_CLASS_TEMPLATE_P (decl))
> add_deduction_guides (decl);
>
> - if (!walker.is_key_order ()
> + if (!is_key_order ()
> && TREE_CODE (decl) == TEMPLATE_DECL
> && !DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl))
> {
> @@ -14168,6 +14366,37 @@ depset::hash::finalize_dependencies ()
> /* We should have emitted an error above. */
> gcc_checking_assert (explained);
> }
> + else if (warn_template_names_tu_local
> + && dep->refs_tu_local () && !dep->is_tu_local ())
> + {
> + tree decl = dep->get_entity ();
> +
> + /* Friend decls in a class body are ignored, but this is harmless:
> + it should not impact any consumers. */
> + if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
> + continue;
> +
> + /* We should now only be warning about templates. */
> + gcc_checking_assert
> + (TREE_CODE (decl) == TEMPLATE_DECL
> + && VAR_OR_FUNCTION_DECL_P (DECL_TEMPLATE_RESULT (decl)));
> +
> + /* Ideally we would only warn in cases where there are no explicit
> + instantiations of the template, but we don't currently track this
> + in an easy-to-find way. */
> + for (depset *rdep : dep->deps)
> + if (!rdep->is_binding () && rdep->is_tu_local ())
> + {
> + tree ref = rdep->get_entity ();
> + auto_diagnostic_group d;
> + if (warning_at (DECL_SOURCE_LOCATION (decl),
> + OPT_Wtemplate_names_tu_local,
> + "%qD refers to TU-local entity %qD and cannot "
> + "be instantiated in other TUs", decl, ref))
> + is_tu_local_entity (ref, /*explain=*/true);
> + break;
> + }
> + }
> }
>
> return ok;
> @@ -15331,8 +15560,9 @@ enum ct_bind_flags
> void
> module_state::intercluster_seed (trees_out &sec, unsigned index_hwm, depset
> *dep)
> {
> - if (dep->is_import ()
> - || dep->cluster < index_hwm)
> + if (dep->is_tu_local ())
> + /* We only stream placeholders for TU-local entities anyway. */;
> + else if (dep->is_import () || dep->cluster < index_hwm)
> {
> tree ent = dep->get_entity ();
> if (!TREE_VISITED (ent))
> @@ -15553,7 +15783,7 @@ module_state::write_cluster (elf_out *to, depset
> *scc[], unsigned size,
> sec.u (ct_defn);
> sec.tree_node (decl);
> dump () && dump ("Writing definition %N", decl);
> - sec.write_definition (decl);
> + sec.write_definition (decl, b->refs_tu_local ());
>
> if (!namer->has_defn ())
> namer = b;
> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> index 03a1144765b..c7c6da0969e 100644
> --- a/gcc/cp/pt.cc
> +++ b/gcc/cp/pt.cc
> @@ -9881,6 +9881,71 @@ add_pending_template (tree d)
> pop_tinst_level ();
> }
>
> +/* Emit a diagnostic about instantiating a reference to TU-local entity E.
> */
> +
> +static void
> +complain_about_tu_local_entity (tree e)
> +{
> + auto_diagnostic_group d;
> + error ("instantiation exposes TU-local entity %qD",
> + TU_LOCAL_ENTITY_NAME (e));
> + inform (TU_LOCAL_ENTITY_LOCATION (e), "declared here");
> +}
> +
> +/* Checks if T contains a TU-local entity. */
> +
> +static bool
> +expr_contains_tu_local_entity (tree t)
> +{
> + if (!modules_p ())
> + return false;
> +
> + auto walker = [](tree *tp, int *walk_subtrees, void *) -> tree
> + {
> + if (TREE_CODE (*tp) == TU_LOCAL_ENTITY)
> + return *tp;
> + if (!EXPR_P (*tp))
> + *walk_subtrees = false;
> + return NULL_TREE;
> + };
> + return cp_walk_tree (&t, walker, nullptr, nullptr);
> +}
> +
> +/* Errors and returns TRUE if X is a function that contains a TU-local
> + entity in its overload set. */
> +
> +static bool
> +function_contains_tu_local_entity (tree x)
> +{
> + if (!modules_p ())
> + return false;
> +
> + if (!x || x == error_mark_node)
> + return false;
> +
> + if (TREE_CODE (x) == OFFSET_REF
> + || TREE_CODE (x) == COMPONENT_REF)
> + x = TREE_OPERAND (x, 1);
> + x = MAYBE_BASELINK_FUNCTIONS (x);
> + if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
> + x = TREE_OPERAND (x, 0);
> +
> + if (OVL_P (x))
> + for (tree ovl : lkp_range (x))
> + if (TREE_CODE (ovl) == TU_LOCAL_ENTITY)
> + {
> + x = ovl;
> + break;
> + }
> +
> + if (TREE_CODE (x) == TU_LOCAL_ENTITY)
> + {
> + complain_about_tu_local_entity (x);
> + return true;
> + }
> +
> + return false;
> +}
>
> /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
> ARGLIST. Valid choices for FNS are given in the cp-tree.def
> @@ -12743,8 +12808,10 @@ instantiate_class_template (tree type)
> }
> else
> {
> - if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t)
> - || DECL_TEMPLATE_TEMPLATE_PARM_P (t))
> + if (TREE_CODE (t) == TU_LOCAL_ENTITY)
> + /* Ignore. */;
> + else if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t)
> + || DECL_TEMPLATE_TEMPLATE_PARM_P (t))
> {
> /* Build new CLASSTYPE_FRIEND_CLASSES. */
>
> @@ -15522,7 +15589,8 @@ tsubst_decl (tree t, tree args, tsubst_flags_t
> complain,
> RETURN (error_mark_node);
>
> if (TREE_CODE (t) == TYPE_DECL
> - && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
> + && (TREE_CODE (TREE_TYPE (t)) == TU_LOCAL_ENTITY
> + || t == TYPE_MAIN_DECL (TREE_TYPE (t))))
> {
> /* If this is the canonical decl, we don't have to
> mess with instantiations, and often we can't (for
> @@ -16250,6 +16318,14 @@ tsubst (tree t, tree args, tsubst_flags_t complain,
> tree in_decl)
> || TREE_CODE (t) == TRANSLATION_UNIT_DECL)
> return t;
>
> + /* Any instantiation of a template containing a TU-local entity is an
> + exposure, so always issue a hard error irrespective of complain. */
> + if (TREE_CODE (t) == TU_LOCAL_ENTITY)
> + {
> + complain_about_tu_local_entity (t);
> + return error_mark_node;
> + }
> +
> tsubst_flags_t tst_ok_flag = (complain & tf_tst_ok);
> complain &= ~tf_tst_ok;
>
> @@ -18486,6 +18562,12 @@ dependent_operand_p (tree t)
> {
> while (TREE_CODE (t) == IMPLICIT_CONV_EXPR)
> t = TREE_OPERAND (t, 0);
> +
> + /* If we contain a TU_LOCAL_ENTITY assume we're non-dependent; we'll error
> + later when instantiating. */
> + if (expr_contains_tu_local_entity (t))
> + return false;
I think it'd be more robust and cheaper (avoiding a separate tree walk)
to teach the general constexpr/dependence predicates about
TU_LOCAL_ENTITY instead of handling it only here.
> +
> ++processing_template_decl;
> bool r = (potential_constant_expression (t)
> ? value_dependent_expression_p (t)
> @@ -20255,6 +20337,9 @@ tsubst_expr (tree t, tree args, tsubst_flags_t
> complain, tree in_decl)
> else
> object = NULL_TREE;
>
> + if (function_contains_tu_local_entity (templ))
> + RETURN (error_mark_node);
> +
> tree tid = lookup_template_function (templ, targs);
> protected_set_expr_location (tid, EXPR_LOCATION (t));
>
> @@ -20947,6 +21032,9 @@ tsubst_expr (tree t, tree args, tsubst_flags_t
> complain, tree in_decl)
> qualified_p = true;
> }
>
> + if (function_contains_tu_local_entity (function))
> + RETURN (error_mark_node);
Similarly, maybe it'd suffice to check this more generally in the
OVERLOAD case of tsubst_expr?
> +
> nargs = call_expr_nargs (t);
> releasing_vec call_args;
> tsubst_call_args (t, args, complain, in_decl, call_args);
> @@ -21968,6 +22056,10 @@ tsubst_expr (tree t, tree args, tsubst_flags_t
> complain, tree in_decl)
> RETURN (op);
> }
>
> + case TU_LOCAL_ENTITY:
> + complain_about_tu_local_entity (t);
> + RETURN (error_mark_node);
> +
> default:
> /* Handle Objective-C++ constructs, if appropriate. */
> if (tree subst = objcp_tsubst_expr (t, args, complain, in_decl))
> diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
> index d38c1feb86f..b5f767f6f12 100644
> --- a/gcc/doc/invoke.texi
> +++ b/gcc/doc/invoke.texi
> @@ -272,7 +272,7 @@ in the following sections.
> -Woverloaded-virtual -Wno-pmf-conversions -Wself-move -Wsign-promo
> -Wsized-deallocation -Wsuggest-final-methods
> -Wsuggest-final-types -Wsuggest-override -Wno-template-body
> --Wno-template-id-cdtor
> +-Wno-template-id-cdtor -Wtemplate-names-tu-local
> -Wno-terminate -Wno-vexing-parse -Wvirtual-inheritance
> -Wno-virtual-move-assign -Wvolatile -Wzero-as-null-pointer-constant}
>
> @@ -4686,6 +4686,23 @@ template<typename T> struct S @{
> @option{-Wtemplate-id-cdtor} is enabled by default with
> @option{-std=c++20}; it is also enabled by @option{-Wc++20-compat}.
>
> +@opindex Wtemplate-names-tu-local
> +@opindex Wno-template-names-tu-local
> +@item -Wtemplate-names-tu-local
> +Warn when a template body hides an exposure of a translation-unit-local
> +entity. In most cases, referring to a translation-unit-local entity
> +(such as an internal linkage declaration) within an entity that is
> +emitted into a module's CMI is an error. However, within the
> +initializer of a variable, or in the body of a non-inline function,
> +this is not an exposure and no error is emitted.
> +
> +This can cause variable or function templates to accidentally become
> +unusable if they reference such an entity, because other translation
> +units that import the template will never be able to instantiate it.
> +This warning attempts to detect cases where this might occur.
> +
> +This flag is enabled by @option{-Wextra}.
> +
> @opindex Wterminate
> @opindex Wno-terminate
> @item -Wno-terminate @r{(C++ and Objective-C++ only)}
> diff --git a/gcc/testsuite/g++.dg/modules/internal-5_a.C
> b/gcc/testsuite/g++.dg/modules/internal-5_a.C
> new file mode 100644
> index 00000000000..c5ef3752f5a
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/modules/internal-5_a.C
> @@ -0,0 +1,110 @@
> +// { dg-additional-options "-fmodules-ts -Wtemplate-names-tu-local" }
> +// { dg-module-cmi M }
> +// Ignore exposures in these cases
> +
> +export module M;
> +
> +namespace {
> + inline namespace ns {
> + struct internal_t {};
> + template <typename T> struct internal_tmpl_t {};
> +
> + int internal_x;
> + void internal_ovl(int&) {}
> + void internal_ovl(internal_t) {}
> +
> + template <typename T> void internal_tmpl() {}
> + }
> +}
> +export struct ok_inst_tag {};
> +
> +
> +// The function body for a non-inline function or function template
> +export void function() {
> + internal_t i {};
> + internal_tmpl_t<int> ii {};
> + internal_ovl(internal_x);
> + internal_tmpl<int>();
> +}
> +
> +export template <typename T> void function_tmpl() { // { dg-warning "refers
> to TU-local entity" }
> + internal_t i {};
> + internal_tmpl_t<T> ii {};
> + internal_ovl(internal_x);
> + internal_tmpl<T>();
> +}
> +template void function_tmpl<ok_inst_tag>();
> +template <> void function_tmpl<ok_inst_tag*>() {}
> +
> +
> +// The initializer for a variable or variable template
> +export int var
> + = (internal_t{}, internal_tmpl_t<int>{},
> + internal_ovl(internal_x), internal_tmpl<int>(), 0);
> +
> +export template <typename T> int var_tmpl // { dg-warning "refers to
> TU-local entity" }
> + = (internal_t{}, internal_tmpl_t<T>{},
> + internal_ovl(internal_x), internal_tmpl<T>(), 0);
> +
> +template <typename T> int var_tmpl<T*> // { dg-warning "refers to TU-local
> entity" }
> + = (internal_t{}, internal_tmpl_t<T*>{},
> + internal_ovl(internal_x), internal_tmpl<T*>(), 0);
> +
> +template int var_tmpl<ok_inst_tag>;
> +template <> int var_tmpl<ok_inst_tag*> = 0;
> +
> +export int& constant_ref = internal_x;
> +static_assert (&constant_ref == &internal_x);
> +
> +
> +// Friend declarations in a class definition
> +export struct klass { // { dg-bogus "TU-local" }
> + friend ns::internal_t;
> + friend ns::internal_tmpl_t<int>;
> + friend void ns::internal_ovl(int&);
> + friend void ns::internal_ovl(internal_t);
> + friend void ns::internal_tmpl<int>();
> +
> + template <typename> friend struct ns::internal_tmpl_t;
> + template <typename> friend void ns::internal_tmpl();
> +};
> +
> +export template <typename T>
> +class klass_tmpl { // { dg-bogus "TU-local" }
> + friend ns::internal_t;
> + friend ns::internal_tmpl_t<int>;
> + friend void ns::internal_ovl(int&);
> + friend void ns::internal_ovl(internal_t);
> + friend void ns::internal_tmpl<int>();
> +
> + template <typename> friend struct ns::internal_tmpl_t;
> + template <typename> friend void ns::internal_tmpl();
> +};
> +
> +template <typename T> class klass_tmpl<T*> { // { dg-bogus "TU-local" }
> + friend ns::internal_t;
> + friend ns::internal_tmpl_t<int>;
> + friend void ns::internal_ovl(int&);
> + friend void ns::internal_ovl(internal_t);
> + friend void ns::internal_tmpl<int>();
> +
> + template <typename> friend struct ns::internal_tmpl_t;
> + template <typename> friend void ns::internal_tmpl();
> +};
> +
> +
> +// Any reference to a non-volatile const object or reference with internal or
> +// no linkage initialized with a constant expression that is not an ODR-use
> +static const int value = 123;
> +static const int& ref = 456;
> +static const internal_t internal {};
> +void f(int) {}
> +export inline void no_odr_use() {
> + int x = value;
> + int y = ref;
> + int z = (internal, 0);
> +
> + value;
> + bool b = value < value;
> + f(value);
> +}
> diff --git a/gcc/testsuite/g++.dg/modules/internal-5_b.C
> b/gcc/testsuite/g++.dg/modules/internal-5_b.C
> new file mode 100644
> index 00000000000..baf60fdafa2
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/modules/internal-5_b.C
> @@ -0,0 +1,30 @@
> +// { dg-additional-options "-fmodules-ts" }
> +
> +import M;
> +
> +int main() {
> + // These are all OK
> + function();
> + int a = var;
> + klass k;
> + klass_tmpl<int> kt;
> + klass_tmpl<int*> ktp;
> + no_odr_use();
> +
> + function_tmpl<ok_inst_tag>();
> + function_tmpl<ok_inst_tag*>();
> + int b = var_tmpl<ok_inst_tag>;
> + int c = var_tmpl<ok_inst_tag*>;
> +
> + // But don't ignore exposures in these cases
> + function_tmpl<int>(); // { dg-message "required from here" }
> + int x = var_tmpl<int>; // { dg-message "required from here" }
> + int y = var_tmpl<int*>; // { dg-message "required from here" }
> +
> + // And decls initialized to a TU-local value are not constant here
> + // Unfortunately the error does not currently point to this decl
> + constexpr int& r = constant_ref;
> + // { dg-error "is not a constant expression" "" { target *-*-* } 0 }
> +}
> +
> +// { dg-error "instantiation exposes TU-local entity" "" { target *-*-* } 0 }
> diff --git a/gcc/testsuite/g++.dg/modules/internal-6.C
> b/gcc/testsuite/g++.dg/modules/internal-6.C
> new file mode 100644
> index 00000000000..0f138781ad5
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/modules/internal-6.C
> @@ -0,0 +1,24 @@
> +// { dg-additional-options "-fmodules-ts" }
> +// { dg-module-cmi !M }
> +// Exposures (or not) of TU-local values
> +
> +export module M;
> +
> +static void f() {}
> +auto& fr = f; // OK
> +constexpr auto& fr2 = fr; // { dg-error "initialized to a TU-local value" }
> +static constexpr auto fp2 = fr; // OK
> +
> +struct S { void (&ref)(); } s{ f }; // OK, value is TU-local
> +constexpr extern struct W { S& s; } wrap{ s }; // OK, value is not TU-local
> +constexpr S s2{ f }; // { dg-error "initialized to a TU-local value" }
> +
> +constexpr int a = 123;
> +static constexpr int b = 456;
> +struct X {
> + union {
> + const int* p[2];
> + };
> +};
> +constexpr X x { &a }; // OK
> +constexpr X y { &a, &b }; // { dg-error "initialized to a TU-local value" }
> diff --git a/gcc/testsuite/g++.dg/modules/internal-7_a.C
> b/gcc/testsuite/g++.dg/modules/internal-7_a.C
> new file mode 100644
> index 00000000000..39f53ea382e
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/modules/internal-7_a.C
> @@ -0,0 +1,75 @@
> +// { dg-additional-options "-fmodules-ts -Wtemplate-names-tu-local" }
> +// Test streaming and instantiations of various kinds of exposures
> +
> +export module M;
> +
> +namespace {
> + int x;
> + constexpr int y = 1;
> +
> + struct S { int m; void d(); };
> + enum class E { e };
> +
> + template <typename T> int f(T t) { return (int)t; }
> +}
> +
> +template <auto N> void g() {}
> +
> +template <typename T>
> +int expose_1() { // { dg-warning "TU-local" }
> + return x;
> +}
> +
> +template <typename T>
> +void expose_2() { // { dg-warning "TU-local" }
> + T t = &y;
> +}
> +
> +template <typename T>
> +bool expose_3() { // { dg-warning "TU-local" }
> + return !(T{} * (x + 5) > 123);
> +}
> +
> +template <typename T>
> +bool expose_4() { // { dg-warning "TU-local" }
> + return __is_same(S, T);
> +}
> +
> +template <typename T>
> +void expose_5() { // { dg-warning "TU-local" }
> + static_assert(T{} == (int)E::e);
> +}
> +
> +template <typename T>
> +void expose_6() { // { dg-warning "TU-local" }
> + f(T{});
> +}
> +
> +template <typename T>
> +void expose_7() { // { dg-warning "TU-local" }
> + g<&y>();
> +}
> +
> +template <typename T>
> +void expose_8() { // { dg-warning "TU-local" }
> + decltype(T{} .* &S::m)* (*x)[5][10];
> +};
> +
> +template <typename T>
> +bool expose_9() { // { dg-warning "TU-local" }
> + return noexcept((T{} .* &S::d)());
> +}
> +
> +template <typename T>
> +void expose_10() { // { dg-warning "TU-local" }
> + using U = decltype(f<T>());
> +}
> +
> +template <typename T>
> +void expose_11() { // { dg-warning "TU-local" }
> + static thread_local E r;
> +}
> +
> +template <typename T>
> +int expose_var // { dg-warning "TU-local" }
> + = f(sizeof(T));
> diff --git a/gcc/testsuite/g++.dg/modules/internal-7_b.C
> b/gcc/testsuite/g++.dg/modules/internal-7_b.C
> new file mode 100644
> index 00000000000..2a11e449d6e
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/modules/internal-7_b.C
> @@ -0,0 +1,21 @@
> +// { dg-additional-options "-fmodules-ts" }
> +
> +module M;
> +
> +void inst() {
> + expose_1<int>(); // { dg-message "required from here" }
> + expose_2<int>(); // { dg-message "required from here" }
> + expose_3<int>(); // { dg-message "required from here" }
> + expose_4<int>(); // { dg-message "required from here" }
> + expose_5<int>(); // { dg-message "required from here" }
> + expose_6<int>(); // { dg-message "required from here" }
> + expose_7<int>(); // { dg-message "required from here" }
> + expose_8<int>(); // { dg-message "required from here" }
> + expose_9<int>(); // { dg-message "required from here" }
> + expose_10<int>(); // { dg-message "required from here" }
> + expose_11<int>(); // { dg-message "required from here" }
> +
> + expose_var<int>; // { dg-message "required from here" }
> +}
> +
> +// { dg-error "instantiation exposes TU-local entity" "" { target *-*-* } 0 }
> diff --git a/gcc/testsuite/g++.dg/modules/internal-8_a.C
> b/gcc/testsuite/g++.dg/modules/internal-8_a.C
> new file mode 100644
> index 00000000000..46e07a23cf0
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/modules/internal-8_a.C
> @@ -0,0 +1,35 @@
> +// { dg-additional-options "-fmodules-ts -Wtemplate-names-tu-local" }
> +// Non-ODR usages of const variables currently are erroneously
> +// reported in templates and constexpr functions; this test
> +// XFAILS them until we can implement a fix.
> +
> +export module M;
> +
> +namespace { struct internal_t {}; };
> +static const int value = 123;
> +static const int& ref = 456;
> +static const internal_t internal {};
> +
> +constexpr void f(int) {}
> +
> +export constexpr
> +void no_odr_use_cexpr() { // { dg-bogus "TU-local" "" { xfail *-*-* } }
> + int x = value;
> + int y = ref;
> + int z = (internal, 0);
> +
> + value;
> + bool b = value < value;
> + f(value);
> +}
> +
> +export template <typename T>
> +void no_odr_use_templ() { // { dg-bogus "TU-local" "" { xfail *-*-* } }
> + int x = value;
> + int y = ref;
> + int z = (internal, 0);
> +
> + value;
> + bool b = value < value;
> + f(value);
> +}
> diff --git a/gcc/testsuite/g++.dg/modules/xtreme-header-8.C
> b/gcc/testsuite/g++.dg/modules/xtreme-header-8.C
> new file mode 100644
> index 00000000000..82c0b59fefe
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/modules/xtreme-header-8.C
> @@ -0,0 +1,8 @@
> +// PR c++/115126
> +// { dg-additional-options "-fmodules-ts -Wtemplate-names-tu-local" }
> +// { dg-module-cmi xstd }
> +
> +export module xstd;
> +extern "C++" {
> + #include "xtreme-header.h"
> +}
> --
> 2.46.0
>
>
