1 /* Perform optimizations on tree structure.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Written by Mark Michell (mark@codesourcery.com).
6 This file is part of GCC.
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 3, or (at your option)
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.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "insn-config.h"
31 #include "integrate.h"
38 #include "tree-inline.h"
40 #include "langhooks.h"
41 #include "diagnostic.h"
42 #include "tree-dump.h"
44 #include "tree-iterator.h"
48 static void update_cloned_parm (tree
, tree
, bool);
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. */
56 update_cloned_parm (tree parm
, tree cloned_parm
, bool first
)
58 DECL_ABSTRACT_ORIGIN (cloned_parm
) = parm
;
60 /* We may have taken its address. */
61 TREE_ADDRESSABLE (cloned_parm
) = TREE_ADDRESSABLE (parm
);
63 /* The definition might have different constness. */
64 TREE_READONLY (cloned_parm
) = TREE_READONLY (parm
);
66 TREE_USED (cloned_parm
) = !first
|| TREE_USED (parm
);
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
);
73 DECL_GIMPLE_REG_P (cloned_parm
) = DECL_GIMPLE_REG_P (parm
);
77 /* FN is a function in High GIMPLE form that has a complete body and no
78 CFG. CLONE is a function whose body is to be set to a copy of FN,
79 mapping argument declarations according to the ARG_MAP splay_tree. */
82 clone_body (tree clone
, tree fn
, void *arg_map
)
87 /* Clone the body, as if we were making an inline call. But, remap
88 the parameters in the callee to the parameters of caller. */
89 memset (&id
, 0, sizeof (id
));
92 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
93 id
.decl_map
= (struct pointer_map_t
*) arg_map
;
95 id
.copy_decl
= copy_decl_no_change
;
96 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
97 id
.transform_new_cfg
= true;
98 id
.transform_return_to_modify
= false;
99 id
.transform_lang_insert_block
= NULL
;
101 /* We're not inside any EH region. */
104 stmts
= DECL_SAVED_TREE (fn
);
105 walk_tree (&stmts
, copy_tree_body_r
, &id
, NULL
);
106 append_to_statement_list_force (stmts
, &DECL_SAVED_TREE (clone
));
109 /* DELETE_DTOR is a delete destructor whose body will be built.
110 COMPLETE_DTOR is the corresponding complete destructor. */
113 build_delete_destructor_body (tree delete_dtor
, tree complete_dtor
)
115 tree call_dtor
, call_delete
;
116 tree parm
= DECL_ARGUMENTS (delete_dtor
);
117 tree virtual_size
= cxx_sizeof (current_class_type
);
119 /* Call the corresponding complete destructor. */
120 gcc_assert (complete_dtor
);
121 call_dtor
= build_cxx_call (complete_dtor
, 1, &parm
);
122 add_stmt (call_dtor
);
124 add_stmt (build_stmt (0, LABEL_EXPR
, cdtor_label
));
126 /* Call the delete function. */
127 call_delete
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
130 /*placement=*/NULL_TREE
,
131 /*alloc_fn=*/NULL_TREE
);
132 add_stmt (call_delete
);
134 /* Return the address of the object. */
135 if (targetm
.cxx
.cdtor_returns_this ())
137 tree val
= DECL_ARGUMENTS (delete_dtor
);
138 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
139 DECL_RESULT (delete_dtor
), val
);
140 add_stmt (build_stmt (0, RETURN_EXPR
, val
));
144 /* FN is a function that has a complete body. Clone the body as
145 necessary. Returns nonzero if there's no longer any need to
146 process the main body. */
149 maybe_clone_body (tree fn
)
152 tree complete_dtor
= NULL_TREE
;
155 /* We only clone constructors and destructors. */
156 if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
)
157 && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
))
160 /* Emit the DWARF1 abstract instance. */
161 (*debug_hooks
->deferred_inline_function
) (fn
);
163 /* Look for the complete destructor which may be used to build the
164 delete destructor. */
165 FOR_EACH_CLONE (clone
, fn
)
166 if (DECL_NAME (clone
) == complete_dtor_identifier
)
168 complete_dtor
= clone
;
172 /* We know that any clones immediately follow FN in the TYPE_METHODS
174 push_to_top_level ();
175 FOR_EACH_CLONE (clone
, fn
)
180 struct pointer_map_t
*decl_map
;
182 /* Update CLONE's source position information to match FN's. */
183 DECL_SOURCE_LOCATION (clone
) = DECL_SOURCE_LOCATION (fn
);
184 DECL_DECLARED_INLINE_P (clone
) = DECL_DECLARED_INLINE_P (fn
);
185 DECL_COMDAT (clone
) = DECL_COMDAT (fn
);
186 DECL_WEAK (clone
) = DECL_WEAK (fn
);
188 /* We don't copy the comdat group from fn to clone because the assembler
189 name of fn was corrupted by write_mangled_name by adding *INTERNAL*
190 to it. By doing so, it also corrupted the comdat group. */
191 if (DECL_ONE_ONLY (fn
))
192 DECL_COMDAT_GROUP (clone
) = cxx_comdat_group (clone
);
193 DECL_SECTION_NAME (clone
) = DECL_SECTION_NAME (fn
);
194 DECL_USE_TEMPLATE (clone
) = DECL_USE_TEMPLATE (fn
);
195 DECL_EXTERNAL (clone
) = DECL_EXTERNAL (fn
);
196 DECL_INTERFACE_KNOWN (clone
) = DECL_INTERFACE_KNOWN (fn
);
197 DECL_NOT_REALLY_EXTERN (clone
) = DECL_NOT_REALLY_EXTERN (fn
);
198 TREE_PUBLIC (clone
) = TREE_PUBLIC (fn
);
199 DECL_VISIBILITY (clone
) = DECL_VISIBILITY (fn
);
200 DECL_VISIBILITY_SPECIFIED (clone
) = DECL_VISIBILITY_SPECIFIED (fn
);
201 DECL_DLLIMPORT_P (clone
) = DECL_DLLIMPORT_P (fn
);
203 /* Adjust the parameter names and locations. */
204 parm
= DECL_ARGUMENTS (fn
);
205 clone_parm
= DECL_ARGUMENTS (clone
);
206 /* Update the `this' parameter, which is always first. */
207 update_cloned_parm (parm
, clone_parm
, first
);
208 parm
= TREE_CHAIN (parm
);
209 clone_parm
= TREE_CHAIN (clone_parm
);
210 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
211 parm
= TREE_CHAIN (parm
);
212 if (DECL_HAS_VTT_PARM_P (fn
))
213 parm
= TREE_CHAIN (parm
);
214 if (DECL_HAS_VTT_PARM_P (clone
))
215 clone_parm
= TREE_CHAIN (clone_parm
);
217 parm
= TREE_CHAIN (parm
), clone_parm
= TREE_CHAIN (clone_parm
))
218 /* Update this parameter. */
219 update_cloned_parm (parm
, clone_parm
, first
);
221 /* Start processing the function. */
222 start_preparsed_function (clone
, NULL_TREE
, SF_PRE_PARSED
);
224 /* Build the delete destructor by calling complete destructor
225 and delete function. */
226 if (DECL_NAME (clone
) == deleting_dtor_identifier
)
227 build_delete_destructor_body (clone
, complete_dtor
);
230 /* Remap the parameters. */
231 decl_map
= pointer_map_create ();
233 parm
= DECL_ARGUMENTS (fn
),
234 clone_parm
= DECL_ARGUMENTS (clone
);
237 parm
= TREE_CHAIN (parm
))
239 /* Map the in-charge parameter to an appropriate constant. */
240 if (DECL_HAS_IN_CHARGE_PARM_P (fn
) && parmno
== 1)
243 in_charge
= in_charge_arg_for_name (DECL_NAME (clone
));
244 *pointer_map_insert (decl_map
, parm
) = in_charge
;
246 else if (DECL_ARTIFICIAL (parm
)
247 && DECL_NAME (parm
) == vtt_parm_identifier
)
249 /* For a subobject constructor or destructor, the next
250 argument is the VTT parameter. Remap the VTT_PARM
251 from the CLONE to this parameter. */
252 if (DECL_HAS_VTT_PARM_P (clone
))
254 DECL_ABSTRACT_ORIGIN (clone_parm
) = parm
;
255 *pointer_map_insert (decl_map
, parm
) = clone_parm
;
256 clone_parm
= TREE_CHAIN (clone_parm
);
258 /* Otherwise, map the VTT parameter to `NULL'. */
260 *pointer_map_insert (decl_map
, parm
)
261 = fold_convert (TREE_TYPE (parm
), null_pointer_node
);
263 /* Map other parameters to their equivalents in the cloned
267 *pointer_map_insert (decl_map
, parm
) = clone_parm
;
268 clone_parm
= TREE_CHAIN (clone_parm
);
272 if (targetm
.cxx
.cdtor_returns_this ())
274 parm
= DECL_RESULT (fn
);
275 clone_parm
= DECL_RESULT (clone
);
276 *pointer_map_insert (decl_map
, parm
) = clone_parm
;
279 /* Clone the body. */
280 clone_body (clone
, fn
, decl_map
);
283 pointer_map_destroy (decl_map
);
286 /* The clone can throw iff the original function can throw. */
287 cp_function_chain
->can_throw
= !TREE_NOTHROW (fn
);
289 /* Now, expand this function into RTL, if appropriate. */
291 BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone
)) = DECL_INITIAL (fn
);
292 expand_or_defer_fn (clone
);
295 pop_from_top_level ();
297 /* We don't need to process the original function any further. */