1 /* Perform optimizations on tree structure.
2 Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
3 Written by Mark Michell (mark@codesourcery.com).
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
27 #include "insn-config.h"
29 #include "integrate.h"
36 #include "tree-inline.h"
40 static tree calls_setjmp_r
PARAMS ((tree
*, int *, void *));
41 static void update_cloned_parm
PARAMS ((tree
, tree
));
42 static void dump_function
PARAMS ((enum tree_dump_index
, tree
));
44 /* Optimize the body of FN. */
47 optimize_function (fn
)
50 dump_function (TDI_original
, fn
);
52 /* While in this function, we may choose to go off and compile
53 another function. For example, we might instantiate a function
54 in the hopes of inlining it. Normally, that wouldn't trigger any
55 actual RTL code-generation -- but it will if the template is
56 actually needed. (For example, if it's address is taken, or if
57 some other function already refers to the template.) If
58 code-generation occurs, then garbage collection will occur, so we
59 must protect ourselves, just as we do while building up the body
64 /* We do not inline thunks, as (a) the backend tries to optimize
65 the call to the thunkee, (b) tree based inlining breaks that
66 optimization, (c) virtual functions are rarely inlineable,
67 and (d) ASM_OUTPUT_MI_THUNK is there to DTRT anyway. */
68 && !DECL_THUNK_P (fn
))
70 optimize_inline_calls (fn
);
72 dump_function (TDI_inlined
, fn
);
75 /* Undo the call to ggc_push_context above. */
78 dump_function (TDI_optimized
, fn
);
81 /* Called from calls_setjmp_p via walk_tree. */
84 calls_setjmp_r (tp
, walk_subtrees
, data
)
86 int *walk_subtrees ATTRIBUTE_UNUSED
;
87 void *data ATTRIBUTE_UNUSED
;
89 /* We're only interested in FUNCTION_DECLS. */
90 if (TREE_CODE (*tp
) != FUNCTION_DECL
)
93 return setjmp_call_p (*tp
) ? *tp
: NULL_TREE
;
96 /* Returns non-zero if FN calls `setjmp' or some other function that
97 can return more than once. This function is conservative; it may
98 occasionally return a non-zero value even when FN does not actually
105 return walk_tree_without_duplicates (&DECL_SAVED_TREE (fn
),
110 /* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
111 or destructor. Update it to ensure that the source-position for
112 the cloned parameter matches that for the original, and that the
113 debugging generation code will be able to find the original PARM. */
116 update_cloned_parm (parm
, cloned_parm
)
120 DECL_ABSTRACT_ORIGIN (cloned_parm
) = parm
;
122 /* We may have taken its address. */
123 TREE_ADDRESSABLE (cloned_parm
) = TREE_ADDRESSABLE (parm
);
125 /* The definition might have different constness. */
126 TREE_READONLY (cloned_parm
) = TREE_READONLY (parm
);
128 TREE_USED (cloned_parm
) = TREE_USED (parm
);
130 /* The name may have changed from the declaration. */
131 DECL_NAME (cloned_parm
) = DECL_NAME (parm
);
132 DECL_SOURCE_FILE (cloned_parm
) = DECL_SOURCE_FILE (parm
);
133 DECL_SOURCE_LINE (cloned_parm
) = DECL_SOURCE_LINE (parm
);
136 /* FN is a function that has a complete body. Clone the body as
137 necessary. Returns non-zero if there's no longer any need to
138 process the main body. */
141 maybe_clone_body (fn
)
147 /* We only clone constructors and destructors. */
148 if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
)
149 && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
))
152 /* Emit the DWARF1 abstract instance. */
153 (*debug_hooks
->deferred_inline_function
) (fn
);
155 /* We know that any clones immediately follow FN in the TYPE_METHODS
157 for (clone
= TREE_CHAIN (fn
);
158 clone
&& DECL_CLONED_FUNCTION_P (clone
);
159 clone
= TREE_CHAIN (clone
), first
= 0)
166 /* Update CLONE's source position information to match FN's. */
167 DECL_SOURCE_FILE (clone
) = DECL_SOURCE_FILE (fn
);
168 DECL_SOURCE_LINE (clone
) = DECL_SOURCE_LINE (fn
);
169 DECL_INLINE (clone
) = DECL_INLINE (fn
);
170 DECL_DECLARED_INLINE_P (clone
) = DECL_DECLARED_INLINE_P (fn
);
171 DECL_COMDAT (clone
) = DECL_COMDAT (fn
);
172 DECL_WEAK (clone
) = DECL_WEAK (fn
);
173 DECL_ONE_ONLY (clone
) = DECL_ONE_ONLY (fn
);
174 DECL_SECTION_NAME (clone
) = DECL_SECTION_NAME (fn
);
175 DECL_USE_TEMPLATE (clone
) = DECL_USE_TEMPLATE (fn
);
176 DECL_EXTERNAL (clone
) = DECL_EXTERNAL (fn
);
177 DECL_INTERFACE_KNOWN (clone
) = DECL_INTERFACE_KNOWN (fn
);
178 DECL_NOT_REALLY_EXTERN (clone
) = DECL_NOT_REALLY_EXTERN (fn
);
179 TREE_PUBLIC (clone
) = TREE_PUBLIC (fn
);
181 /* Adjust the parameter names and locations. */
182 parm
= DECL_ARGUMENTS (fn
);
183 clone_parm
= DECL_ARGUMENTS (clone
);
184 /* Update the `this' parameter, which is always first.
185 Sometimes, we end update the `this' parameter twice because
186 we process it again in the loop below. That is harmless. */
187 update_cloned_parm (parm
, clone_parm
);
188 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
189 parm
= TREE_CHAIN (parm
);
190 if (DECL_HAS_VTT_PARM_P (fn
))
191 parm
= TREE_CHAIN (parm
);
192 if (DECL_HAS_VTT_PARM_P (clone
))
193 clone_parm
= TREE_CHAIN (clone_parm
);
195 parm
= TREE_CHAIN (parm
), clone_parm
= TREE_CHAIN (clone_parm
))
197 /* Update this paramter. */
198 update_cloned_parm (parm
, clone_parm
);
199 /* We should only give unused information for one clone. */
201 TREE_USED (clone_parm
) = 1;
204 /* Start processing the function. */
205 push_to_top_level ();
206 start_function (NULL_TREE
, clone
, NULL_TREE
, SF_PRE_PARSED
);
208 /* Remap the parameters. */
209 decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
211 parm
= DECL_ARGUMENTS (fn
),
212 clone_parm
= DECL_ARGUMENTS (clone
);
215 parm
= TREE_CHAIN (parm
))
217 /* Map the in-charge parameter to an appropriate constant. */
218 if (DECL_HAS_IN_CHARGE_PARM_P (fn
) && parmno
== 1)
221 in_charge
= in_charge_arg_for_name (DECL_NAME (clone
));
222 splay_tree_insert (decl_map
,
223 (splay_tree_key
) parm
,
224 (splay_tree_value
) in_charge
);
226 else if (DECL_ARTIFICIAL (parm
)
227 && DECL_NAME (parm
) == vtt_parm_identifier
)
229 /* For a subobject constructor or destructor, the next
230 argument is the VTT parameter. Remap the VTT_PARM
231 from the CLONE to this parameter. */
232 if (DECL_HAS_VTT_PARM_P (clone
))
234 DECL_ABSTRACT_ORIGIN (clone_parm
) = parm
;
235 splay_tree_insert (decl_map
,
236 (splay_tree_key
) parm
,
237 (splay_tree_value
) clone_parm
);
238 clone_parm
= TREE_CHAIN (clone_parm
);
240 /* Otherwise, map the VTT parameter to `NULL'. */
243 splay_tree_insert (decl_map
,
244 (splay_tree_key
) parm
,
245 (splay_tree_value
) null_pointer_node
);
248 /* Map other parameters to their equivalents in the cloned
252 splay_tree_insert (decl_map
,
253 (splay_tree_key
) parm
,
254 (splay_tree_value
) clone_parm
);
255 clone_parm
= TREE_CHAIN (clone_parm
);
259 /* Clone the body. */
260 clone_body (clone
, fn
, decl_map
);
262 /* There are as many statements in the clone as in the
264 DECL_NUM_STMTS (clone
) = DECL_NUM_STMTS (fn
);
267 splay_tree_delete (decl_map
);
269 /* Now, expand this function into RTL, if appropriate. */
271 BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone
)) = DECL_INITIAL (fn
);
273 pop_from_top_level ();
276 /* We don't need to process the original function any further. */
280 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
283 dump_function (phase
, fn
)
284 enum tree_dump_index phase
;
290 stream
= dump_begin (phase
, &flags
);
293 fprintf (stream
, "\n;; Function %s",
294 decl_as_string (fn
, TFF_DECL_SPECIFIERS
));
295 fprintf (stream
, " (%s)\n",
296 decl_as_string (DECL_ASSEMBLER_NAME (fn
), 0));
297 fprintf (stream
, ";; enabled by -%s\n", dump_flag_name (phase
));
298 fprintf (stream
, "\n");
300 dump_node (fn
, TDF_SLIM
| flags
, stream
);
301 dump_end (phase
, stream
);