1 /* Perform optimizations on tree structure.
2 Copyright (C) 1998-2013 Free Software Foundation, Inc.
3 Written by Mark Michell (mark@codesourcery.com).
5 This file is part of GCC.
7 GCC 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 3, or (at your option)
12 GCC 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 GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
32 #include "tree-inline.h"
34 #include "langhooks.h"
35 #include "diagnostic-core.h"
38 #include "tree-iterator.h"
43 static void update_cloned_parm (tree
, tree
, bool);
45 /* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
46 or destructor. Update it to ensure that the source-position for
47 the cloned parameter matches that for the original, and that the
48 debugging generation code will be able to find the original PARM. */
51 update_cloned_parm (tree parm
, tree cloned_parm
, bool first
)
53 DECL_ABSTRACT_ORIGIN (cloned_parm
) = parm
;
55 /* We may have taken its address. */
56 TREE_ADDRESSABLE (cloned_parm
) = TREE_ADDRESSABLE (parm
);
58 /* The definition might have different constness. */
59 TREE_READONLY (cloned_parm
) = TREE_READONLY (parm
);
61 TREE_USED (cloned_parm
) = !first
|| TREE_USED (parm
);
63 /* The name may have changed from the declaration. */
64 DECL_NAME (cloned_parm
) = DECL_NAME (parm
);
65 DECL_SOURCE_LOCATION (cloned_parm
) = DECL_SOURCE_LOCATION (parm
);
66 TREE_TYPE (cloned_parm
) = TREE_TYPE (parm
);
68 DECL_GIMPLE_REG_P (cloned_parm
) = DECL_GIMPLE_REG_P (parm
);
72 /* FN is a function in High GIMPLE form that has a complete body and no
73 CFG. CLONE is a function whose body is to be set to a copy of FN,
74 mapping argument declarations according to the ARG_MAP splay_tree. */
77 clone_body (tree clone
, tree fn
, void *arg_map
)
82 /* Clone the body, as if we were making an inline call. But, remap
83 the parameters in the callee to the parameters of caller. */
84 memset (&id
, 0, sizeof (id
));
87 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
88 id
.decl_map
= (struct pointer_map_t
*) arg_map
;
90 id
.copy_decl
= copy_decl_no_change
;
91 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
92 id
.transform_new_cfg
= true;
93 id
.transform_return_to_modify
= false;
94 id
.transform_lang_insert_block
= NULL
;
96 /* We're not inside any EH region. */
99 stmts
= DECL_SAVED_TREE (fn
);
100 walk_tree (&stmts
, copy_tree_body_r
, &id
, NULL
);
102 /* Also remap the initializer of any static variables so that they (in
103 particular, any label addresses) correspond to the base variant rather
104 than the abstract one. */
105 if (DECL_NAME (clone
) == base_dtor_identifier
106 || DECL_NAME (clone
) == base_ctor_identifier
)
111 FOR_EACH_LOCAL_DECL (DECL_STRUCT_FUNCTION (fn
), ix
, decl
)
112 walk_tree (&DECL_INITIAL (decl
), copy_tree_body_r
, &id
, NULL
);
115 append_to_statement_list_force (stmts
, &DECL_SAVED_TREE (clone
));
118 /* DELETE_DTOR is a delete destructor whose body will be built.
119 COMPLETE_DTOR is the corresponding complete destructor. */
122 build_delete_destructor_body (tree delete_dtor
, tree complete_dtor
)
124 tree call_dtor
, call_delete
;
125 tree parm
= DECL_ARGUMENTS (delete_dtor
);
126 tree virtual_size
= cxx_sizeof (current_class_type
);
128 /* Call the corresponding complete destructor. */
129 gcc_assert (complete_dtor
);
130 call_dtor
= build_cxx_call (complete_dtor
, 1, &parm
,
131 tf_warning_or_error
);
132 add_stmt (call_dtor
);
134 add_stmt (build_stmt (0, LABEL_EXPR
, cdtor_label
));
136 /* Call the delete function. */
137 call_delete
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
140 /*placement=*/NULL_TREE
,
141 /*alloc_fn=*/NULL_TREE
,
142 tf_warning_or_error
);
143 add_stmt (call_delete
);
145 /* Return the address of the object. */
146 if (targetm
.cxx
.cdtor_returns_this ())
148 tree val
= DECL_ARGUMENTS (delete_dtor
);
149 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
150 DECL_RESULT (delete_dtor
), val
);
151 add_stmt (build_stmt (0, RETURN_EXPR
, val
));
155 /* Return name of comdat group for complete and base ctor (or dtor)
156 that have the same body. If dtor is virtual, deleting dtor goes
157 into this comdat group as well. */
160 cdtor_comdat_group (tree complete
, tree base
)
162 tree complete_name
= DECL_COMDAT_GROUP (complete
);
163 tree base_name
= DECL_COMDAT_GROUP (base
);
166 bool diff_seen
= false;
168 if (complete_name
== NULL
)
169 complete_name
= cxx_comdat_group (complete
);
170 if (base_name
== NULL
)
171 base_name
= cxx_comdat_group (base
);
172 gcc_assert (IDENTIFIER_LENGTH (complete_name
)
173 == IDENTIFIER_LENGTH (base_name
));
174 grp_name
= XALLOCAVEC (char, IDENTIFIER_LENGTH (complete_name
) + 1);
175 p
= IDENTIFIER_POINTER (complete_name
);
176 q
= IDENTIFIER_POINTER (base_name
);
177 for (idx
= 0; idx
< IDENTIFIER_LENGTH (complete_name
); idx
++)
178 if (p
[idx
] == q
[idx
])
179 grp_name
[idx
] = p
[idx
];
182 gcc_assert (!diff_seen
184 && (p
[idx
- 1] == 'C' || p
[idx
- 1] == 'D')
190 grp_name
[idx
] = '\0';
191 gcc_assert (diff_seen
);
192 return get_identifier (grp_name
);
195 /* FN is a function that has a complete body. Clone the body as
196 necessary. Returns nonzero if there's no longer any need to
197 process the main body. */
200 maybe_clone_body (tree fn
)
202 tree comdat_group
= NULL_TREE
;
206 bool in_charge_parm_used
;
208 bool need_alias
= false;
210 /* We only clone constructors and destructors. */
211 if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
)
212 && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
))
215 /* Emit the DWARF1 abstract instance. */
216 (*debug_hooks
->deferred_inline_function
) (fn
);
218 in_charge_parm_used
= CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn
)) != NULL
;
223 /* Look for the complete destructor which may be used to build the
224 delete destructor. */
225 FOR_EACH_CLONE (clone
, fn
)
226 if (DECL_NAME (clone
) == complete_dtor_identifier
227 || DECL_NAME (clone
) == complete_ctor_identifier
)
229 else if (DECL_NAME (clone
) == base_dtor_identifier
230 || DECL_NAME (clone
) == base_ctor_identifier
)
232 else if (DECL_NAME (clone
) == deleting_dtor_identifier
)
237 /* Remember if we can't have multiple clones for some reason. We need to
238 check this before we remap local static initializers in clone_body. */
239 if (!tree_versionable_function_p (fn
))
242 /* We know that any clones immediately follow FN in the TYPE_METHODS
244 push_to_top_level ();
245 for (idx
= 0; idx
< 3; idx
++)
251 struct pointer_map_t
*decl_map
;
257 /* Update CLONE's source position information to match FN's. */
258 DECL_SOURCE_LOCATION (clone
) = DECL_SOURCE_LOCATION (fn
);
259 DECL_DECLARED_INLINE_P (clone
) = DECL_DECLARED_INLINE_P (fn
);
260 DECL_DECLARED_CONSTEXPR_P (clone
) = DECL_DECLARED_CONSTEXPR_P (fn
);
261 DECL_COMDAT (clone
) = DECL_COMDAT (fn
);
262 DECL_WEAK (clone
) = DECL_WEAK (fn
);
264 /* We don't copy the comdat group from fn to clone because the assembler
265 name of fn was corrupted by write_mangled_name by adding *INTERNAL*
266 to it. By doing so, it also corrupted the comdat group. */
267 if (DECL_ONE_ONLY (fn
))
268 DECL_COMDAT_GROUP (clone
) = cxx_comdat_group (clone
);
269 DECL_SECTION_NAME (clone
) = DECL_SECTION_NAME (fn
);
270 DECL_USE_TEMPLATE (clone
) = DECL_USE_TEMPLATE (fn
);
271 DECL_EXTERNAL (clone
) = DECL_EXTERNAL (fn
);
272 DECL_INTERFACE_KNOWN (clone
) = DECL_INTERFACE_KNOWN (fn
);
273 DECL_NOT_REALLY_EXTERN (clone
) = DECL_NOT_REALLY_EXTERN (fn
);
274 TREE_PUBLIC (clone
) = TREE_PUBLIC (fn
);
275 DECL_VISIBILITY (clone
) = DECL_VISIBILITY (fn
);
276 DECL_VISIBILITY_SPECIFIED (clone
) = DECL_VISIBILITY_SPECIFIED (fn
);
277 DECL_DLLIMPORT_P (clone
) = DECL_DLLIMPORT_P (fn
);
278 DECL_ATTRIBUTES (clone
) = copy_list (DECL_ATTRIBUTES (fn
));
279 DECL_DISREGARD_INLINE_LIMITS (clone
) = DECL_DISREGARD_INLINE_LIMITS (fn
);
281 /* Adjust the parameter names and locations. */
282 parm
= DECL_ARGUMENTS (fn
);
283 clone_parm
= DECL_ARGUMENTS (clone
);
284 /* Update the `this' parameter, which is always first. */
285 update_cloned_parm (parm
, clone_parm
, first
);
286 parm
= DECL_CHAIN (parm
);
287 clone_parm
= DECL_CHAIN (clone_parm
);
288 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
289 parm
= DECL_CHAIN (parm
);
290 if (DECL_HAS_VTT_PARM_P (fn
))
291 parm
= DECL_CHAIN (parm
);
292 if (DECL_HAS_VTT_PARM_P (clone
))
293 clone_parm
= DECL_CHAIN (clone_parm
);
295 parm
= DECL_CHAIN (parm
), clone_parm
= DECL_CHAIN (clone_parm
))
296 /* Update this parameter. */
297 update_cloned_parm (parm
, clone_parm
, first
);
299 /* Start processing the function. */
300 start_preparsed_function (clone
, NULL_TREE
, SF_PRE_PARSED
);
302 /* Tell cgraph if both ctors or both dtors are known to have
304 if (!in_charge_parm_used
307 && !flag_use_repository
308 && DECL_INTERFACE_KNOWN (fns
[0])
309 && (SUPPORTS_ONE_ONLY
|| !DECL_WEAK (fns
[0]))
310 && (!DECL_ONE_ONLY (fns
[0])
311 || (HAVE_COMDAT_GROUP
312 && DECL_WEAK (fns
[0])))
314 /* Set linkage flags appropriately before
315 cgraph_create_function_alias looks at them. */
316 && expand_or_defer_fn_1 (clone
)
317 && cgraph_same_body_alias (cgraph_get_node (fns
[0]),
321 if (DECL_ONE_ONLY (fns
[0]))
323 /* For comdat base and complete cdtors put them
324 into the same, *[CD]5* comdat group instead of
326 comdat_group
= cdtor_comdat_group (fns
[1], fns
[0]);
327 DECL_COMDAT_GROUP (fns
[0]) = comdat_group
;
328 symtab_add_to_same_comdat_group (symtab_get_node (clone
),
329 symtab_get_node (fns
[0]));
333 /* Build the delete destructor by calling complete destructor
334 and delete function. */
337 build_delete_destructor_body (clone
, fns
[1]);
338 /* If *[CD][12]* dtors go into the *[CD]5* comdat group and dtor is
339 virtual, it goes into the same comdat group as well. */
341 symtab_add_to_same_comdat_group
342 ((symtab_node
) cgraph_get_create_node (clone
),
343 symtab_get_node (fns
[0]));
346 /* No need to populate body. */ ;
349 /* If we can't have multiple copies of FN (say, because there's a
350 static local initialized with the address of a label), we need
351 to use an alias for the complete variant. */
352 if (idx
== 1 && need_alias
)
354 if (DECL_STRUCT_FUNCTION (fn
)->cannot_be_copied_set
)
355 sorry (DECL_STRUCT_FUNCTION (fn
)->cannot_be_copied_reason
, fn
);
357 sorry ("making multiple clones of %qD", fn
);
360 /* Remap the parameters. */
361 decl_map
= pointer_map_create ();
363 parm
= DECL_ARGUMENTS (fn
),
364 clone_parm
= DECL_ARGUMENTS (clone
);
367 parm
= DECL_CHAIN (parm
))
369 /* Map the in-charge parameter to an appropriate constant. */
370 if (DECL_HAS_IN_CHARGE_PARM_P (fn
) && parmno
== 1)
373 in_charge
= in_charge_arg_for_name (DECL_NAME (clone
));
374 *pointer_map_insert (decl_map
, parm
) = in_charge
;
376 else if (DECL_ARTIFICIAL (parm
)
377 && DECL_NAME (parm
) == vtt_parm_identifier
)
379 /* For a subobject constructor or destructor, the next
380 argument is the VTT parameter. Remap the VTT_PARM
381 from the CLONE to this parameter. */
382 if (DECL_HAS_VTT_PARM_P (clone
))
384 DECL_ABSTRACT_ORIGIN (clone_parm
) = parm
;
385 *pointer_map_insert (decl_map
, parm
) = clone_parm
;
386 clone_parm
= DECL_CHAIN (clone_parm
);
388 /* Otherwise, map the VTT parameter to `NULL'. */
390 *pointer_map_insert (decl_map
, parm
)
391 = fold_convert (TREE_TYPE (parm
), null_pointer_node
);
393 /* Map other parameters to their equivalents in the cloned
397 *pointer_map_insert (decl_map
, parm
) = clone_parm
;
398 clone_parm
= DECL_CHAIN (clone_parm
);
402 if (targetm
.cxx
.cdtor_returns_this ())
404 parm
= DECL_RESULT (fn
);
405 clone_parm
= DECL_RESULT (clone
);
406 *pointer_map_insert (decl_map
, parm
) = clone_parm
;
409 /* Clone the body. */
410 clone_body (clone
, fn
, decl_map
);
413 pointer_map_destroy (decl_map
);
416 /* The clone can throw iff the original function can throw. */
417 cp_function_chain
->can_throw
= !TREE_NOTHROW (fn
);
419 /* Now, expand this function into RTL, if appropriate. */
421 BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone
)) = DECL_INITIAL (fn
);
424 if (expand_or_defer_fn_1 (clone
))
425 emit_associated_thunks (clone
);
428 expand_or_defer_fn (clone
);
431 pop_from_top_level ();
433 /* We don't need to process the original function any further. */