[thirdparty/gcc.git] / gcc / cp / optimize.c

/* Perform optimizations on tree structure.
   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005
   Free Software Foundation, Inc.
   Written by Mark Michell (mark@codesourcery.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 2, 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 COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "cp-tree.h"
#include "rtl.h"
#include "insn-config.h"
#include "input.h"
#include "integrate.h"
#include "toplev.h"
#include "varray.h"
#include "params.h"
#include "hashtab.h"
#include "target.h"
#include "debug.h"
#include "tree-inline.h"
#include "flags.h"
#include "langhooks.h"
#include "diagnostic.h"
#include "tree-dump.h"
#include "tree-gimple.h"

/* Prototypes.  */

static void update_cloned_parm (tree, tree);

/* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
   or destructor.  Update it to ensure that the source-position for
   the cloned parameter matches that for the original, and that the
   debugging generation code will be able to find the original PARM.  */

static void
update_cloned_parm (tree parm, tree cloned_parm)
{
  DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;

  /* We may have taken its address.  */
  TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);

  /* The definition might have different constness.  */
  TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
  
  TREE_USED (cloned_parm) = TREE_USED (parm);
  
  /* The name may have changed from the declaration.  */
  DECL_NAME (cloned_parm) = DECL_NAME (parm);
  DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
  TREE_TYPE (cloned_parm) = TREE_TYPE (parm);
}

/* FN is a function that has a complete body.  Clone the body as
   necessary.  Returns nonzero if there's no longer any need to
   process the main body.  */

bool
maybe_clone_body (tree fn)
{
  tree clone;

  /* We only clone constructors and destructors.  */
  if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
      && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
    return 0;

  /* Emit the DWARF1 abstract instance.  */
  (*debug_hooks->deferred_inline_function) (fn);

  /* We know that any clones immediately follow FN in the TYPE_METHODS
     list.  */
  push_to_top_level ();
  FOR_EACH_CLONE (clone, fn)
    {
      tree parm;
      tree clone_parm;
      int parmno;
      splay_tree decl_map;

      /* Update CLONE's source position information to match FN's.  */
      DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
      DECL_INLINE (clone) = DECL_INLINE (fn);
      DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
      DECL_COMDAT (clone) = DECL_COMDAT (fn);
      DECL_WEAK (clone) = DECL_WEAK (fn);
      DECL_ONE_ONLY (clone) = DECL_ONE_ONLY (fn);
      DECL_SECTION_NAME (clone) = DECL_SECTION_NAME (fn);
      DECL_USE_TEMPLATE (clone) = DECL_USE_TEMPLATE (fn);
      DECL_EXTERNAL (clone) = DECL_EXTERNAL (fn);
      DECL_INTERFACE_KNOWN (clone) = DECL_INTERFACE_KNOWN (fn);
      DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
      TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
      DECL_VISIBILITY (clone) = DECL_VISIBILITY (fn);
      DECL_VISIBILITY_SPECIFIED (clone) = DECL_VISIBILITY_SPECIFIED (fn);

      /* Adjust the parameter names and locations.  */
      parm = DECL_ARGUMENTS (fn);
      clone_parm = DECL_ARGUMENTS (clone);
      /* Update the `this' parameter, which is always first.  */
      update_cloned_parm (parm, clone_parm);
      parm = TREE_CHAIN (parm);
      clone_parm = TREE_CHAIN (clone_parm);
      if (DECL_HAS_IN_CHARGE_PARM_P (fn))
	parm = TREE_CHAIN (parm);
      if (DECL_HAS_VTT_PARM_P (fn))
	parm = TREE_CHAIN (parm);
      if (DECL_HAS_VTT_PARM_P (clone))
	clone_parm = TREE_CHAIN (clone_parm);
      for (; parm;
	   parm = TREE_CHAIN (parm), clone_parm = TREE_CHAIN (clone_parm))
	/* Update this parameter.  */
	update_cloned_parm (parm, clone_parm);

      /* Start processing the function.  */
      start_preparsed_function (clone, NULL_TREE, SF_PRE_PARSED);

      /* Remap the parameters.  */
      decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
      for (parmno = 0,
	     parm = DECL_ARGUMENTS (fn),
	     clone_parm = DECL_ARGUMENTS (clone);
	   parm;
	   ++parmno,
	     parm = TREE_CHAIN (parm))
	{
	  /* Map the in-charge parameter to an appropriate constant.  */
	  if (DECL_HAS_IN_CHARGE_PARM_P (fn) && parmno == 1)
	    {
	      tree in_charge;
	      in_charge = in_charge_arg_for_name (DECL_NAME (clone));
	      splay_tree_insert (decl_map,
				 (splay_tree_key) parm,
				 (splay_tree_value) in_charge);
	    }
	  else if (DECL_ARTIFICIAL (parm)
		   && DECL_NAME (parm) == vtt_parm_identifier)
	    {
	      /* For a subobject constructor or destructor, the next
		 argument is the VTT parameter.  Remap the VTT_PARM
		 from the CLONE to this parameter.  */
	      if (DECL_HAS_VTT_PARM_P (clone))
		{
		  DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
		  splay_tree_insert (decl_map,
				     (splay_tree_key) parm,
				     (splay_tree_value) clone_parm);
		  clone_parm = TREE_CHAIN (clone_parm);
		}
	      /* Otherwise, map the VTT parameter to `NULL'.  */
	      else
		{
		  splay_tree_insert (decl_map,
				     (splay_tree_key) parm,
				     (splay_tree_value) null_pointer_node);
		}
	    }
	  /* Map other parameters to their equivalents in the cloned
	     function.  */
	  else
	    {
	      splay_tree_insert (decl_map,
				 (splay_tree_key) parm,
				 (splay_tree_value) clone_parm);
	      clone_parm = TREE_CHAIN (clone_parm);
	    }
	}

      if (targetm.cxx.cdtor_returns_this ())
	{
	  parm = DECL_RESULT (fn);
	  clone_parm = DECL_RESULT (clone);
	  splay_tree_insert (decl_map, (splay_tree_key) parm,
			     (splay_tree_value) clone_parm);
	}
      /* Clone the body.  */
      clone_body (clone, fn, decl_map);

      /* Clean up.  */
      splay_tree_delete (decl_map);

      /* The clone can throw iff the original function can throw.  */
      cp_function_chain->can_throw = !TREE_NOTHROW (fn);

      /* Now, expand this function into RTL, if appropriate.  */
      finish_function (0);
      BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
      expand_or_defer_fn (clone);
    }
  pop_from_top_level ();

  /* We don't need to process the original function any further.  */
  return 1;
}
Commit	Line	Data
46e8c075	1	/* Perform optimizations on tree structure.
2a8a8f8f	2	Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005
3c2426b9	3	Free Software Foundation, Inc.
46e8c075 MM	4	Written by Mark Michell (mark@codesourcery.com).
46e8c075 MM	5
f5adbb8d	6	This file is part of GCC.
46e8c075	7
f5adbb8d	8	GCC is free software; you can redistribute it and/or modify it
06ceef4e RK	9	under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2, or (at your option)
	11	any later version.
	12
f5adbb8d	13	GCC is distributed in the hope that it will be useful, but
06ceef4e RK	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	General Public License for more details.
9c96f3f8	17
06ceef4e	18	You should have received a copy of the GNU General Public License
f5adbb8d	19	along with GCC; see the file COPYING. If not, write to the Free
06ceef4e RK	20	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
06ceef4e RK	21	02111-1307, USA. */
46e8c075 MM	22
	23	#include "config.h"
	24	#include "system.h"
4977bab6 ZW	25	#include "coretypes.h"
4977bab6 ZW	26	#include "tm.h"
46e8c075 MM	27	#include "tree.h"
	28	#include "cp-tree.h"
	29	#include "rtl.h"
	30	#include "insn-config.h"
574a0ef5	31	#include "input.h"
46e8c075	32	#include "integrate.h"
9c96f3f8	33	#include "toplev.h"
46e8c075	34	#include "varray.h"
b850de4f	35	#include "params.h"
11fe225a	36	#include "hashtab.h"
44d10c10	37	#include "target.h"
2b85879e	38	#include "debug.h"
25af8512	39	#include "tree-inline.h"
6de9cd9a DN	40	#include "flags.h"
	41	#include "langhooks.h"
	42	#include "diagnostic.h"
	43	#include "tree-dump.h"
eadf906f	44	#include "tree-gimple.h"
46e8c075	45
46e8c075 MM	46	/* Prototypes. */
46e8c075 MM	47
4977bab6	48	static void update_cloned_parm (tree, tree);
95fabfd3	49
d60e5448 MM	50	/* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
	51	or destructor. Update it to ensure that the source-position for
	52	the cloned parameter matches that for the original, and that the
	53	debugging generation code will be able to find the original PARM. */
	54
	55	static void
4977bab6	56	update_cloned_parm (tree parm, tree cloned_parm)
d60e5448 MM	57	{
d60e5448 MM	58	DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
d30a825a	59
c6002625	60	/* We may have taken its address. */
d30a825a NS	61	TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
d30a825a NS	62
c6002625	63	/* The definition might have different constness. */
d30a825a NS	64	TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
	65
	66	TREE_USED (cloned_parm) = TREE_USED (parm);
d60e5448	67
c6002625	68	/* The name may have changed from the declaration. */
d60e5448	69	DECL_NAME (cloned_parm) = DECL_NAME (parm);
f31686a3	70	DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
e777303f	71	TREE_TYPE (cloned_parm) = TREE_TYPE (parm);
d60e5448 MM	72	}
d60e5448 MM	73
db9b2174	74	/* FN is a function that has a complete body. Clone the body as
838dfd8a	75	necessary. Returns nonzero if there's no longer any need to
db9b2174 MM	76	process the main body. */
db9b2174 MM	77
4977bab6 ZW	78	bool
4977bab6 ZW	79	maybe_clone_body (tree fn)
db9b2174	80	{
db9b2174 MM	81	tree clone;
db9b2174 MM	82
db9b2174 MM	83	/* We only clone constructors and destructors. */
	84	if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
	85	&& !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
	86	return 0;
	87
5daf7c0a	88	/* Emit the DWARF1 abstract instance. */
2b85879e	89	(*debug_hooks->deferred_inline_function) (fn);
5daf7c0a	90
db9b2174 MM	91	/* We know that any clones immediately follow FN in the TYPE_METHODS
db9b2174 MM	92	list. */
f44b0c8e	93	push_to_top_level ();
4684cd27	94	FOR_EACH_CLONE (clone, fn)
db9b2174 MM	95	{
	96	tree parm;
	97	tree clone_parm;
	98	int parmno;
25af8512	99	splay_tree decl_map;
db9b2174 MM	100
db9b2174 MM	101	/* Update CLONE's source position information to match FN's. */
f31686a3	102	DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
99389463	103	DECL_INLINE (clone) = DECL_INLINE (fn);
79065db2	104	DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
3ec6bad3 MM	105	DECL_COMDAT (clone) = DECL_COMDAT (fn);
	106	DECL_WEAK (clone) = DECL_WEAK (fn);
	107	DECL_ONE_ONLY (clone) = DECL_ONE_ONLY (fn);
	108	DECL_SECTION_NAME (clone) = DECL_SECTION_NAME (fn);
459c43ad MM	109	DECL_USE_TEMPLATE (clone) = DECL_USE_TEMPLATE (fn);
	110	DECL_EXTERNAL (clone) = DECL_EXTERNAL (fn);
	111	DECL_INTERFACE_KNOWN (clone) = DECL_INTERFACE_KNOWN (fn);
	112	DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
b96ada87	113	TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
968b41a1	114	DECL_VISIBILITY (clone) = DECL_VISIBILITY (fn);
d7afec4b	115	DECL_VISIBILITY_SPECIFIED (clone) = DECL_VISIBILITY_SPECIFIED (fn);
db9b2174	116
c6002625	117	/* Adjust the parameter names and locations. */
02a1a68c NS	118	parm = DECL_ARGUMENTS (fn);
02a1a68c NS	119	clone_parm = DECL_ARGUMENTS (clone);
4a90862e	120	/* Update the `this' parameter, which is always first. */
d60e5448	121	update_cloned_parm (parm, clone_parm);
4a90862e JM	122	parm = TREE_CHAIN (parm);
4a90862e JM	123	clone_parm = TREE_CHAIN (clone_parm);
02a1a68c NS	124	if (DECL_HAS_IN_CHARGE_PARM_P (fn))
	125	parm = TREE_CHAIN (parm);
	126	if (DECL_HAS_VTT_PARM_P (fn))
	127	parm = TREE_CHAIN (parm);
	128	if (DECL_HAS_VTT_PARM_P (clone))
	129	clone_parm = TREE_CHAIN (clone_parm);
	130	for (; parm;
	131	parm = TREE_CHAIN (parm), clone_parm = TREE_CHAIN (clone_parm))
85b22f78 NS	132	/* Update this parameter. */
85b22f78 NS	133	update_cloned_parm (parm, clone_parm);
02a1a68c	134
db9b2174	135	/* Start processing the function. */
058b15c1	136	start_preparsed_function (clone, NULL_TREE, SF_PRE_PARSED);
db9b2174	137
db9b2174	138	/* Remap the parameters. */
25af8512	139	decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
db9b2174 MM	140	for (parmno = 0,
	141	parm = DECL_ARGUMENTS (fn),
	142	clone_parm = DECL_ARGUMENTS (clone);
	143	parm;
	144	++parmno,
	145	parm = TREE_CHAIN (parm))
	146	{
	147	/* Map the in-charge parameter to an appropriate constant. */
	148	if (DECL_HAS_IN_CHARGE_PARM_P (fn) && parmno == 1)
	149	{
	150	tree in_charge;
298d6f60	151	in_charge = in_charge_arg_for_name (DECL_NAME (clone));
25af8512	152	splay_tree_insert (decl_map,
db9b2174	153	(splay_tree_key) parm,
3ec6bad3	154	(splay_tree_value) in_charge);
e0fff4b3 JM	155	}
	156	else if (DECL_ARTIFICIAL (parm)
	157	&& DECL_NAME (parm) == vtt_parm_identifier)
	158	{
3ec6bad3 MM	159	/* For a subobject constructor or destructor, the next
	160	argument is the VTT parameter. Remap the VTT_PARM
	161	from the CLONE to this parameter. */
e0fff4b3	162	if (DECL_HAS_VTT_PARM_P (clone))
3ec6bad3	163	{
5daf7c0a	164	DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
25af8512	165	splay_tree_insert (decl_map,
e0fff4b3	166	(splay_tree_key) parm,
3ec6bad3	167	(splay_tree_value) clone_parm);
3ec6bad3 MM	168	clone_parm = TREE_CHAIN (clone_parm);
	169	}
	170	/* Otherwise, map the VTT parameter to `NULL'. */
e0fff4b3	171	else
3ec6bad3	172	{
25af8512	173	splay_tree_insert (decl_map,
e0fff4b3	174	(splay_tree_key) parm,
3ec6bad3	175	(splay_tree_value) null_pointer_node);
3ec6bad3	176	}
db9b2174 MM	177	}
	178	/* Map other parameters to their equivalents in the cloned
	179	function. */
	180	else
	181	{
25af8512	182	splay_tree_insert (decl_map,
db9b2174 MM	183	(splay_tree_key) parm,
	184	(splay_tree_value) clone_parm);
	185	clone_parm = TREE_CHAIN (clone_parm);
	186	}
	187	}
	188
44d10c10 PB	189	if (targetm.cxx.cdtor_returns_this ())
	190	{
	191	parm = DECL_RESULT (fn);
	192	clone_parm = DECL_RESULT (clone);
	193	splay_tree_insert (decl_map, (splay_tree_key) parm,
	194	(splay_tree_value) clone_parm);
	195	}
25af8512 AO	196	/* Clone the body. */
25af8512 AO	197	clone_body (clone, fn, decl_map);
db9b2174 MM	198
db9b2174 MM	199	/* Clean up. */
25af8512	200	splay_tree_delete (decl_map);
db9b2174	201
b2dd096b MM	202	/* The clone can throw iff the original function can throw. */
	203	cp_function_chain->can_throw = !TREE_NOTHROW (fn);
	204
db9b2174	205	/* Now, expand this function into RTL, if appropriate. */
5daf7c0a JM	206	finish_function (0);
5daf7c0a JM	207	BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
8cd2462c	208	expand_or_defer_fn (clone);
db9b2174	209	}
f44b0c8e	210	pop_from_top_level ();
9c96f3f8	211
db9b2174 MM	212	/* We don't need to process the original function any further. */
	213	return 1;
	214	}