[thirdparty/gcc.git] / gcc / cp / cp-objcp-common.c

/* Some code common to C++ and ObjC++ front ends.
   Copyright (C) 2004-2018 Free Software Foundation, Inc.
   Contributed by Ziemowit Laski  <zlaski@apple.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "cp-tree.h"
#include "cp-objcp-common.h"
#include "dwarf2.h"

/* Special routine to get the alias set for C++.  */

alias_set_type
cxx_get_alias_set (tree t)
{
  if (IS_FAKE_BASE_TYPE (t))
    /* The base variant of a type must be in the same alias set as the
       complete type.  */
    return get_alias_set (TYPE_CONTEXT (t));

  /* Punt on PMFs until we canonicalize functions properly.  */
  if (TYPE_PTRMEMFUNC_P (t)
      || (POINTER_TYPE_P (t)
	  && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))))
    return 0;

  return c_common_get_alias_set (t);
}

/* Called from check_global_declaration.  */

bool
cxx_warn_unused_global_decl (const_tree decl)
{
  if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
    return false;
  if (DECL_IN_SYSTEM_HEADER (decl))
    return false;

  return true;
}

/* Langhook for tree_size: determine size of our 'x' and 'c' nodes.  */
size_t
cp_tree_size (enum tree_code code)
{
  gcc_checking_assert (code >= NUM_TREE_CODES);
  switch (code)
    {
    case PTRMEM_CST:		return sizeof (ptrmem_cst);
    case BASELINK:		return sizeof (tree_baselink);
    case TEMPLATE_PARM_INDEX:	return sizeof (template_parm_index);
    case DEFAULT_ARG:		return sizeof (tree_default_arg);
    case DEFERRED_NOEXCEPT:	return sizeof (tree_deferred_noexcept);
    case OVERLOAD:		return sizeof (tree_overload);
    case STATIC_ASSERT:         return sizeof (tree_static_assert);
    case TYPE_ARGUMENT_PACK:
    case TYPE_PACK_EXPANSION:	return sizeof (tree_type_non_common);
    case NONTYPE_ARGUMENT_PACK:
    case EXPR_PACK_EXPANSION:	return sizeof (tree_exp);
    case ARGUMENT_PACK_SELECT:	return sizeof (tree_argument_pack_select);
    case TRAIT_EXPR:		return sizeof (tree_trait_expr);
    case LAMBDA_EXPR:           return sizeof (tree_lambda_expr);
    case TEMPLATE_INFO:         return sizeof (tree_template_info);
    case CONSTRAINT_INFO:       return sizeof (tree_constraint_info);
    case USERDEF_LITERAL:	return sizeof (tree_userdef_literal);
    case TEMPLATE_DECL:		return sizeof (tree_template_decl);
    default:
      switch (TREE_CODE_CLASS (code))
	{
	case tcc_declaration:	return sizeof (tree_decl_non_common);
	case tcc_type:		return sizeof (tree_type_non_common);
	default: gcc_unreachable ();
	}
    }
  /* NOTREACHED */
}

/* Returns true if T is a variably modified type, in the sense of C99.
   FN is as passed to variably_modified_p.
   This routine needs only check cases that cannot be handled by the
   language-independent logic in tree.c.  */

bool
cp_var_mod_type_p (tree type, tree fn)
{
  /* If TYPE is a pointer-to-member, it is variably modified if either
     the class or the member are variably modified.  */
  if (TYPE_PTRMEM_P (type))
    return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn)
	    || variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type),
					 fn));

  /* All other types are not variably modified.  */
  return false;
}

/* This compares two types for equivalence ("compatible" in C-based languages).
   This routine should only return 1 if it is sure.  It should not be used
   in contexts where erroneously returning 0 causes problems.  */

int
cxx_types_compatible_p (tree x, tree y)
{
  return same_type_ignoring_top_level_qualifiers_p (x, y);
}

static GTY((cache)) tree_cache_map *debug_type_map;

/* Return a type to use in the debug info instead of TYPE, or NULL_TREE to
   keep TYPE.  */

tree
cp_get_debug_type (const_tree type)
{
  tree dtype = NULL_TREE;

  if (TYPE_PTRMEMFUNC_P (type) && !typedef_variant_p (type))
    dtype = build_offset_type (TYPE_PTRMEMFUNC_OBJECT_TYPE (type),
			       TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type)));

  /* We cannot simply return the debug type here because the function uses
     the type canonicalization hashtable, which is GC-ed, so its behavior
     depends on the actual collection points.  Since we are building these
     types on the fly for the debug info only, they would not be attached
     to any GC root and always be swept, so we would make the contents of
     the debug info depend on the collection points.  */
  if (dtype)
    {
      tree ktype = CONST_CAST_TREE (type);
      if (debug_type_map == NULL)
	debug_type_map = tree_cache_map::create_ggc (512);
      else if (tree *slot = debug_type_map->get (ktype))
	return *slot;
      debug_type_map->put (ktype, dtype);
    }

  return dtype;
}

/* Return -1 if dwarf ATTR shouldn't be added for DECL, or the attribute
   value otherwise.  */
int
cp_decl_dwarf_attribute (const_tree decl, int attr)
{
  if (decl == NULL_TREE)
    return -1;

  switch (attr)
    {
    case DW_AT_explicit:
      if (TREE_CODE (decl) == FUNCTION_DECL
	  && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
	  && DECL_NONCONVERTING_P (decl))
	return 1;
      break;

    case DW_AT_deleted:
      if (TREE_CODE (decl) == FUNCTION_DECL
	  && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
	  && DECL_DELETED_FN (decl))
	return 1;
      break;

    case DW_AT_defaulted:
      if (TREE_CODE (decl) == FUNCTION_DECL
	  && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
	  && DECL_DEFAULTED_FN (decl))
	{
	  if (DECL_DEFAULTED_IN_CLASS_P (decl))
	    return DW_DEFAULTED_in_class;

	  if (DECL_DEFAULTED_OUTSIDE_CLASS_P (decl))
	    return DW_DEFAULTED_out_of_class;
	}
      break;

    case DW_AT_const_expr:
      if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
	return 1;
      break;

    case DW_AT_reference:
      if (TREE_CODE (decl) == FUNCTION_DECL
	  && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
	  && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
	  && !FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
	return 1;
      break;

    case DW_AT_rvalue_reference:
      if (TREE_CODE (decl) == FUNCTION_DECL
	  && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
	  && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
	  && FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
	return 1;
      break;

    case DW_AT_inline:
      if (VAR_P (decl) && DECL_INLINE_VAR_P (decl))
	{
	  if (DECL_VAR_DECLARED_INLINE_P (decl))
	    return DW_INL_declared_inlined;
	  else
	    return DW_INL_inlined;
	}
      break;

    case DW_AT_export_symbols:
      if (TREE_CODE (decl) == NAMESPACE_DECL
	  && (DECL_NAMESPACE_INLINE_P (decl)
	      || (DECL_NAME (decl) == NULL_TREE && dwarf_version >= 5)))
	return 1;
      break;

    default:
      break;
    }

  return -1;
}

/* Return -1 if dwarf ATTR shouldn't be added for TYPE, or the attribute
   value otherwise.  */
int
cp_type_dwarf_attribute (const_tree type, int attr)
{
  if (type == NULL_TREE)
    return -1;

  switch (attr)
    {
    case DW_AT_reference:
      if ((TREE_CODE (type) == FUNCTION_TYPE
	   || TREE_CODE (type) == METHOD_TYPE)
	  && FUNCTION_REF_QUALIFIED (type)
	  && !FUNCTION_RVALUE_QUALIFIED (type))
	return 1;
      break;

    case DW_AT_rvalue_reference:
      if ((TREE_CODE (type) == FUNCTION_TYPE
	   || TREE_CODE (type) == METHOD_TYPE)
	  && FUNCTION_REF_QUALIFIED (type)
	  && FUNCTION_RVALUE_QUALIFIED (type))
	return 1;
      break;

    default:
      break;
    }

  return -1;
}

/* Return the unit size of TYPE without reusable tail padding.  */

tree
cp_unit_size_without_reusable_padding (tree type)
{
  if (CLASS_TYPE_P (type))
    return CLASSTYPE_SIZE_UNIT (type);
  return TYPE_SIZE_UNIT (type);
}

/* Stubs to keep c-opts.c happy.  */
void
push_file_scope (void)
{
}

void
pop_file_scope (void)
{
}

/* c-pragma.c needs to query whether a decl has extern "C" linkage.  */
bool
has_c_linkage (const_tree decl)
{
  return DECL_EXTERN_C_P (decl);
}

static GTY ((cache))
     hash_table<tree_decl_map_cache_hasher> *shadowed_var_for_decl;

/* Lookup a shadowed var for FROM, and return it if we find one.  */

tree
decl_shadowed_for_var_lookup (tree from)
{
  struct tree_decl_map *h, in;
  in.base.from = from;

  h = shadowed_var_for_decl->find_with_hash (&in, DECL_UID (from));
  if (h)
    return h->to;
  return NULL_TREE;
}

/* Insert a mapping FROM->TO in the shadowed var hashtable.  */

void
decl_shadowed_for_var_insert (tree from, tree to)
{
  struct tree_decl_map *h;

  h = ggc_alloc<tree_decl_map> ();
  h->base.from = from;
  h->to = to;
  *shadowed_var_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
}

void
init_shadowed_var_for_decl (void)
{
  shadowed_var_for_decl
    = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
}

/* Return true if stmt can fall through.  Used by block_may_fallthru
   default case.  */

bool
cxx_block_may_fallthru (const_tree stmt)
{
  switch (TREE_CODE (stmt))
    {
    case EXPR_STMT:
      return block_may_fallthru (EXPR_STMT_EXPR (stmt));

    case THROW_EXPR:
      return false;

    case SWITCH_STMT:
      return (!SWITCH_STMT_ALL_CASES_P (stmt)
	      || !SWITCH_STMT_NO_BREAK_P (stmt)
	      || block_may_fallthru (SWITCH_STMT_BODY (stmt)));

    default:
      return true;
    }
}

/* Return the list of decls in the global namespace.  */

tree
cp_get_global_decls ()
{
  return NAMESPACE_LEVEL (global_namespace)->names;
}

/* Push DECL into the current scope.  */

tree
cp_pushdecl (tree decl)
{
  return pushdecl (decl);
}

/* Get the global value binding of NAME.  Called directly from
   c-common.c, not via a hook. */

tree
identifier_global_value (tree name)
{
  return get_global_binding (name);
}

/* Register c++-specific dumps.  */

void
cp_register_dumps (gcc::dump_manager *dumps)
{
  class_dump_id = dumps->dump_register
    (".class", "lang-class", "lang-class", DK_lang, OPTGROUP_NONE, false);

  raw_dump_id = dumps->dump_register
    (".raw", "lang-raw", "lang-raw", DK_lang, OPTGROUP_NONE, false);
}

void
cp_common_init_ts (void)
{
  MARK_TS_DECL_NON_COMMON (USING_DECL);
  MARK_TS_DECL_COMMON (TEMPLATE_DECL);
  MARK_TS_DECL_COMMON (WILDCARD_DECL);

  MARK_TS_COMMON (TEMPLATE_TEMPLATE_PARM);
  MARK_TS_COMMON (TEMPLATE_TYPE_PARM);
  MARK_TS_COMMON (TEMPLATE_PARM_INDEX);
  MARK_TS_COMMON (OVERLOAD);
  MARK_TS_COMMON (TEMPLATE_INFO);
  MARK_TS_COMMON (TYPENAME_TYPE);
  MARK_TS_COMMON (TYPEOF_TYPE);
  MARK_TS_COMMON (UNDERLYING_TYPE);
  MARK_TS_COMMON (BASELINK);
  MARK_TS_COMMON (TYPE_PACK_EXPANSION);
  MARK_TS_COMMON (TYPE_ARGUMENT_PACK);
  MARK_TS_COMMON (DECLTYPE_TYPE);
  MARK_TS_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM);
  MARK_TS_COMMON (UNBOUND_CLASS_TEMPLATE);

  MARK_TS_TYPED (EXPR_PACK_EXPANSION);
  MARK_TS_TYPED (SWITCH_STMT);
  MARK_TS_TYPED (IF_STMT);
  MARK_TS_TYPED (FOR_STMT);
  MARK_TS_TYPED (RANGE_FOR_STMT);
  MARK_TS_TYPED (AGGR_INIT_EXPR);
  MARK_TS_TYPED (EXPR_STMT);
  MARK_TS_TYPED (EH_SPEC_BLOCK);
  MARK_TS_TYPED (CLEANUP_STMT);
  MARK_TS_TYPED (SCOPE_REF);
  MARK_TS_TYPED (CAST_EXPR);
  MARK_TS_TYPED (NON_DEPENDENT_EXPR);
  MARK_TS_TYPED (MODOP_EXPR);
  MARK_TS_TYPED (TRY_BLOCK);
  MARK_TS_TYPED (THROW_EXPR);
  MARK_TS_TYPED (HANDLER);
  MARK_TS_TYPED (REINTERPRET_CAST_EXPR);
  MARK_TS_TYPED (CONST_CAST_EXPR);
  MARK_TS_TYPED (STATIC_CAST_EXPR);
  MARK_TS_TYPED (DYNAMIC_CAST_EXPR);
  MARK_TS_TYPED (IMPLICIT_CONV_EXPR);
  MARK_TS_TYPED (TEMPLATE_ID_EXPR);
  MARK_TS_TYPED (ARROW_EXPR);
  MARK_TS_TYPED (SIZEOF_EXPR);
  MARK_TS_TYPED (ALIGNOF_EXPR);
  MARK_TS_TYPED (AT_ENCODE_EXPR);
  MARK_TS_TYPED (UNARY_PLUS_EXPR);
  MARK_TS_TYPED (TRAIT_EXPR);
  MARK_TS_TYPED (TYPE_ARGUMENT_PACK);
  MARK_TS_TYPED (NOEXCEPT_EXPR);
  MARK_TS_TYPED (NONTYPE_ARGUMENT_PACK);
  MARK_TS_TYPED (WHILE_STMT);
  MARK_TS_TYPED (NEW_EXPR);
  MARK_TS_TYPED (VEC_NEW_EXPR);
  MARK_TS_TYPED (BREAK_STMT);
  MARK_TS_TYPED (MEMBER_REF);
  MARK_TS_TYPED (DOTSTAR_EXPR);
  MARK_TS_TYPED (DO_STMT);
  MARK_TS_TYPED (DELETE_EXPR);
  MARK_TS_TYPED (VEC_DELETE_EXPR);
  MARK_TS_TYPED (CONTINUE_STMT);
  MARK_TS_TYPED (TAG_DEFN);
  MARK_TS_TYPED (PSEUDO_DTOR_EXPR);
  MARK_TS_TYPED (TYPEID_EXPR);
  MARK_TS_TYPED (MUST_NOT_THROW_EXPR);
  MARK_TS_TYPED (STMT_EXPR);
  MARK_TS_TYPED (OFFSET_REF);
  MARK_TS_TYPED (OFFSETOF_EXPR);
  MARK_TS_TYPED (ADDRESSOF_EXPR);
  MARK_TS_TYPED (PTRMEM_CST);
  MARK_TS_TYPED (EMPTY_CLASS_EXPR);
  MARK_TS_TYPED (VEC_INIT_EXPR);
  MARK_TS_TYPED (USING_STMT);
  MARK_TS_TYPED (LAMBDA_EXPR);
  MARK_TS_TYPED (CTOR_INITIALIZER);
  MARK_TS_TYPED (REQUIRES_EXPR);
  MARK_TS_TYPED (UNARY_LEFT_FOLD_EXPR);
  MARK_TS_TYPED (UNARY_RIGHT_FOLD_EXPR);
  MARK_TS_TYPED (BINARY_LEFT_FOLD_EXPR);
  MARK_TS_TYPED (BINARY_RIGHT_FOLD_EXPR);
}

#include "gt-cp-cp-objcp-common.h"
Commit	Line	Data
11bb4b27	1	/* Some code common to C++ and ObjC++ front ends.
85ec4feb	2	Copyright (C) 2004-2018 Free Software Foundation, Inc.
11bb4b27 ZL	3	Contributed by Ziemowit Laski <zlaski@apple.com>
	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
e77f031d	9	Software Foundation; either version 3, or (at your option) any later
11bb4b27 ZL	10	version.
	11
	12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	for more details.
	16
	17	You should have received a copy of the GNU General Public License
e77f031d NC	18	along with GCC; see the file COPYING3. If not see
e77f031d NC	19	<http://www.gnu.org/licenses/>. */
11bb4b27 ZL	20
	21	#include "config.h"
	22	#include "system.h"
	23	#include "coretypes.h"
11bb4b27	24	#include "cp-tree.h"
11bb4b27	25	#include "cp-objcp-common.h"
81b42cc6	26	#include "dwarf2.h"
11bb4b27 ZL	27
	28	/* Special routine to get the alias set for C++. */
	29
4862826d	30	alias_set_type
11bb4b27 ZL	31	cxx_get_alias_set (tree t)
	32	{
	33	if (IS_FAKE_BASE_TYPE (t))
	34	/* The base variant of a type must be in the same alias set as the
	35	complete type. */
	36	return get_alias_set (TYPE_CONTEXT (t));
	37
	38	/* Punt on PMFs until we canonicalize functions properly. */
a489b1f0 RG	39	if (TYPE_PTRMEMFUNC_P (t)
	40	\|\| (POINTER_TYPE_P (t)
	41	&& TYPE_PTRMEMFUNC_P (TREE_TYPE (t))))
11bb4b27 ZL	42	return 0;
	43
	44	return c_common_get_alias_set (t);
	45	}
	46
d7438551	47	/* Called from check_global_declaration. */
11bb4b27 ZL	48
11bb4b27 ZL	49	bool
ac7d7749	50	cxx_warn_unused_global_decl (const_tree decl)
11bb4b27 ZL	51	{
	52	if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
	53	return false;
	54	if (DECL_IN_SYSTEM_HEADER (decl))
	55	return false;
	56
11bb4b27 ZL	57	return true;
	58	}
	59
11bb4b27 ZL	60	/* Langhook for tree_size: determine size of our 'x' and 'c' nodes. */
	61	size_t
	62	cp_tree_size (enum tree_code code)
	63	{
f419fd1f	64	gcc_checking_assert (code >= NUM_TREE_CODES);
11bb4b27 ZL	65	switch (code)
11bb4b27 ZL	66	{
f419fd1f NS	67	case PTRMEM_CST: return sizeof (ptrmem_cst);
f419fd1f NS	68	case BASELINK: return sizeof (tree_baselink);
0cbd7506	69	case TEMPLATE_PARM_INDEX: return sizeof (template_parm_index);
f419fd1f NS	70	case DEFAULT_ARG: return sizeof (tree_default_arg);
	71	case DEFERRED_NOEXCEPT: return sizeof (tree_deferred_noexcept);
	72	case OVERLOAD: return sizeof (tree_overload);
	73	case STATIC_ASSERT: return sizeof (tree_static_assert);
5d80a306	74	case TYPE_ARGUMENT_PACK:
f419fd1f	75	case TYPE_PACK_EXPANSION: return sizeof (tree_type_non_common);
5d80a306	76	case NONTYPE_ARGUMENT_PACK:
f419fd1f NS	77	case EXPR_PACK_EXPANSION: return sizeof (tree_exp);
	78	case ARGUMENT_PACK_SELECT: return sizeof (tree_argument_pack_select);
	79	case TRAIT_EXPR: return sizeof (tree_trait_expr);
	80	case LAMBDA_EXPR: return sizeof (tree_lambda_expr);
	81	case TEMPLATE_INFO: return sizeof (tree_template_info);
	82	case CONSTRAINT_INFO: return sizeof (tree_constraint_info);
	83	case USERDEF_LITERAL: return sizeof (tree_userdef_literal);
	84	case TEMPLATE_DECL: return sizeof (tree_template_decl);
11bb4b27	85	default:
f419fd1f NS	86	switch (TREE_CODE_CLASS (code))
	87	{
	88	case tcc_declaration: return sizeof (tree_decl_non_common);
	89	case tcc_type: return sizeof (tree_type_non_common);
	90	default: gcc_unreachable ();
	91	}
11bb4b27 ZL	92	}
	93	/* NOTREACHED */
	94	}
	95
	96	/* Returns true if T is a variably modified type, in the sense of C99.
	97	FN is as passed to variably_modified_p.
	98	This routine needs only check cases that cannot be handled by the
	99	language-independent logic in tree.c. */
	100
	101	bool
	102	cp_var_mod_type_p (tree type, tree fn)
	103	{
	104	/* If TYPE is a pointer-to-member, it is variably modified if either
	105	the class or the member are variably modified. */
66b1156a	106	if (TYPE_PTRMEM_P (type))
11bb4b27 ZL	107	return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn)
	108	\|\| variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type),
	109	fn));
	110
	111	/* All other types are not variably modified. */
	112	return false;
	113	}
	114
65958285 ZL	115	/* This compares two types for equivalence ("compatible" in C-based languages).
	116	This routine should only return 1 if it is sure. It should not be used
	117	in contexts where erroneously returning 0 causes problems. */
	118
	119	int
	120	cxx_types_compatible_p (tree x, tree y)
	121	{
cf7bc668	122	return same_type_ignoring_top_level_qualifiers_p (x, y);
65958285 ZL	123	}
65958285 ZL	124
21faa101	125	static GTY((cache)) tree_cache_map *debug_type_map;
a49bf6f0	126
6905c577 JJ	127	/* Return a type to use in the debug info instead of TYPE, or NULL_TREE to
	128	keep TYPE. */
	129
	130	tree
	131	cp_get_debug_type (const_tree type)
	132	{
21faa101 JM	133	tree dtype = NULL_TREE;
21faa101 JM	134
6905c577	135	if (TYPE_PTRMEMFUNC_P (type) && !typedef_variant_p (type))
21faa101 JM	136	dtype = build_offset_type (TYPE_PTRMEMFUNC_OBJECT_TYPE (type),
	137	TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type)));
	138
	139	/* We cannot simply return the debug type here because the function uses
	140	the type canonicalization hashtable, which is GC-ed, so its behavior
	141	depends on the actual collection points. Since we are building these
	142	types on the fly for the debug info only, they would not be attached
	143	to any GC root and always be swept, so we would make the contents of
	144	the debug info depend on the collection points. */
	145	if (dtype)
a49bf6f0	146	{
21faa101 JM	147	tree ktype = CONST_CAST_TREE (type);
	148	if (debug_type_map == NULL)
	149	debug_type_map = tree_cache_map::create_ggc (512);
	150	else if (tree *slot = debug_type_map->get (ktype))
	151	return *slot;
	152	debug_type_map->put (ktype, dtype);
a49bf6f0	153	}
6905c577	154
21faa101	155	return dtype;
6905c577 JJ	156	}
6905c577 JJ	157
81b42cc6 JJ	158	/* Return -1 if dwarf ATTR shouldn't be added for DECL, or the attribute
	159	value otherwise. */
	160	int
	161	cp_decl_dwarf_attribute (const_tree decl, int attr)
68599f33	162	{
81b42cc6 JJ	163	if (decl == NULL_TREE)
81b42cc6 JJ	164	return -1;
68599f33	165
81b42cc6 JJ	166	switch (attr)
	167	{
	168	case DW_AT_explicit:
	169	if (TREE_CODE (decl) == FUNCTION_DECL
	170	&& DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
	171	&& DECL_NONCONVERTING_P (decl))
	172	return 1;
	173	break;
f5059223	174
81b42cc6 JJ	175	case DW_AT_deleted:
81b42cc6 JJ	176	if (TREE_CODE (decl) == FUNCTION_DECL
f5059223	177	&& DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
81b42cc6 JJ	178	&& DECL_DELETED_FN (decl))
	179	return 1;
	180	break;
f5059223	181
81b42cc6 JJ	182	case DW_AT_defaulted:
	183	if (TREE_CODE (decl) == FUNCTION_DECL
	184	&& DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
	185	&& DECL_DEFAULTED_FN (decl))
	186	{
	187	if (DECL_DEFAULTED_IN_CLASS_P (decl))
	188	return DW_DEFAULTED_in_class;
e366d7d8	189
81b42cc6 JJ	190	if (DECL_DEFAULTED_OUTSIDE_CLASS_P (decl))
	191	return DW_DEFAULTED_out_of_class;
	192	}
	193	break;
e366d7d8	194
8e6982f7 JJ	195	case DW_AT_const_expr:
	196	if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
	197	return 1;
	198	break;
	199
0f2a9e37 JJ	200	case DW_AT_reference:
	201	if (TREE_CODE (decl) == FUNCTION_DECL
	202	&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
	203	&& FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
	204	&& !FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
	205	return 1;
0f2a9e37 JJ	206	break;
	207
	208	case DW_AT_rvalue_reference:
	209	if (TREE_CODE (decl) == FUNCTION_DECL
	210	&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
	211	&& FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
	212	&& FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
	213	return 1;
0f2a9e37 JJ	214	break;
0f2a9e37 JJ	215
70d28813 JJ	216	case DW_AT_inline:
	217	if (VAR_P (decl) && DECL_INLINE_VAR_P (decl))
	218	{
	219	if (DECL_VAR_DECLARED_INLINE_P (decl))
	220	return DW_INL_declared_inlined;
	221	else
	222	return DW_INL_inlined;
	223	}
	224	break;
	225
e071b767 JJ	226	case DW_AT_export_symbols:
	227	if (TREE_CODE (decl) == NAMESPACE_DECL
	228	&& (DECL_NAMESPACE_INLINE_P (decl)
	229	\|\| (DECL_NAME (decl) == NULL_TREE && dwarf_version >= 5)))
	230	return 1;
	231	break;
	232
81b42cc6 JJ	233	default:
81b42cc6 JJ	234	break;
e366d7d8 AO	235	}
e366d7d8 AO	236
81b42cc6	237	return -1;
e366d7d8 AO	238	}
e366d7d8 AO	239
6905c577 JJ	240	/* Return -1 if dwarf ATTR shouldn't be added for TYPE, or the attribute
	241	value otherwise. */
	242	int
	243	cp_type_dwarf_attribute (const_tree type, int attr)
	244	{
	245	if (type == NULL_TREE)
	246	return -1;
	247
	248	switch (attr)
	249	{
	250	case DW_AT_reference:
	251	if ((TREE_CODE (type) == FUNCTION_TYPE
	252	\|\| TREE_CODE (type) == METHOD_TYPE)
	253	&& FUNCTION_REF_QUALIFIED (type)
	254	&& !FUNCTION_RVALUE_QUALIFIED (type))
	255	return 1;
	256	break;
	257
	258	case DW_AT_rvalue_reference:
	259	if ((TREE_CODE (type) == FUNCTION_TYPE
	260	\|\| TREE_CODE (type) == METHOD_TYPE)
	261	&& FUNCTION_REF_QUALIFIED (type)
	262	&& FUNCTION_RVALUE_QUALIFIED (type))
	263	return 1;
	264	break;
	265
	266	default:
	267	break;
	268	}
	269
	270	return -1;
	271	}
	272
b7fc43d7 RB	273	/* Return the unit size of TYPE without reusable tail padding. */
	274
	275	tree
	276	cp_unit_size_without_reusable_padding (tree type)
	277	{
	278	if (CLASS_TYPE_P (type))
	279	return CLASSTYPE_SIZE_UNIT (type);
	280	return TYPE_SIZE_UNIT (type);
	281	}
	282
11bb4b27 ZL	283	/* Stubs to keep c-opts.c happy. */
	284	void
	285	push_file_scope (void)
	286	{
	287	}
	288
	289	void
	290	pop_file_scope (void)
	291	{
	292	}
	293
	294	/* c-pragma.c needs to query whether a decl has extern "C" linkage. */
	295	bool
58f9752a	296	has_c_linkage (const_tree decl)
11bb4b27 ZL	297	{
	298	return DECL_EXTERN_C_P (decl);
	299	}
3ed8593d	300
d242408f TS	301	static GTY ((cache))
d242408f TS	302	hash_table<tree_decl_map_cache_hasher> *shadowed_var_for_decl;
3ed8593d AP	303
	304	/* Lookup a shadowed var for FROM, and return it if we find one. */
	305
3db45ab5	306	tree
3ed8593d AP	307	decl_shadowed_for_var_lookup (tree from)
3ed8593d AP	308	{
53e030f1	309	struct tree_decl_map *h, in;
fc8600f9	310	in.base.from = from;
3ed8593d	311
d242408f	312	h = shadowed_var_for_decl->find_with_hash (&in, DECL_UID (from));
3ed8593d AP	313	if (h)
	314	return h->to;
	315	return NULL_TREE;
	316	}
	317
	318	/* Insert a mapping FROM->TO in the shadowed var hashtable. */
	319
	320	void
	321	decl_shadowed_for_var_insert (tree from, tree to)
	322	{
53e030f1	323	struct tree_decl_map *h;
3ed8593d	324
766090c2	325	h = ggc_alloc<tree_decl_map> ();
fc8600f9	326	h->base.from = from;
3ed8593d	327	h->to = to;
d242408f	328	*shadowed_var_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
3ed8593d AP	329	}
	330
	331	void
	332	init_shadowed_var_for_decl (void)
	333	{
d242408f TS	334	shadowed_var_for_decl
d242408f TS	335	= hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
3ed8593d AP	336	}
3ed8593d AP	337
c65cb8d1	338	/* Return true if stmt can fall through. Used by block_may_fallthru
88cd0e88 JJ	339	default case. */
	340
	341	bool
	342	cxx_block_may_fallthru (const_tree stmt)
	343	{
	344	switch (TREE_CODE (stmt))
	345	{
	346	case EXPR_STMT:
	347	return block_may_fallthru (EXPR_STMT_EXPR (stmt));
	348
	349	case THROW_EXPR:
	350	return false;
	351
1a2e9708 JJ	352	case SWITCH_STMT:
	353	return (!SWITCH_STMT_ALL_CASES_P (stmt)
	354	\|\| !SWITCH_STMT_NO_BREAK_P (stmt)
	355	\|\| block_may_fallthru (SWITCH_STMT_BODY (stmt)));
	356
88cd0e88 JJ	357	default:
	358	return true;
	359	}
	360	}
	361
505dd180 NS	362	/* Return the list of decls in the global namespace. */
	363
	364	tree
	365	cp_get_global_decls ()
	366	{
	367	return NAMESPACE_LEVEL (global_namespace)->names;
	368	}
	369
	370	/* Push DECL into the current scope. */
	371
	372	tree
	373	cp_pushdecl (tree decl)
	374	{
	375	return pushdecl (decl);
	376	}
	377
87e3d7cf NS	378	/* Get the global value binding of NAME. Called directly from
	379	c-common.c, not via a hook. */
	380
	381	tree
	382	identifier_global_value (tree name)
	383	{
	384	return get_global_binding (name);
	385	}
	386
2a8a8d7b NS	387	/* Register c++-specific dumps. */
	388
	389	void
	390	cp_register_dumps (gcc::dump_manager *dumps)
	391	{
	392	class_dump_id = dumps->dump_register
	393	(".class", "lang-class", "lang-class", DK_lang, OPTGROUP_NONE, false);
58aca9d9 NS	394
	395	raw_dump_id = dumps->dump_register
	396	(".raw", "lang-raw", "lang-raw", DK_lang, OPTGROUP_NONE, false);
2a8a8d7b NS	397	}
2a8a8d7b NS	398
81f653d6 NF	399	void
	400	cp_common_init_ts (void)
	401	{
81f653d6	402	MARK_TS_DECL_NON_COMMON (USING_DECL);
ad115a3c	403	MARK_TS_DECL_COMMON (TEMPLATE_DECL);
971e17ff	404	MARK_TS_DECL_COMMON (WILDCARD_DECL);
81f653d6 NF	405
	406	MARK_TS_COMMON (TEMPLATE_TEMPLATE_PARM);
	407	MARK_TS_COMMON (TEMPLATE_TYPE_PARM);
	408	MARK_TS_COMMON (TEMPLATE_PARM_INDEX);
	409	MARK_TS_COMMON (OVERLOAD);
	410	MARK_TS_COMMON (TEMPLATE_INFO);
81f653d6 NF	411	MARK_TS_COMMON (TYPENAME_TYPE);
81f653d6 NF	412	MARK_TS_COMMON (TYPEOF_TYPE);
a0d260fc	413	MARK_TS_COMMON (UNDERLYING_TYPE);
81f653d6	414	MARK_TS_COMMON (BASELINK);
81f653d6	415	MARK_TS_COMMON (TYPE_PACK_EXPANSION);
0dfef520	416	MARK_TS_COMMON (TYPE_ARGUMENT_PACK);
81f653d6 NF	417	MARK_TS_COMMON (DECLTYPE_TYPE);
	418	MARK_TS_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM);
	419	MARK_TS_COMMON (UNBOUND_CLASS_TEMPLATE);
81f653d6	420
d26e5986	421	MARK_TS_TYPED (EXPR_PACK_EXPANSION);
1f18dbc6	422	MARK_TS_TYPED (SWITCH_STMT);
545f261b	423	MARK_TS_TYPED (IF_STMT);
40e71fc7 NF	424	MARK_TS_TYPED (FOR_STMT);
40e71fc7 NF	425	MARK_TS_TYPED (RANGE_FOR_STMT);
81f653d6 NF	426	MARK_TS_TYPED (AGGR_INIT_EXPR);
	427	MARK_TS_TYPED (EXPR_STMT);
	428	MARK_TS_TYPED (EH_SPEC_BLOCK);
	429	MARK_TS_TYPED (CLEANUP_STMT);
	430	MARK_TS_TYPED (SCOPE_REF);
	431	MARK_TS_TYPED (CAST_EXPR);
	432	MARK_TS_TYPED (NON_DEPENDENT_EXPR);
	433	MARK_TS_TYPED (MODOP_EXPR);
	434	MARK_TS_TYPED (TRY_BLOCK);
	435	MARK_TS_TYPED (THROW_EXPR);
	436	MARK_TS_TYPED (HANDLER);
	437	MARK_TS_TYPED (REINTERPRET_CAST_EXPR);
	438	MARK_TS_TYPED (CONST_CAST_EXPR);
	439	MARK_TS_TYPED (STATIC_CAST_EXPR);
	440	MARK_TS_TYPED (DYNAMIC_CAST_EXPR);
a4474a38	441	MARK_TS_TYPED (IMPLICIT_CONV_EXPR);
81f653d6 NF	442	MARK_TS_TYPED (TEMPLATE_ID_EXPR);
	443	MARK_TS_TYPED (ARROW_EXPR);
	444	MARK_TS_TYPED (SIZEOF_EXPR);
	445	MARK_TS_TYPED (ALIGNOF_EXPR);
	446	MARK_TS_TYPED (AT_ENCODE_EXPR);
	447	MARK_TS_TYPED (UNARY_PLUS_EXPR);
	448	MARK_TS_TYPED (TRAIT_EXPR);
	449	MARK_TS_TYPED (TYPE_ARGUMENT_PACK);
	450	MARK_TS_TYPED (NOEXCEPT_EXPR);
	451	MARK_TS_TYPED (NONTYPE_ARGUMENT_PACK);
	452	MARK_TS_TYPED (WHILE_STMT);
	453	MARK_TS_TYPED (NEW_EXPR);
	454	MARK_TS_TYPED (VEC_NEW_EXPR);
	455	MARK_TS_TYPED (BREAK_STMT);
	456	MARK_TS_TYPED (MEMBER_REF);
	457	MARK_TS_TYPED (DOTSTAR_EXPR);
	458	MARK_TS_TYPED (DO_STMT);
	459	MARK_TS_TYPED (DELETE_EXPR);
	460	MARK_TS_TYPED (VEC_DELETE_EXPR);
	461	MARK_TS_TYPED (CONTINUE_STMT);
	462	MARK_TS_TYPED (TAG_DEFN);
	463	MARK_TS_TYPED (PSEUDO_DTOR_EXPR);
	464	MARK_TS_TYPED (TYPEID_EXPR);
	465	MARK_TS_TYPED (MUST_NOT_THROW_EXPR);
	466	MARK_TS_TYPED (STMT_EXPR);
	467	MARK_TS_TYPED (OFFSET_REF);
	468	MARK_TS_TYPED (OFFSETOF_EXPR);
be845b04	469	MARK_TS_TYPED (ADDRESSOF_EXPR);
81f653d6 NF	470	MARK_TS_TYPED (PTRMEM_CST);
	471	MARK_TS_TYPED (EMPTY_CLASS_EXPR);
	472	MARK_TS_TYPED (VEC_INIT_EXPR);
	473	MARK_TS_TYPED (USING_STMT);
	474	MARK_TS_TYPED (LAMBDA_EXPR);
4ac74df2	475	MARK_TS_TYPED (CTOR_INITIALIZER);
971e17ff	476	MARK_TS_TYPED (REQUIRES_EXPR);
378b307d AS	477	MARK_TS_TYPED (UNARY_LEFT_FOLD_EXPR);
	478	MARK_TS_TYPED (UNARY_RIGHT_FOLD_EXPR);
	479	MARK_TS_TYPED (BINARY_LEFT_FOLD_EXPR);
	480	MARK_TS_TYPED (BINARY_RIGHT_FOLD_EXPR);
81f653d6	481	}
3ed8593d AP	482
3ed8593d AP	483	#include "gt-cp-cp-objcp-common.h"