Here are the pieces of patch 22 that add new flag bits to tree nodes and
lang_decl structs, along with a new global indicating what fragment of a
module we may be processing.
be aware that header-units, although part of the Global Module, are
treated as-if they are named modules but with some interesting 'may have
duplicate' rules. In particular all their entities are exported, and
marked as having a purview
There was a free LANG_DECL flag, which I use for DECL_MODULE_EXPORT_P,
such a decl is being exported from somewhere.
I needed to mark typeinfo types, so DECL_TINFO_P is extended to TYPE_DECLs.
OVL_EXPORT_P is added to indicate that a particular member is an export.
This is duplicating DECL_MODULE_EXPORT_P, but it is convenient to have
it in the overload.
DECL_MODULE_PURVIEW_P -- the decl is in the purview of a module
DECL_MODULE_IMPORT_P -- we got this decl from an import
DECL_MODULE_ENTITY_P -- this decl is in the imported entity array &
hash. It may be true even if DECL_MODULE_IMPORT_P is false, because the
current TU might be defining it.
DECL_MODULE_PENDING_SPECIALIZATIONs, this template decl has
specializations that we have not loaded (they must be loaded before we
can instantiate the template) such specializations can be in arbitray
modules, not necessarily the one defining the template
DECL_MODULE_PENDING_MEMBERS, likewise, we can define members in other
modules (partitions or header units), or instantiate implicit members
anywhere. These need to be loaded before we can look inside this class.
DECL_ATTACHED_DECLS_P, this namespace-scope decl has a set of attached
decls for ODR purposes. The case we handle comes from ranges:
template<something> constexpr T var = [] () { return something; }
That lambda is attached to 'var', it's not a different lambda in each TU.
Nearly all those new flags are added to lang_decl_base. Originally I
had the module index there, which is why I drastically shrank
'selector'. I keep the shrinkage because I don't really think it's a
bottleneck.
class module_state is defined inside module.cc, but we need to expose
its incomplete tag. 'modules_p' is true if we're supporting modules.
IIRC I had one bug during development where a modules-disabled
compilation crashed. So I'm reasonably certain that, when disabled, the
compiler is still as stable as ever.
module_kind is a set of bits indicating what kind of module we're
processing. non-module code will have it zero. In module purview
MK_MODULE will be set. In the GMF of a named module MK_GLOBAL will be
set (and MK_MODULE clear). In a header unit, both are set.
MK_EXPORTING is set if we're inside an 'export' either a {...} region,
or a single decl. MK_INTERFACE is true if we're in the interface of a
named module (as opposed to implementation), and MK_PARTITION is true if
we're in a partition of a named module (interface or implementation).
There are a bunch of inline predicate functions to decode the various
combinations that are useful.
nathan
--
Nathan Sidwell
diff --git c/gcc/cp/cp-tree.h w/gcc/cp/cp-tree.h
index 63724c0e84f..4752ddef898 100644
--- c/gcc/cp/cp-tree.h
+++ w/gcc/cp/cp-tree.h
@@ -479,13 +488,14 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
CALL_EXPR_ORDERED_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
DECLTYPE_FOR_REF_CAPTURE (in DECLTYPE_TYPE)
CONSTRUCTOR_C99_COMPOUND_LITERAL (in CONSTRUCTOR)
+ DECL_MODULE_EXPORT_P (in _DECL)
OVL_NESTED_P (in OVERLOAD)
LAMBDA_EXPR_INSTANTIATED (in LAMBDA_EXPR)
Reserved for DECL_MODULE_EXPORT (in DECL_)
4: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
CALL_EXPR, or FIELD_DECL).
- DECL_TINFO_P (in VAR_DECL)
+ DECL_TINFO_P (in VAR_DECL, TYPE_DECL)
FUNCTION_REF_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
OVL_LOOKUP_P (in OVERLOAD)
LOOKUP_FOUND_P (in RECORD_TYPE, UNION_TYPE, ENUMERAL_TYPE, NAMESPACE_DECL)
@@ -493,6 +503,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
FUNCTION_RVALUE_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
CALL_EXPR_REVERSE_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
CONSTRUCTOR_PLACEHOLDER_BOUNDARY (in CONSTRUCTOR)
+ OVL_EXPORT_P (in OVL_USING_P OVERLOAD)
6: TYPE_MARKED_P (in _TYPE)
DECL_NONTRIVIALLY_INITIALIZED_P (in VAR_DECL)
RANGE_FOR_IVDEP (in RANGE_FOR_STMT)
@@ -768,6 +780,8 @@ typedef struct ptrmem_cst * ptrmem_cst_t;
#define OVL_NESTED_P(NODE) TREE_LANG_FLAG_3 (OVERLOAD_CHECK (NODE))
/* If set, this overload was constructed during lookup. */
#define OVL_LOOKUP_P(NODE) TREE_LANG_FLAG_4 (OVERLOAD_CHECK (NODE))
+/* If set, this OVL_USING_P overload is exported. */
+#define OVL_EXPORT_P(NODE) TREE_LANG_FLAG_5 (OVERLOAD_CHECK (NODE))
/* The first decl of an overload. */
#define OVL_FIRST(NODE) ovl_first (NODE)
@@ -835,6 +854,12 @@ class ovl_iterator {
return (TREE_CODE (ovl) == USING_DECL
|| (TREE_CODE (ovl) == OVERLOAD && OVL_USING_P (ovl)));
}
+ /* Whether this using is being exported. */
+ bool exporting_p () const
+ {
+ return OVL_EXPORT_P (get_using ());
+ }
+
bool hidden_p () const
{
return TREE_CODE (ovl) == OVERLOAD && OVL_HIDDEN_P (ovl);
@@ -1634,6 +1742,48 @@ check_constraint_info (tree t)
#define CONSTRAINED_PARM_PROTOTYPE(NODE) \
DECL_INITIAL (TYPE_DECL_CHECK (NODE))
+/* Module defines. */
+// Too many _DECLS: FUNCTION,VAR,TYPE,TEMPLATE,CONCEPT or NAMESPACE
+#define DECL_MODULE_CHECK(NODE) (NODE)
+
+/* In the purview of a module (including header unit). */
+#define DECL_MODULE_PURVIEW_P(N) \
+ (DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (N))->u.base.module_purview_p)
+
+/* True if the live version of the decl was imported. */
+#define DECL_MODULE_IMPORT_P(NODE) \
+ (DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (NODE))->u.base.module_import_p)
+
+/* True if this decl is in the entity hash & array. This means that
+ some variant was imported, even if DECL_MODULE_IMPORT_P is false. */
+#define DECL_MODULE_ENTITY_P(NODE) \
+ (DECL_LANG_SPECIFIC (DECL_MODULE_CHECK (NODE))->u.base.module_entity_p)
+
+/* True if there are unloaded specializations keyed to this template. */
+#define DECL_MODULE_PENDING_SPECIALIZATIONS_P(NODE) \
+ (DECL_LANG_SPECIFIC (TEMPLATE_DECL_CHECK (NODE)) \
+ ->u.base.module_pending_specializations_p)
+
+/* True if this class has unloaded members. These should be loaded
+ before we do member lookups. While this may be better on the
+ classtype, I think we can get this behaviour for enums too. But
+ perhaps those need to be immediately loaded? (Particularly if
+ unscoped). */
+#define DECL_MODULE_PENDING_MEMBERS_P(NODE) \
+ (DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE)) \
+ ->u.base.module_pending_members_p)
+
+/* Whether this is an exported DECL. Held on any decl that can appear
+ at namespace scope (function, var, type, template, const or
+ namespace). templates copy from their template_result, consts have
+ it for unscoped enums. */
+#define DECL_MODULE_EXPORT_P(NODE) TREE_LANG_FLAG_3 (NODE)
+
+/* DECL that has attached decls for ODR-relatedness. */
+#define DECL_ATTACHED_DECLS_P(NODE) \
+ (DECL_LANG_SPECIFIC (NODE)->u.base.attached_decls_p)
+
+
/* The list of local parameters introduced by this requires-expression,
in the form of a chain of PARM_DECLs. */
#define REQUIRES_EXPR_PARMS(NODE) \
@@ -2643,15 +2795,15 @@ enum lang_decl_selector
/* Flags shared by all forms of DECL_LANG_SPECIFIC.
Some of the flags live here only to make lang_decl_min/fn smaller. Do
- not make this struct larger than 32 bits; instead, make sel smaller. */
+ not make this struct larger than 32 bits. */
struct GTY(()) lang_decl_base {
- /* Larger than necessary for faster access. */
- ENUM_BITFIELD(lang_decl_selector) selector : 16;
+ ENUM_BITFIELD(lang_decl_selector) selector : 3;
ENUM_BITFIELD(languages) language : 1;
unsigned use_template : 2;
unsigned not_really_extern : 1; /* var or fn */
unsigned initialized_in_class : 1; /* var or fn */
+
unsigned threadprivate_or_deleted_p : 1; /* var or fn */
/* anticipated_p is no longer used for anticipated_decls (fn, type
or template). It is used as DECL_OMP_PRIVATIZED_MEMBER in
@@ -2660,11 +2812,22 @@ struct GTY(()) lang_decl_base {
unsigned friend_or_tls : 1; /* var, fn, type or template */
unsigned unknown_bound_p : 1; /* var */
unsigned odr_used : 1; /* var or fn */
- unsigned spare : 1;
unsigned concept_p : 1; /* applies to vars and functions */
unsigned var_declared_inline_p : 1; /* var */
unsigned dependent_init_p : 1; /* var */
- /* 2 spare bits */
+
+ unsigned module_purview_p : 1; /* in module purview (not GMF) */
+ unsigned module_import_p : 1; /* from an import */
+ unsigned module_entity_p : 1; /* is in the entitity ary &
+ hash. */
+ /* Has specializations or members yet to load. */
+ unsigned module_pending_specializations_p : 1;
+ unsigned module_pending_members_p : 1;
+
+ /* Is in the decl-attached hash table, (with attached decls). */
+ unsigned attached_decls_p : 1;
+
+ /* 10 spare bits. */
};
/* True for DECL codes which have template info and access. */
@@ -3338,7 +3508,8 @@ struct GTY(()) lang_decl {
/* 1 iff VAR_DECL node NODE is a type-info decl. This flag is set for
both the primary typeinfo object and the associated NTBS name. */
-#define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))
+#define DECL_TINFO_P(NODE) \
+ TREE_LANG_FLAG_4 (TREE_CHECK2 (NODE,VAR_DECL,TYPE_DECL))
/* 1 iff VAR_DECL node NODE is virtual table or VTT. We forward to
DECL_VIRTUAL_P from the common code, as that has the semantics we
@@ -6773,6 +6973,51 @@ extern bool ctor_omit_inherited_parms (tree);
extern tree locate_ctor (tree);
extern tree implicitly_declare_fn (special_function_kind, tree,
bool, tree, tree);
+/* In module.cc */
+class module_state; /* Forward declare. */
+inline bool modules_p () { return flag_modules != 0; }
+
+#define MK_MODULE (1 << 0) /* This TU is a module. */
+#define MK_GLOBAL (1 << 1) /* Entities are in the global module. */
+#define MK_INTERFACE (1 << 2) /* This TU is an interface. */
+#define MK_PARTITION (1 << 3) /* This TU is a partition. */
+#define MK_EXPORTING (1 << 4) /* We are in an export region. */
+extern unsigned module_kind;
+
+/* MK_MODULE & MK_GLOBAL have the following combined meanings:
+ MODULE GLOBAL
+ 0 0 not a module
+ 0 1 GMF of named module (we've not yet seen module-decl)
+ 1 0 purview of named module
+ 1 1 header unit. */
+
+inline bool module_purview_p ()
+{ return module_kind & MK_MODULE; }
+inline bool global_purview_p ()
+{ return module_kind & MK_GLOBAL; }
+
+inline bool not_module_p ()
+{ return (module_kind & (MK_MODULE | MK_GLOBAL)) == 0; }
+inline bool named_module_p ()
+{ /* This is a named module if exactly one of MODULE and GLOBAL is
+ set. */
+ /* The divides are constant shifts! */
+ return ((module_kind / MK_MODULE) ^ (module_kind / MK_GLOBAL)) & 1;
+}
+inline bool header_module_p ()
+{ return (module_kind & (MK_MODULE | MK_GLOBAL)) == (MK_MODULE | MK_GLOBAL); }
+inline bool named_module_purview_p ()
+{ return (module_kind & (MK_MODULE | MK_GLOBAL)) == MK_MODULE; }
+inline bool module_interface_p ()
+{ return module_kind & MK_INTERFACE; }
+inline bool module_partition_p ()
+{ return module_kind & MK_PARTITION; }
+inline bool module_has_cmi_p ()
+{ return module_kind & (MK_INTERFACE | MK_PARTITION); }
+
+/* We're currently exporting declarations. */
+inline bool module_exporting_p ()
+{ return module_kind & MK_EXPORTING; }
/* In optimize.c */
extern bool maybe_clone_body (tree);
