OSDN Git Service

bf9b22b63e915c22b537632dc67213a318b4d058
[pf3gnuchains/gcc-fork.git] / gcc / cp / optimize.c
1 /* Perform optimizations on tree structure.
2    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004
3    Free Software Foundation, Inc.
4    Written by Mark Michell (mark@codesourcery.com).
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it
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
13 GCC is distributed in the hope that it will be useful, but
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.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "tree.h"
28 #include "cp-tree.h"
29 #include "rtl.h"
30 #include "insn-config.h"
31 #include "input.h"
32 #include "integrate.h"
33 #include "toplev.h"
34 #include "varray.h"
35 #include "params.h"
36 #include "hashtab.h"
37 #include "target.h"
38 #include "debug.h"
39 #include "tree-inline.h"
40 #include "flags.h"
41 #include "langhooks.h"
42 #include "diagnostic.h"
43 #include "tree-dump.h"
44 #include "tree-gimple.h"
45
46 /* Prototypes.  */
47
48 static void update_cloned_parm (tree, tree);
49
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
56 update_cloned_parm (tree parm, tree cloned_parm)
57 {
58   DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
59
60   /* We may have taken its address.  */
61   TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
62
63   /* The definition might have different constness.  */
64   TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
65   
66   TREE_USED (cloned_parm) = TREE_USED (parm);
67   
68   /* The name may have changed from the declaration.  */
69   DECL_NAME (cloned_parm) = DECL_NAME (parm);
70   DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
71   TREE_TYPE (cloned_parm) = TREE_TYPE (parm);
72 }
73
74 /* FN is a function that has a complete body.  Clone the body as
75    necessary.  Returns nonzero if there's no longer any need to
76    process the main body.  */
77
78 bool
79 maybe_clone_body (tree fn)
80 {
81   tree clone;
82
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
88   /* Emit the DWARF1 abstract instance.  */
89   (*debug_hooks->deferred_inline_function) (fn);
90
91   /* We know that any clones immediately follow FN in the TYPE_METHODS
92      list.  */
93   push_to_top_level ();
94   FOR_EACH_CLONE (clone, fn)
95     {
96       tree parm;
97       tree clone_parm;
98       int parmno;
99       splay_tree decl_map;
100
101       /* Update CLONE's source position information to match FN's.  */
102       DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
103       DECL_INLINE (clone) = DECL_INLINE (fn);
104       DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
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);
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);
113       TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
114       DECL_VISIBILITY (clone) = DECL_VISIBILITY (fn);
115       DECL_VISIBILITY_SPECIFIED (clone) = DECL_VISIBILITY_SPECIFIED (fn);
116
117       /* Adjust the parameter names and locations.  */
118       parm = DECL_ARGUMENTS (fn);
119       clone_parm = DECL_ARGUMENTS (clone);
120       /* Update the `this' parameter, which is always first.  */
121       update_cloned_parm (parm, clone_parm);
122       parm = TREE_CHAIN (parm);
123       clone_parm = TREE_CHAIN (clone_parm);
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))
132         /* Update this parameter.  */
133         update_cloned_parm (parm, clone_parm);
134
135       /* Start processing the function.  */
136       start_preparsed_function (clone, NULL_TREE, SF_PRE_PARSED);
137
138       /* Remap the parameters.  */
139       decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
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;
151               in_charge = in_charge_arg_for_name (DECL_NAME (clone));
152               splay_tree_insert (decl_map,
153                                  (splay_tree_key) parm,
154                                  (splay_tree_value) in_charge);
155             }
156           else if (DECL_ARTIFICIAL (parm)
157                    && DECL_NAME (parm) == vtt_parm_identifier)
158             {
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.  */
162               if (DECL_HAS_VTT_PARM_P (clone))
163                 {
164                   DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
165                   splay_tree_insert (decl_map,
166                                      (splay_tree_key) parm,
167                                      (splay_tree_value) clone_parm);
168                   clone_parm = TREE_CHAIN (clone_parm);
169                 }
170               /* Otherwise, map the VTT parameter to `NULL'.  */
171               else
172                 {
173                   splay_tree_insert (decl_map,
174                                      (splay_tree_key) parm,
175                                      (splay_tree_value) null_pointer_node);
176                 }
177             }
178           /* Map other parameters to their equivalents in the cloned
179              function.  */
180           else
181             {
182               splay_tree_insert (decl_map,
183                                  (splay_tree_key) parm,
184                                  (splay_tree_value) clone_parm);
185               clone_parm = TREE_CHAIN (clone_parm);
186             }
187         }
188
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         }
196       /* Clone the body.  */
197       clone_body (clone, fn, decl_map);
198
199       /* Clean up.  */
200       splay_tree_delete (decl_map);
201
202       /* The clone can throw iff the original function can throw.  */
203       cp_function_chain->can_throw = !TREE_NOTHROW (fn);
204
205       /* Now, expand this function into RTL, if appropriate.  */
206       finish_function (0);
207       BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
208       expand_or_defer_fn (clone);
209     }
210   pop_from_top_level ();
211
212   /* We don't need to process the original function any further.  */
213   return 1;
214 }