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

/* Some code common to C++ and ObjC++ front ends.
   Copyright (C) 2004, 2007, 2008, 2009 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 "tm.h"
#include "tree.h"
#include "cp-tree.h"
#include "c-common.h"
#include "toplev.h"
#include "langhooks.h"
#include "langhooks-def.h"
#include "diagnostic.h"
#include "debug.h"
#include "cxx-pretty-print.h"
#include "cp-objcp-common.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_declarations.  */

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;

  /* Const variables take the place of #defines in C++.  */
  if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
    return false;

  return true;
}

/* Langhook for expr_size: Tell the back end that the value of an expression
   of non-POD class type does not include any tail padding; a derived class
   might have allocated something there.  */

tree
cp_expr_size (const_tree exp)
{
  tree type = TREE_TYPE (exp);

  if (CLASS_TYPE_P (type))
    {
      /* The back end should not be interested in the size of an expression
	 of a type with both of these set; all copies of such types must go
	 through a constructor or assignment op.  */
      if (!TYPE_HAS_COMPLEX_INIT_REF (type)
	  || !TYPE_HAS_COMPLEX_ASSIGN_REF (type)
	  /* But storing a CONSTRUCTOR isn't a copy.  */
	  || TREE_CODE (exp) == CONSTRUCTOR
	  /* And, the gimplifier will sometimes make a copy of
	     an aggregate.  In particular, for a case like:

		struct S { S(); };
		struct X { int a; S s; };
		X x = { 0 };

	     the gimplifier will create a temporary with
	     static storage duration, perform static
	     initialization of the temporary, and then copy
	     the result.  Since the "s" subobject is never
	     constructed, this is a valid transformation.  */
	  || CP_AGGREGATE_TYPE_P (type))
	/* This would be wrong for a type with virtual bases.  */
	return (is_really_empty_class (type)
		? size_zero_node
		: CLASSTYPE_SIZE_UNIT (type));
      else
	return NULL_TREE;
    }
  else
    /* Use the default code.  */
    return tree_expr_size (exp);
}

/* Langhook for tree_size: determine size of our 'x' and 'c' nodes.  */
size_t
cp_tree_size (enum tree_code code)
{
  switch (code)
    {
    case PTRMEM_CST:		return sizeof (struct ptrmem_cst);
    case BASELINK:		return sizeof (struct tree_baselink);
    case TEMPLATE_PARM_INDEX:	return sizeof (template_parm_index);
    case DEFAULT_ARG:		return sizeof (struct tree_default_arg);
    case OVERLOAD:		return sizeof (struct tree_overload);
    case STATIC_ASSERT:         return sizeof (struct tree_static_assert);
    case TYPE_ARGUMENT_PACK:
    case TYPE_PACK_EXPANSION:
      return sizeof (struct tree_common);

    case NONTYPE_ARGUMENT_PACK:
    case EXPR_PACK_EXPANSION:
      return sizeof (struct tree_exp);

    case ARGUMENT_PACK_SELECT:
      return sizeof (struct tree_argument_pack_select);

    case TRAIT_EXPR:
      return sizeof (struct tree_trait_expr);

    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_PTR_TO_MEMBER_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;
}

/* Construct a C++-aware pretty-printer for CONTEXT.  It is assumed
   that CONTEXT->printer is an already constructed basic pretty_printer.  */
void
cxx_initialize_diagnostics (diagnostic_context *context)
{
  pretty_printer *base = context->printer;
  cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
  memcpy (pp_base (pp), base, sizeof (pretty_printer));
  pp_cxx_pretty_printer_init (pp);
  context->printer = (pretty_printer *) pp;

  /* It is safe to free this object because it was previously malloc()'d.  */
  free (base);
}

/* 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);
}

/* Return true if DECL is explicit member function.  */

bool
cp_function_decl_explicit_p (tree decl)
{
  return (decl
	  && FUNCTION_FIRST_USER_PARMTYPE (decl) != void_list_node
	  && DECL_NONCONVERTING_P (decl));
}

/* 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 ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
     htab_t 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_map *h, in;
  in.base.from = from;

  h = (struct tree_map *) htab_find_with_hash (shadowed_var_for_decl, &in,
					       htab_hash_pointer (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_map *h;
  void **loc;

  h = GGC_NEW (struct tree_map);
  h->hash = htab_hash_pointer (from);
  h->base.from = from;
  h->to = to;
  loc = htab_find_slot_with_hash (shadowed_var_for_decl, h, h->hash, INSERT);
  *(struct tree_map **) loc = h;
}

void
init_shadowed_var_for_decl (void)
{
  shadowed_var_for_decl = htab_create_ggc (512, tree_map_hash,
					   tree_map_eq, 0);
}


#include "gt-cp-cp-objcp-common.h"
Commit	Line	Data
11bb4b27	1	/* Some code common to C++ and ObjC++ front ends.
68599f33	2	Copyright (C) 2004, 2007, 2008, 2009 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"
	24	#include "tm.h"
	25	#include "tree.h"
	26	#include "cp-tree.h"
	27	#include "c-common.h"
	28	#include "toplev.h"
	29	#include "langhooks.h"
	30	#include "langhooks-def.h"
	31	#include "diagnostic.h"
	32	#include "debug.h"
	33	#include "cxx-pretty-print.h"
	34	#include "cp-objcp-common.h"
	35
	36	/* Special routine to get the alias set for C++. */
	37
4862826d	38	alias_set_type
11bb4b27 ZL	39	cxx_get_alias_set (tree t)
	40	{
	41	if (IS_FAKE_BASE_TYPE (t))
	42	/* The base variant of a type must be in the same alias set as the
	43	complete type. */
	44	return get_alias_set (TYPE_CONTEXT (t));
	45
	46	/* Punt on PMFs until we canonicalize functions properly. */
a489b1f0 RG	47	if (TYPE_PTRMEMFUNC_P (t)
	48	\|\| (POINTER_TYPE_P (t)
	49	&& TYPE_PTRMEMFUNC_P (TREE_TYPE (t))))
11bb4b27 ZL	50	return 0;
	51
	52	return c_common_get_alias_set (t);
	53	}
	54
	55	/* Called from check_global_declarations. */
	56
	57	bool
ac7d7749	58	cxx_warn_unused_global_decl (const_tree decl)
11bb4b27 ZL	59	{
	60	if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
	61	return false;
	62	if (DECL_IN_SYSTEM_HEADER (decl))
	63	return false;
	64
	65	/* Const variables take the place of #defines in C++. */
	66	if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
	67	return false;
	68
	69	return true;
	70	}
	71
3b426391	72	/* Langhook for expr_size: Tell the back end that the value of an expression
11bb4b27 ZL	73	of non-POD class type does not include any tail padding; a derived class
	74	might have allocated something there. */
	75
	76	tree
ac7d7749	77	cp_expr_size (const_tree exp)
11bb4b27	78	{
acb3f79a MM	79	tree type = TREE_TYPE (exp);
	80
	81	if (CLASS_TYPE_P (type))
11bb4b27	82	{
3b426391	83	/* The back end should not be interested in the size of an expression
11bb4b27 ZL	84	of a type with both of these set; all copies of such types must go
11bb4b27 ZL	85	through a constructor or assignment op. */
26979bc2 JH	86	if (!TYPE_HAS_COMPLEX_INIT_REF (type)
	87	\|\| !TYPE_HAS_COMPLEX_ASSIGN_REF (type)
	88	/* But storing a CONSTRUCTOR isn't a copy. */
	89	\|\| TREE_CODE (exp) == CONSTRUCTOR
	90	/* And, the gimplifier will sometimes make a copy of
	91	an aggregate. In particular, for a case like:
	92
	93	struct S { S(); };
	94	struct X { int a; S s; };
	95	X x = { 0 };
	96
	97	the gimplifier will create a temporary with
	98	static storage duration, perform static
	99	initialization of the temporary, and then copy
	100	the result. Since the "s" subobject is never
	101	constructed, this is a valid transformation. */
	102	\|\| CP_AGGREGATE_TYPE_P (type))
	103	/* This would be wrong for a type with virtual bases. */
2588c9e9	104	return (is_really_empty_class (type)
26979bc2 JH	105	? size_zero_node
	106	: CLASSTYPE_SIZE_UNIT (type));
	107	else
	108	return NULL_TREE;
11bb4b27 ZL	109	}
	110	else
	111	/* Use the default code. */
71c00b5c	112	return tree_expr_size (exp);
11bb4b27 ZL	113	}
	114
	115	/* Langhook for tree_size: determine size of our 'x' and 'c' nodes. */
	116	size_t
	117	cp_tree_size (enum tree_code code)
	118	{
	119	switch (code)
	120	{
0cbd7506	121	case PTRMEM_CST: return sizeof (struct ptrmem_cst);
11bb4b27	122	case BASELINK: return sizeof (struct tree_baselink);
0cbd7506	123	case TEMPLATE_PARM_INDEX: return sizeof (template_parm_index);
11bb4b27 ZL	124	case DEFAULT_ARG: return sizeof (struct tree_default_arg);
11bb4b27 ZL	125	case OVERLOAD: return sizeof (struct tree_overload);
55a3debe	126	case STATIC_ASSERT: return sizeof (struct tree_static_assert);
5d80a306 DG	127	case TYPE_ARGUMENT_PACK:
	128	case TYPE_PACK_EXPANSION:
	129	return sizeof (struct tree_common);
	130
	131	case NONTYPE_ARGUMENT_PACK:
	132	case EXPR_PACK_EXPANSION:
	133	return sizeof (struct tree_exp);
	134
	135	case ARGUMENT_PACK_SELECT:
	136	return sizeof (struct tree_argument_pack_select);
	137
cb68ec50 PC	138	case TRAIT_EXPR:
	139	return sizeof (struct tree_trait_expr);
	140
11bb4b27 ZL	141	default:
	142	gcc_unreachable ();
	143	}
	144	/* NOTREACHED */
	145	}
	146
	147	/* Returns true if T is a variably modified type, in the sense of C99.
	148	FN is as passed to variably_modified_p.
	149	This routine needs only check cases that cannot be handled by the
	150	language-independent logic in tree.c. */
	151
	152	bool
	153	cp_var_mod_type_p (tree type, tree fn)
	154	{
	155	/* If TYPE is a pointer-to-member, it is variably modified if either
	156	the class or the member are variably modified. */
	157	if (TYPE_PTR_TO_MEMBER_P (type))
	158	return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn)
	159	\|\| variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type),
	160	fn));
	161
	162	/* All other types are not variably modified. */
	163	return false;
	164	}
	165
	166	/* Construct a C++-aware pretty-printer for CONTEXT. It is assumed
	167	that CONTEXT->printer is an already constructed basic pretty_printer. */
	168	void
	169	cxx_initialize_diagnostics (diagnostic_context *context)
	170	{
	171	pretty_printer *base = context->printer;
0ac1b889	172	cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
11bb4b27 ZL	173	memcpy (pp_base (pp), base, sizeof (pretty_printer));
	174	pp_cxx_pretty_printer_init (pp);
	175	context->printer = (pretty_printer *) pp;
	176
	177	/* It is safe to free this object because it was previously malloc()'d. */
	178	free (base);
	179	}
	180
65958285 ZL	181	/* This compares two types for equivalence ("compatible" in C-based languages).
	182	This routine should only return 1 if it is sure. It should not be used
	183	in contexts where erroneously returning 0 causes problems. */
	184
	185	int
	186	cxx_types_compatible_p (tree x, tree y)
	187	{
cf7bc668	188	return same_type_ignoring_top_level_qualifiers_p (x, y);
65958285 ZL	189	}
65958285 ZL	190
68599f33 DS	191	/* Return true if DECL is explicit member function. */
	192
	193	bool
	194	cp_function_decl_explicit_p (tree decl)
	195	{
	196	return (decl
	197	&& FUNCTION_FIRST_USER_PARMTYPE (decl) != void_list_node
	198	&& DECL_NONCONVERTING_P (decl));
	199	}
	200
11bb4b27 ZL	201	/* Stubs to keep c-opts.c happy. */
	202	void
	203	push_file_scope (void)
	204	{
	205	}
	206
	207	void
	208	pop_file_scope (void)
	209	{
	210	}
	211
	212	/* c-pragma.c needs to query whether a decl has extern "C" linkage. */
	213	bool
58f9752a	214	has_c_linkage (const_tree decl)
11bb4b27 ZL	215	{
	216	return DECL_EXTERN_C_P (decl);
	217	}
3ed8593d	218
3db45ab5	219	static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
3ed8593d AP	220	htab_t shadowed_var_for_decl;
	221
	222	/* Lookup a shadowed var for FROM, and return it if we find one. */
	223
3db45ab5	224	tree
3ed8593d AP	225	decl_shadowed_for_var_lookup (tree from)
	226	{
	227	struct tree_map *h, in;
fc8600f9	228	in.base.from = from;
3ed8593d	229
3db45ab5 MS	230	h = (struct tree_map *) htab_find_with_hash (shadowed_var_for_decl, &in,
3db45ab5 MS	231	htab_hash_pointer (from));
3ed8593d AP	232	if (h)
	233	return h->to;
	234	return NULL_TREE;
	235	}
	236
	237	/* Insert a mapping FROM->TO in the shadowed var hashtable. */
	238
	239	void
	240	decl_shadowed_for_var_insert (tree from, tree to)
	241	{
	242	struct tree_map *h;
	243	void **loc;
	244
0ac1b889	245	h = GGC_NEW (struct tree_map);
3ed8593d	246	h->hash = htab_hash_pointer (from);
fc8600f9	247	h->base.from = from;
3ed8593d AP	248	h->to = to;
	249	loc = htab_find_slot_with_hash (shadowed_var_for_decl, h, h->hash, INSERT);
	250	(struct tree_map *) loc = h;
	251	}
	252
	253	void
	254	init_shadowed_var_for_decl (void)
	255	{
	256	shadowed_var_for_decl = htab_create_ggc (512, tree_map_hash,
	257	tree_map_eq, 0);
	258	}
	259
	260
	261	#include "gt-cp-cp-objcp-common.h"