Intrinsics for N2965: Type traits and base classes
Mike Spertus
mike_spertus@symantec.com
Mon Sep 26 16:24:00 GMT 2011
This patch consists intrinsics to properly create the bases and
direct_bases of a class in the correct order (including multiple nested
ambiguous virtual and non-virtual classes) for N2965
(http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2965.html).
This allows you to create type traits for giving the base classes of the
class:
template<typename _Tp>
struct bases
{
typedef tuple<__bases(_Tp)...> type;
};
I didn't modify the standard library to include the above type trait in
the patch because it is not yet clear what type it should return (e.g.,
a tuple, a "typelist," something satisfying the requirements of a
boost::mpl sequence, or a generalization of parameter packs). I have
(cursorily) tested it with the above type trait and the corresponding
direct_bases trait.
Thanks to Jason Merrill and Benjamin Kosnik for all their help,
Mike
Index: gcc/c-family/c-common.c
===================================================================
--- gcc/c-family/c-common.c (revision 178892)
+++ gcc/c-family/c-common.c (working copy)
@@ -423,6 +423,7 @@
{ "__asm__", RID_ASM, 0 },
{ "__attribute", RID_ATTRIBUTE, 0 },
{ "__attribute__", RID_ATTRIBUTE, 0 },
+ { "__bases", RID_BASES, D_CXXONLY },
{ "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
{ "__builtin_complex", RID_BUILTIN_COMPLEX, D_CONLY },
{ "__builtin_offsetof", RID_OFFSETOF, 0 },
@@ -433,6 +434,7 @@
{ "__const", RID_CONST, 0 },
{ "__const__", RID_CONST, 0 },
{ "__decltype", RID_DECLTYPE, D_CXXONLY },
+ { "__direct_bases", RID_DIRECT_BASES, D_CXXONLY },
{ "__extension__", RID_EXTENSION, 0 },
{ "__func__", RID_C99_FUNCTION_NAME, 0 },
{ "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
Index: gcc/c-family/c-common.h
===================================================================
--- gcc/c-family/c-common.h (revision 178892)
+++ gcc/c-family/c-common.h (working copy)
@@ -139,7 +139,8 @@
RID_IS_LITERAL_TYPE, RID_IS_POD,
RID_IS_POLYMORPHIC, RID_IS_STD_LAYOUT,
RID_IS_TRIVIAL, RID_IS_UNION,
- RID_UNDERLYING_TYPE,
+ RID_UNDERLYING_TYPE, RID_BASES,
+ RID_DIRECT_BASES,
/* C++0x */
RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR,
RID_STATIC_ASSERT,
Index: gcc/tree.h
===================================================================
--- gcc/tree.h (revision 178892)
+++ gcc/tree.h (working copy)
@@ -21,7 +21,6 @@
#ifndef GCC_TREE_H
#define GCC_TREE_H
-
#include "hashtab.h"
#include "machmode.h"
#include "input.h"
Index: gcc/cp/pt.c
===================================================================
--- gcc/cp/pt.c (revision 178892)
+++ gcc/cp/pt.c (working copy)
@@ -2976,6 +2976,10 @@
}
break;
+ case BASES:
+ case DIRECT_BASES:
+ parameter_pack_p = true;
+ break;
default:
/* Not a parameter pack. */
break;
@@ -9123,6 +9127,16 @@
tree arg_pack = NULL_TREE;
tree orig_arg = NULL_TREE;
+ if (TREE_CODE (parm_pack) == BASES)
+ {
+ return calculate_bases(tsubst_expr(BASES_TYPE(parm_pack),
+ args, complain, in_decl, false));
+ }
+ if (TREE_CODE (parm_pack) == DIRECT_BASES)
+ {
+ return
calculate_direct_bases(tsubst_expr(DIRECT_BASES_TYPE(parm_pack),
+ args, complain, in_decl, false));
+ }
if (TREE_CODE (parm_pack) == PARM_DECL)
{
if (!cp_unevaluated_operand)
Index: gcc/cp/semantics.c
===================================================================
--- gcc/cp/semantics.c (revision 178892)
+++ gcc/cp/semantics.c (working copy)
@@ -3407,6 +3407,155 @@
return underlying_type;
}
+/* Implement the __direct_bases keyword: Return the direct base classes
+ of type */
+tree
+calculate_direct_bases (tree type)
+{
+ VEC(tree, gc) *vector;
+ tree bases_vec = NULL_TREE;
+ VEC(tree, none) *base_binfos;
+ tree binfo;
+ unsigned i;
+
+ complete_type (type);
+
+ if (!NON_UNION_CLASS_TYPE_P (type))
+ {
+ return bases_vec;
+ }
+ /* Virtual bases are initialized first */
+ vector = VEC_copy (tree, gc, CLASSTYPE_VBASECLASSES (type));
+
+ base_binfos = BINFO_BASE_BINFOS(TYPE_BINFO (complete_type
(TYPE_MAIN_VARIANT (type))));
+ for (i = 0; VEC_iterate (tree, base_binfos, i, binfo); i++)
+ {
+ /* Now the non-virtual bases */
+ if (!BINFO_VIRTUAL_P (binfo))
+ {
+ VEC_safe_push (tree, gc, vector, binfo);
+ }
+ }
+
+ bases_vec = make_tree_vec (VEC_length (tree, vector));
+
+ for (i = 0; i < VEC_length (tree, vector); ++i)
+ {
+ TREE_VEC_ELT (bases_vec, i) = BINFO_TYPE (VEC_index (tree,
vector, i));
+ }
+ return bases_vec;
+}
+
+tree
+finish_direct_bases (tree type)
+{
+ tree direct_bases = NULL_TREE;
+
+ if (!processing_template_decl)
+ {
+ /* Parameter packs can only be used in templates */
+ error ("__direct_bases only valid in template declaration");
+ return error_mark_node;
+ }
+
+ direct_bases = cxx_make_type (DIRECT_BASES);
+ DIRECT_BASES_TYPE (direct_bases) = type;
+ SET_TYPE_STRUCTURAL_EQUALITY (direct_bases);
+
+ return direct_bases;
+
+}
+
+/* Implement the __bases keyword: Return the base classes
+ of type */
+
+/* Find morally non-virtual base classes by walking binfo hierarchy */
+/* Virtual base classes are handled separately in finish_bases */
+
+static tree
+dfs_calculate_bases_pre (tree binfo, void *data_)
+{
+ (void)data_;
+ /* Don't walk bases of virtual bases */
+ return BINFO_VIRTUAL_P (binfo) ? dfs_skip_bases : NULL_TREE;
+}
+
+static tree
+dfs_calculate_bases_post (tree binfo, void *data_)
+{
+ VEC(tree, gc) **data = (VEC(tree, gc) **) data_;
+ if (!BINFO_VIRTUAL_P (binfo))
+ {
+ VEC_safe_push (tree, gc, *data, BINFO_TYPE (binfo));
+ }
+ return NULL_TREE;
+}
+
+static VEC(tree, gc) *
+calculate_bases_helper (tree type)
+{
+ VEC(tree, gc) *vector = make_tree_vector();
+ unsigned i;
+ VEC(tree,gc) *vbases;
+ tree binfo;
+
+ /* First go through virtual base classes */
+ for (vbases = CLASSTYPE_VBASECLASSES (type), i = 0;
+ VEC_iterate (tree, vbases, i, binfo); i++)
+ {
+ VEC_safe_splice (tree, gc, vector, calculate_bases_helper
(BINFO_TYPE (binfo)));
+ }
+
+ /* Now add non-virtual base classes in order of construction */
+ dfs_walk_all (TYPE_BINFO (complete_type (TYPE_MAIN_VARIANT (type))),
+ dfs_calculate_bases_pre, dfs_calculate_bases_post,
&vector);
+ return vector;
+}
+
+tree
+calculate_bases (tree type)
+{
+ VEC(tree, gc) *vector;
+ tree bases_vec = NULL_TREE;
+ unsigned i;
+
+ complete_type (type);
+
+ if (!NON_UNION_CLASS_TYPE_P (type))
+ {
+ return bases_vec;
+ }
+
+ vector = calculate_bases_helper (type);
+ /* Last element is entire class, so don't copy */
+ bases_vec = make_tree_vec (VEC_length (tree, vector) - 1);
+
+ for (i = 0; i < VEC_length (tree, vector) - 1; ++i)
+ {
+ TREE_VEC_ELT (bases_vec, i) = VEC_index (tree, vector, i);
+ }
+ return bases_vec;
+}
+
+tree
+finish_bases (tree type)
+{
+ tree bases = NULL_TREE;
+
+ if (!processing_template_decl)
+ {
+ /* Parameter packs can only be used in templates */
+ error ("Parameter pack __bases only valid in template declaration");
+ return error_mark_node;
+ }
+
+ bases = cxx_make_type (BASES);
+ BASES_TYPE (bases) = type;
+ SET_TYPE_STRUCTURAL_EQUALITY (bases);
+
+ return bases;
+}
+
/* Perform C++-specific checks for __builtin_offsetof before calling
fold_offsetof. */
Index: gcc/cp/parser.c
===================================================================
--- gcc/cp/parser.c (revision 178892)
+++ gcc/cp/parser.c (working copy)
@@ -7295,6 +7295,12 @@
case RID_UNDERLYING_TYPE:
kind = CPTK_UNDERLYING_TYPE;
break;
+ case RID_BASES:
+ kind = CPTK_BASES;
+ break;
+ case RID_DIRECT_BASES:
+ kind = CPTK_DIRECT_BASES;
+ break;
default:
gcc_unreachable ();
}
@@ -7339,9 +7345,17 @@
/* Complete the trait expression, which may mean either processing
the trait expr now or saving it for template instantiation. */
- return kind != CPTK_UNDERLYING_TYPE
- ? finish_trait_expr (kind, type1, type2)
- : finish_underlying_type (type1);
+ switch(kind)
+ {
+ case CPTK_UNDERLYING_TYPE:
+ return finish_underlying_type (type1);
+ case CPTK_BASES:
+ return finish_bases (type1);
+ case CPTK_DIRECT_BASES:
+ return finish_direct_bases (type1);
+ default:
+ return finish_trait_expr (kind, type1, type2);
+ }
}
/* Lambdas that appear in variable initializer or default argument scope
@@ -12010,6 +12024,7 @@
parser->integral_constant_expression_p = false;
saved_non_ice_p = parser->non_integral_constant_expression_p;
parser->non_integral_constant_expression_p = false;
+
/* Parse the arguments. */
do
{
@@ -12826,7 +12841,9 @@
return type;
case RID_UNDERLYING_TYPE:
- type = cp_parser_trait_expr (parser, RID_UNDERLYING_TYPE);
+ case RID_BASES:
+ case RID_DIRECT_BASES:
+ type = cp_parser_trait_expr (parser, token->keyword);
if (decl_specs)
cp_parser_set_decl_spec_type (decl_specs, type,
@@ -20534,7 +20551,7 @@
}
/* Parse a template-argument-list, as well as the trailing ">" (but
- not the opening ">"). See cp_parser_template_argument_list for the
+ not the opening "<"). See cp_parser_template_argument_list for the
return value. */
static tree
Index: gcc/cp/cp-tree.def
===================================================================
--- gcc/cp/cp-tree.def (revision 178892)
+++ gcc/cp/cp-tree.def (working copy)
@@ -461,6 +461,14 @@
UNDERLYING_TYPE_TYPE is the type in question. */
DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
+/* A type designated by `__bases (type)'.
+ BASES_TYPE is the type in question. */
+DEFTREECODE (BASES, "bases", tcc_type, 0)
+
+/* A type designated by `__direct_bases (type)'.
+ DIRECT_BASES_TYPE is the type in question. */
+DEFTREECODE (DIRECT_BASES, "direct_bases", tcc_type, 0)
+
/* Used to represent the template information stored by template
specializations.
The accessors are:
Index: gcc/cp/cp-tree.h
===================================================================
--- gcc/cp/cp-tree.h (revision 178892)
+++ gcc/cp/cp-tree.h (working copy)
@@ -578,7 +578,9 @@
CPTK_IS_STD_LAYOUT,
CPTK_IS_TRIVIAL,
CPTK_IS_UNION,
- CPTK_UNDERLYING_TYPE
+ CPTK_UNDERLYING_TYPE,
+ CPTK_BASES,
+ CPTK_DIRECT_BASES
} cp_trait_kind;
/* The types that we are processing. */
@@ -3416,6 +3418,14 @@
#define UNDERLYING_TYPE_TYPE(NODE) \
(TYPE_VALUES_RAW (UNDERLYING_TYPE_CHECK (NODE)))
+/* The type in question for BASES. */
+#define BASES_TYPE(NODE) \
+ (TYPE_VALUES_RAW (BASES_CHECK (NODE)))
+
+/* The type in question for DIRECT_BASES. */
+#define DIRECT_BASES_TYPE(NODE) \
+ (TYPE_VALUES_RAW (DIRECT_BASES_CHECK (NODE)))
+
/* The expression in question for a DECLTYPE_TYPE. */
#define DECLTYPE_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (DECLTYPE_TYPE_CHECK
(NODE)))
@@ -5430,6 +5440,10 @@
location_t);
extern tree finish_typeof (tree);
extern tree finish_underlying_type (tree);
+extern tree calculate_bases (tree);
+extern tree finish_bases (tree);
+extern tree calculate_direct_bases (tree);
+extern tree finish_direct_bases (tree);
extern tree finish_offsetof (tree);
extern void finish_decl_cleanup (tree, tree);
extern void finish_eh_cleanup (tree);
More information about the Gcc-patches
mailing list