1 /* Perform optimizations on tree structure.
2 Copyright (C) 1998-2015 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"
28 #include "double-int.h"
35 #include "stringpool.h"
42 #include "tree-inline.h"
44 #include "langhooks.h"
45 #include "diagnostic-core.h"
47 #include "tree-iterator.h"
50 #include "plugin-api.h"
51 #include "hard-reg-set.h"
58 static void update_cloned_parm (tree
, tree
, bool);
60 /* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
61 or destructor. Update it to ensure that the source-position for
62 the cloned parameter matches that for the original, and that the
63 debugging generation code will be able to find the original PARM. */
66 update_cloned_parm (tree parm
, tree cloned_parm
, bool first
)
68 DECL_ABSTRACT_ORIGIN (cloned_parm
) = parm
;
70 /* We may have taken its address. */
71 TREE_ADDRESSABLE (cloned_parm
) = TREE_ADDRESSABLE (parm
);
73 /* The definition might have different constness. */
74 TREE_READONLY (cloned_parm
) = TREE_READONLY (parm
);
76 TREE_USED (cloned_parm
) = !first
|| TREE_USED (parm
);
78 /* The name may have changed from the declaration. */
79 DECL_NAME (cloned_parm
) = DECL_NAME (parm
);
80 DECL_SOURCE_LOCATION (cloned_parm
) = DECL_SOURCE_LOCATION (parm
);
81 TREE_TYPE (cloned_parm
) = TREE_TYPE (parm
);
83 DECL_GIMPLE_REG_P (cloned_parm
) = DECL_GIMPLE_REG_P (parm
);
87 /* FN is a function in High GIMPLE form that has a complete body and no
88 CFG. CLONE is a function whose body is to be set to a copy of FN,
89 mapping argument declarations according to the ARG_MAP splay_tree. */
92 clone_body (tree clone
, tree fn
, void *arg_map
)
97 /* Clone the body, as if we were making an inline call. But, remap
98 the parameters in the callee to the parameters of caller. */
99 memset (&id
, 0, sizeof (id
));
102 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
103 id
.decl_map
= static_cast<hash_map
<tree
, tree
> *> (arg_map
);
105 id
.copy_decl
= copy_decl_no_change
;
106 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
107 id
.transform_new_cfg
= true;
108 id
.transform_return_to_modify
= false;
109 id
.transform_lang_insert_block
= NULL
;
111 /* We're not inside any EH region. */
114 stmts
= DECL_SAVED_TREE (fn
);
115 walk_tree (&stmts
, copy_tree_body_r
, &id
, NULL
);
117 /* Also remap the initializer of any static variables so that they (in
118 particular, any label addresses) correspond to the base variant rather
119 than the abstract one. */
120 if (DECL_NAME (clone
) == base_dtor_identifier
121 || DECL_NAME (clone
) == base_ctor_identifier
)
126 FOR_EACH_LOCAL_DECL (DECL_STRUCT_FUNCTION (fn
), ix
, decl
)
127 walk_tree (&DECL_INITIAL (decl
), copy_tree_body_r
, &id
, NULL
);
130 append_to_statement_list_force (stmts
, &DECL_SAVED_TREE (clone
));
133 /* DELETE_DTOR is a delete destructor whose body will be built.
134 COMPLETE_DTOR is the corresponding complete destructor. */
137 build_delete_destructor_body (tree delete_dtor
, tree complete_dtor
)
139 tree call_dtor
, call_delete
;
140 tree parm
= DECL_ARGUMENTS (delete_dtor
);
141 tree virtual_size
= cxx_sizeof (current_class_type
);
143 /* Call the corresponding complete destructor. */
144 gcc_assert (complete_dtor
);
145 call_dtor
= build_cxx_call (complete_dtor
, 1, &parm
,
146 tf_warning_or_error
);
147 add_stmt (call_dtor
);
149 add_stmt (build_stmt (0, LABEL_EXPR
, cdtor_label
));
151 /* Call the delete function. */
152 call_delete
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
155 /*placement=*/NULL_TREE
,
156 /*alloc_fn=*/NULL_TREE
,
157 tf_warning_or_error
);
158 add_stmt (call_delete
);
160 /* Return the address of the object. */
161 if (targetm
.cxx
.cdtor_returns_this ())
163 tree val
= DECL_ARGUMENTS (delete_dtor
);
164 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
165 DECL_RESULT (delete_dtor
), val
);
166 add_stmt (build_stmt (0, RETURN_EXPR
, val
));
170 /* Return name of comdat group for complete and base ctor (or dtor)
171 that have the same body. If dtor is virtual, deleting dtor goes
172 into this comdat group as well. */
175 cdtor_comdat_group (tree complete
, tree base
)
177 tree complete_name
= DECL_ASSEMBLER_NAME (complete
);
178 tree base_name
= DECL_ASSEMBLER_NAME (base
);
181 bool diff_seen
= false;
183 gcc_assert (IDENTIFIER_LENGTH (complete_name
)
184 == IDENTIFIER_LENGTH (base_name
));
185 grp_name
= XALLOCAVEC (char, IDENTIFIER_LENGTH (complete_name
) + 1);
186 p
= IDENTIFIER_POINTER (complete_name
);
187 q
= IDENTIFIER_POINTER (base_name
);
188 for (idx
= 0; idx
< IDENTIFIER_LENGTH (complete_name
); idx
++)
189 if (p
[idx
] == q
[idx
])
190 grp_name
[idx
] = p
[idx
];
193 gcc_assert (!diff_seen
195 && (p
[idx
- 1] == 'C' || p
[idx
- 1] == 'D')
201 grp_name
[idx
] = '\0';
202 gcc_assert (diff_seen
);
203 return get_identifier (grp_name
);
206 /* Returns true iff we can make the base and complete [cd]tor aliases of
207 the same symbol rather than separate functions. */
210 can_alias_cdtor (tree fn
)
212 #ifndef ASM_OUTPUT_DEF
213 /* If aliases aren't supported by the assembler, fail. */
216 /* We can't use an alias if there are virtual bases. */
217 if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn
)))
219 /* ??? Why not use aliases with -frepo? */
220 if (flag_use_repository
)
222 gcc_assert (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
)
223 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
));
224 /* Don't use aliases for weak/linkonce definitions unless we can put both
225 symbols in the same COMDAT group. */
226 return (DECL_INTERFACE_KNOWN (fn
)
227 && (SUPPORTS_ONE_ONLY
|| !DECL_WEAK (fn
))
228 && (!DECL_ONE_ONLY (fn
)
229 || (HAVE_COMDAT_GROUP
&& DECL_WEAK (fn
))));
232 /* FN is a [cd]tor, fns is a pointer to an array of length 3. Fill fns
233 with pointers to the base, complete, and deleting variants. */
236 populate_clone_array (tree fn
, tree
*fns
)
244 /* Look for the complete destructor which may be used to build the
245 delete destructor. */
246 FOR_EACH_CLONE (clone
, fn
)
247 if (DECL_NAME (clone
) == complete_dtor_identifier
248 || DECL_NAME (clone
) == complete_ctor_identifier
)
250 else if (DECL_NAME (clone
) == base_dtor_identifier
251 || DECL_NAME (clone
) == base_ctor_identifier
)
253 else if (DECL_NAME (clone
) == deleting_dtor_identifier
)
259 /* FN is a constructor or destructor, and there are FUNCTION_DECLs
260 cloned from it nearby. Instead of cloning this body, leave it
261 alone and create tiny one-call bodies for the cloned
262 FUNCTION_DECLs. These clones are sibcall candidates, and their
263 resulting code will be very thunk-esque. */
266 maybe_thunk_body (tree fn
, bool force
)
268 tree bind
, block
, call
, clone
, clone_result
, fn_parm
, fn_parm_typelist
;
269 tree last_arg
, modify
, *args
;
270 int parmno
, vtt_parmno
, max_parms
;
273 if (!force
&& !flag_declone_ctor_dtor
)
276 /* If function accepts variable arguments, give up. */
277 last_arg
= tree_last (TYPE_ARG_TYPES (TREE_TYPE (fn
)));
278 if (last_arg
!= void_list_node
)
281 /* If we got this far, we've decided to turn the clones into thunks. */
283 /* We're going to generate code for fn, so it is no longer "abstract."
284 Also make the unified ctor/dtor private to either the translation unit
285 (for non-vague linkage ctors) or the COMDAT group (otherwise). */
287 populate_clone_array (fn
, fns
);
288 DECL_ABSTRACT_P (fn
) = false;
291 TREE_PUBLIC (fn
) = false;
292 DECL_EXTERNAL (fn
) = false;
293 DECL_INTERFACE_KNOWN (fn
) = true;
295 else if (HAVE_COMDAT_GROUP
)
297 tree comdat_group
= cdtor_comdat_group (fns
[1], fns
[0]);
298 cgraph_node::get_create (fns
[0])->set_comdat_group (comdat_group
);
299 cgraph_node::get_create (fns
[1])->add_to_same_comdat_group
300 (cgraph_node::get_create (fns
[0]));
301 symtab_node::get (fn
)->add_to_same_comdat_group
302 (symtab_node::get (fns
[0]));
304 /* If *[CD][12]* dtors go into the *[CD]5* comdat group and dtor is
305 virtual, it goes into the same comdat group as well. */
306 cgraph_node::get_create (fns
[2])->add_to_same_comdat_group
307 (symtab_node::get (fns
[0]));
308 TREE_PUBLIC (fn
) = false;
309 DECL_EXTERNAL (fn
) = false;
310 DECL_INTERFACE_KNOWN (fn
) = true;
311 /* function_and_variable_visibility doesn't want !PUBLIC decls to
312 have these flags set. */
313 DECL_WEAK (fn
) = false;
314 DECL_COMDAT (fn
) = false;
317 /* Find the vtt_parm, if present. */
318 for (vtt_parmno
= -1, parmno
= 0, fn_parm
= DECL_ARGUMENTS (fn
);
320 ++parmno
, fn_parm
= TREE_CHAIN (fn_parm
))
322 if (DECL_ARTIFICIAL (fn_parm
)
323 && DECL_NAME (fn_parm
) == vtt_parm_identifier
)
325 /* Compensate for removed in_charge parameter. */
331 /* Allocate an argument buffer for build_cxx_call().
332 Make sure it is large enough for any of the clones. */
334 FOR_EACH_CLONE (clone
, fn
)
336 int length
= list_length (DECL_ARGUMENTS (fn
));
337 if (length
> max_parms
)
340 args
= (tree
*) alloca (max_parms
* sizeof (tree
));
342 /* We know that any clones immediately follow FN in TYPE_METHODS. */
343 FOR_EACH_CLONE (clone
, fn
)
347 /* If we've already generated a body for this clone, avoid
348 duplicating it. (Is it possible for a clone-list to grow after we
350 if (DECL_SAVED_TREE (clone
) || TREE_ASM_WRITTEN (clone
))
353 /* Start processing the function. */
354 start_preparsed_function (clone
, NULL_TREE
, SF_PRE_PARSED
);
358 for (clone_parm
= DECL_ARGUMENTS (clone
); clone_parm
;
359 clone_parm
= TREE_CHAIN (clone_parm
))
360 DECL_ABSTRACT_ORIGIN (clone_parm
) = NULL_TREE
;
361 /* Build the delete destructor by calling complete destructor and
363 build_delete_destructor_body (clone
, fns
[1]);
367 /* Walk parameter lists together, creating parameter list for
368 call to original function. */
370 fn_parm
= DECL_ARGUMENTS (fn
),
371 fn_parm_typelist
= TYPE_ARG_TYPES (TREE_TYPE (fn
)),
372 clone_parm
= DECL_ARGUMENTS (clone
);
375 fn_parm
= TREE_CHAIN (fn_parm
))
377 if (parmno
== vtt_parmno
&& ! DECL_HAS_VTT_PARM_P (clone
))
379 gcc_assert (fn_parm_typelist
);
380 /* Clobber argument with formal parameter type. */
382 = convert (TREE_VALUE (fn_parm_typelist
),
385 else if (parmno
== 1 && DECL_HAS_IN_CHARGE_PARM_P (fn
))
388 = copy_node (in_charge_arg_for_name (DECL_NAME (clone
)));
389 args
[parmno
] = in_charge
;
391 /* Map other parameters to their equivalents in the cloned
395 gcc_assert (clone_parm
);
396 DECL_ABSTRACT_ORIGIN (clone_parm
) = NULL
;
397 args
[parmno
] = clone_parm
;
398 clone_parm
= TREE_CHAIN (clone_parm
);
400 if (fn_parm_typelist
)
401 fn_parm_typelist
= TREE_CHAIN (fn_parm_typelist
);
404 /* We built this list backwards; fix now. */
406 call
= build_cxx_call (fn
, parmno
, args
, tf_warning_or_error
);
407 /* Arguments passed to the thunk by invisible reference should
408 be transmitted to the callee unchanged. Do not create a
409 temporary and invoke the copy constructor. The thunking
410 transformation must not introduce any constructor calls. */
411 CALL_FROM_THUNK_P (call
) = 1;
412 block
= make_node (BLOCK
);
413 if (targetm
.cxx
.cdtor_returns_this ())
415 clone_result
= DECL_RESULT (clone
);
416 modify
= build2 (MODIFY_EXPR
, TREE_TYPE (clone_result
),
418 modify
= build1 (RETURN_EXPR
, void_type_node
, modify
);
425 bind
= c_build_bind_expr (DECL_SOURCE_LOCATION (clone
),
426 block
, cur_stmt_list
);
427 DECL_SAVED_TREE (clone
) = push_stmt_list ();
431 DECL_ABSTRACT_ORIGIN (clone
) = NULL
;
432 expand_or_defer_fn (finish_function (0));
437 /* FN is a function that has a complete body. Clone the body as
438 necessary. Returns nonzero if there's no longer any need to
439 process the main body. */
442 maybe_clone_body (tree fn
)
444 tree comdat_group
= NULL_TREE
;
449 bool need_alias
= false;
451 /* We only clone constructors and destructors. */
452 if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
)
453 && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
))
456 populate_clone_array (fn
, fns
);
458 /* Remember if we can't have multiple clones for some reason. We need to
459 check this before we remap local static initializers in clone_body. */
460 if (!tree_versionable_function_p (fn
))
463 /* We know that any clones immediately follow FN in the TYPE_METHODS
465 push_to_top_level ();
466 for (idx
= 0; idx
< 3; idx
++)
475 /* Update CLONE's source position information to match FN's. */
476 DECL_SOURCE_LOCATION (clone
) = DECL_SOURCE_LOCATION (fn
);
477 DECL_DECLARED_INLINE_P (clone
) = DECL_DECLARED_INLINE_P (fn
);
478 DECL_DECLARED_CONSTEXPR_P (clone
) = DECL_DECLARED_CONSTEXPR_P (fn
);
479 DECL_COMDAT (clone
) = DECL_COMDAT (fn
);
480 DECL_WEAK (clone
) = DECL_WEAK (fn
);
482 /* We don't copy the comdat group from fn to clone because the assembler
483 name of fn was corrupted by write_mangled_name by adding *INTERNAL*
484 to it. By doing so, it also corrupted the comdat group. */
485 if (DECL_ONE_ONLY (fn
))
486 cgraph_node::get_create (clone
)->set_comdat_group (cxx_comdat_group (clone
));
487 DECL_USE_TEMPLATE (clone
) = DECL_USE_TEMPLATE (fn
);
488 DECL_EXTERNAL (clone
) = DECL_EXTERNAL (fn
);
489 DECL_INTERFACE_KNOWN (clone
) = DECL_INTERFACE_KNOWN (fn
);
490 DECL_NOT_REALLY_EXTERN (clone
) = DECL_NOT_REALLY_EXTERN (fn
);
491 TREE_PUBLIC (clone
) = TREE_PUBLIC (fn
);
492 DECL_VISIBILITY (clone
) = DECL_VISIBILITY (fn
);
493 DECL_VISIBILITY_SPECIFIED (clone
) = DECL_VISIBILITY_SPECIFIED (fn
);
494 DECL_DLLIMPORT_P (clone
) = DECL_DLLIMPORT_P (fn
);
495 DECL_ATTRIBUTES (clone
) = copy_list (DECL_ATTRIBUTES (fn
));
496 DECL_DISREGARD_INLINE_LIMITS (clone
) = DECL_DISREGARD_INLINE_LIMITS (fn
);
497 set_decl_section_name (clone
, DECL_SECTION_NAME (fn
));
499 /* Adjust the parameter names and locations. */
500 parm
= DECL_ARGUMENTS (fn
);
501 clone_parm
= DECL_ARGUMENTS (clone
);
502 /* Update the `this' parameter, which is always first. */
503 update_cloned_parm (parm
, clone_parm
, first
);
504 parm
= DECL_CHAIN (parm
);
505 clone_parm
= DECL_CHAIN (clone_parm
);
506 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
507 parm
= DECL_CHAIN (parm
);
508 if (DECL_HAS_VTT_PARM_P (fn
))
509 parm
= DECL_CHAIN (parm
);
510 if (DECL_HAS_VTT_PARM_P (clone
))
511 clone_parm
= DECL_CHAIN (clone_parm
);
513 parm
= DECL_CHAIN (parm
), clone_parm
= DECL_CHAIN (clone_parm
))
514 /* Update this parameter. */
515 update_cloned_parm (parm
, clone_parm
, first
);
518 bool can_alias
= can_alias_cdtor (fn
);
520 /* If we decide to turn clones into thunks, they will branch to fn.
521 Must have original function available to call. */
522 if (!can_alias
&& maybe_thunk_body (fn
, need_alias
))
524 pop_from_top_level ();
525 /* We still need to emit the original function. */
529 /* Emit the DWARF1 abstract instance. */
530 (*debug_hooks
->deferred_inline_function
) (fn
);
532 /* We know that any clones immediately follow FN in the TYPE_METHODS list. */
533 for (idx
= 0; idx
< 3; idx
++)
538 hash_map
<tree
, tree
> *decl_map
;
545 /* Start processing the function. */
546 start_preparsed_function (clone
, NULL_TREE
, SF_PRE_PARSED
);
548 /* Tell cgraph if both ctors or both dtors are known to have
553 && cgraph_node::get_create (fns
[0])->create_same_body_alias
557 if (DECL_ONE_ONLY (fns
[0]))
559 /* For comdat base and complete cdtors put them
560 into the same, *[CD]5* comdat group instead of
562 comdat_group
= cdtor_comdat_group (fns
[1], fns
[0]);
563 cgraph_node::get_create (fns
[0])->set_comdat_group (comdat_group
);
564 if (symtab_node::get (clone
)->same_comdat_group
)
565 symtab_node::get (clone
)->remove_from_same_comdat_group ();
566 symtab_node::get (clone
)->add_to_same_comdat_group
567 (symtab_node::get (fns
[0]));
571 /* Build the delete destructor by calling complete destructor
572 and delete function. */
575 build_delete_destructor_body (clone
, fns
[1]);
576 /* If *[CD][12]* dtors go into the *[CD]5* comdat group and dtor is
577 virtual, it goes into the same comdat group as well. */
579 cgraph_node::get_create (clone
)->add_to_same_comdat_group
580 (symtab_node::get (fns
[0]));
583 /* No need to populate body. */ ;
586 /* If we can't have multiple copies of FN (say, because there's a
587 static local initialized with the address of a label), we need
588 to use an alias for the complete variant. */
589 if (idx
== 1 && need_alias
)
591 if (DECL_STRUCT_FUNCTION (fn
)->cannot_be_copied_set
)
592 sorry (DECL_STRUCT_FUNCTION (fn
)->cannot_be_copied_reason
, fn
);
594 sorry ("making multiple clones of %qD", fn
);
597 /* Remap the parameters. */
598 decl_map
= new hash_map
<tree
, tree
>;
600 parm
= DECL_ARGUMENTS (fn
),
601 clone_parm
= DECL_ARGUMENTS (clone
);
604 parm
= DECL_CHAIN (parm
))
606 /* Map the in-charge parameter to an appropriate constant. */
607 if (DECL_HAS_IN_CHARGE_PARM_P (fn
) && parmno
== 1)
610 in_charge
= in_charge_arg_for_name (DECL_NAME (clone
));
611 decl_map
->put (parm
, in_charge
);
613 else if (DECL_ARTIFICIAL (parm
)
614 && DECL_NAME (parm
) == vtt_parm_identifier
)
616 /* For a subobject constructor or destructor, the next
617 argument is the VTT parameter. Remap the VTT_PARM
618 from the CLONE to this parameter. */
619 if (DECL_HAS_VTT_PARM_P (clone
))
621 DECL_ABSTRACT_ORIGIN (clone_parm
) = parm
;
622 decl_map
->put (parm
, clone_parm
);
623 clone_parm
= DECL_CHAIN (clone_parm
);
625 /* Otherwise, map the VTT parameter to `NULL'. */
629 = fold_convert (TREE_TYPE (parm
), null_pointer_node
);
630 decl_map
->put (parm
, t
);
633 /* Map other parameters to their equivalents in the cloned
637 decl_map
->put (parm
, clone_parm
);
638 clone_parm
= DECL_CHAIN (clone_parm
);
642 if (targetm
.cxx
.cdtor_returns_this ())
644 parm
= DECL_RESULT (fn
);
645 clone_parm
= DECL_RESULT (clone
);
646 decl_map
->put (parm
, clone_parm
);
649 /* Clone the body. */
650 clone_body (clone
, fn
, decl_map
);
656 /* The clone can throw iff the original function can throw. */
657 cp_function_chain
->can_throw
= !TREE_NOTHROW (fn
);
659 /* Now, expand this function into RTL, if appropriate. */
661 BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone
)) = DECL_INITIAL (fn
);
664 if (expand_or_defer_fn_1 (clone
))
665 emit_associated_thunks (clone
);
668 expand_or_defer_fn (clone
);
671 pop_from_top_level ();
673 /* We don't need to process the original function any further. */