gcc/cp/optimize.cc

   1 /* Perform optimizations on tree structure.
   2    Copyright (C) 1998-2023 Free Software Foundation, Inc.
   3    Written by Mark Michell (mark@codesourcery.com).
   4
   5 This file is part of GCC.
   6
   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)
  10 any later version.
  11
  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.
  16
  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/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "target.h"
  25 #include "cp-tree.h"
  26 #include "stringpool.h"
  27 #include "cgraph.h"
  28 #include "debug.h"
  29 #include "tree-inline.h"
  30 #include "tree-iterator.h"
  31
  32 /* Prototypes.  */
  33
  34 static void update_cloned_parm (tree, tree, bool);
  35
  36 /* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
  37    or destructor.  Update it to ensure that the source-position for
  38    the cloned parameter matches that for the original, and that the
  39    debugging generation code will be able to find the original PARM.  */
  40
  41 static void
  42 update_cloned_parm (tree parm, tree cloned_parm, bool first)
  43 {
  44   DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
  45
  46   /* We may have taken its address.  */
  47   TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
  48
  49   DECL_BY_REFERENCE (cloned_parm) = DECL_BY_REFERENCE (parm);
  50
  51   /* The definition might have different constness.  */
  52   TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
  53
  54   TREE_USED (cloned_parm) = !first || TREE_USED (parm);
  55
  56   /* The name may have changed from the declaration.  */
  57   DECL_NAME (cloned_parm) = DECL_NAME (parm);
  58   DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
  59   TREE_TYPE (cloned_parm) = TREE_TYPE (parm);
  60
  61   DECL_NOT_GIMPLE_REG_P (cloned_parm) = DECL_NOT_GIMPLE_REG_P (parm);
  62 }
  63
  64 /* Like copy_decl_no_change, but handle DECL_OMP_PRIVATIZED_MEMBER
  65    properly.  */
  66
  67 static tree
  68 cxx_copy_decl (tree decl, copy_body_data *id)
  69 {
  70   tree copy = copy_decl_no_change (decl, id);
  71   if (VAR_P (decl)
  72       && DECL_HAS_VALUE_EXPR_P (decl)
  73       && DECL_ARTIFICIAL (decl)
  74       && DECL_LANG_SPECIFIC (decl)
  75       && DECL_OMP_PRIVATIZED_MEMBER (decl))
  76     {
  77       tree expr = DECL_VALUE_EXPR (copy);
  78       walk_tree (&expr, copy_tree_body_r, id, NULL);
  79       SET_DECL_VALUE_EXPR (copy, expr);
  80     }
  81   return copy;
  82 }
  83
  84 /* FN is a function in High GIMPLE form that has a complete body and no
  85    CFG.  CLONE is a function whose body is to be set to a copy of FN,
  86    mapping argument declarations according to the ARG_MAP splay_tree.  */
  87
  88 static void
  89 clone_body (tree clone, tree fn, void *arg_map)
  90 {
  91   copy_body_data id;
  92   tree stmts;
  93
  94   /* Clone the body, as if we were making an inline call.  But, remap
  95      the parameters in the callee to the parameters of caller.  */
  96   memset (&id, 0, sizeof (id));
  97   id.src_fn = fn;
  98   id.dst_fn = clone;
  99   id.src_cfun = DECL_STRUCT_FUNCTION (fn);
 100   id.decl_map = static_cast<hash_map<tree, tree> *> (arg_map);
 101
 102   id.copy_decl = cxx_copy_decl;
 103   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
 104   id.transform_new_cfg = true;
 105   id.transform_return_to_modify = false;
 106
 107   /* We're not inside any EH region.  */
 108   id.eh_lp_nr = 0;
 109
 110   stmts = DECL_SAVED_TREE (fn);
 111   walk_tree (&stmts, copy_tree_body_r, &id, NULL);
 112
 113   /* Also remap the initializer of any static variables so that they (in
 114      particular, any label addresses) correspond to the base variant rather
 115      than the abstract one.  */
 116   if (DECL_NAME (clone) == base_dtor_identifier
 117       || DECL_NAME (clone) == base_ctor_identifier)
 118     {
 119       unsigned ix;
 120       tree decl;
 121
 122       FOR_EACH_LOCAL_DECL (DECL_STRUCT_FUNCTION (fn), ix, decl)
 123         walk_tree (&DECL_INITIAL (decl), copy_tree_body_r, &id, NULL);
 124     }
 125
 126   append_to_statement_list_force (stmts, &DECL_SAVED_TREE (clone));
 127 }
 128
 129 /* DELETE_DTOR is a delete destructor whose body will be built.
 130    COMPLETE_DTOR is the corresponding complete destructor.  */
 131
 132 static void
 133 build_delete_destructor_body (tree delete_dtor, tree complete_dtor)
 134 {
 135   tree parm = DECL_ARGUMENTS (delete_dtor);
 136   tree virtual_size = cxx_sizeof (current_class_type);
 137
 138   /* Call the delete function.  */
 139   tree call_delete = build_op_delete_call (DELETE_EXPR, current_class_ptr,
 140                                            virtual_size,
 141                                            /*global_p=*/false,
 142                                            /*placement=*/NULL_TREE,
 143                                            /*alloc_fn=*/NULL_TREE,
 144                                            tf_warning_or_error);
 145
 146   tree op = get_callee_fndecl (call_delete);
 147   if (op && DECL_P (op) && destroying_delete_p (op))
 148     {
 149       /* The destroying delete will handle calling complete_dtor.  */
 150       add_stmt (call_delete);
 151     }
 152   else
 153     {
 154       /* Call the corresponding complete destructor.  */
 155       gcc_assert (complete_dtor);
 156       tree call_dtor = build_cxx_call (complete_dtor, 1, &parm,
 157                                        tf_warning_or_error);
 158
 159       /* Operator delete must be called, whether or not the dtor throws.  */
 160       add_stmt (build2 (TRY_FINALLY_EXPR, void_type_node,
 161                         call_dtor, call_delete));
 162     }
 163
 164   /* Return the address of the object.
 165      ??? How is it useful to return an invalid address?  */
 166   maybe_return_this ();
 167 }
 168
 169 /* Return name of comdat group for complete and base ctor (or dtor)
 170    that have the same body.  If dtor is virtual, deleting dtor goes
 171    into this comdat group as well.  */
 172
 173 static tree
 174 cdtor_comdat_group (tree complete, tree base)
 175 {
 176   tree complete_name = DECL_ASSEMBLER_NAME (complete);
 177   tree base_name = DECL_ASSEMBLER_NAME (base);
 178   char *grp_name;
 179   const char *p, *q;
 180   bool diff_seen = false;
 181   size_t idx;
 182   gcc_assert (IDENTIFIER_LENGTH (complete_name)
 183               == IDENTIFIER_LENGTH (base_name));
 184   grp_name = XALLOCAVEC (char, IDENTIFIER_LENGTH (complete_name) + 1);
 185   p = IDENTIFIER_POINTER (complete_name);
 186   q = IDENTIFIER_POINTER (base_name);
 187   for (idx = 0; idx < IDENTIFIER_LENGTH (complete_name); idx++)
 188     if (p[idx] == q[idx])
 189       grp_name[idx] = p[idx];
 190     else
 191       {
 192         gcc_assert (!diff_seen
 193                     && idx > 0
 194                     && (p[idx - 1] == 'C' || p[idx - 1] == 'D'
 195                         || p[idx - 1] == 'I')
 196                     && p[idx] == '1'
 197                     && q[idx] == '2');
 198         grp_name[idx] = '5';
 199         diff_seen = true;
 200       }
 201   grp_name[idx] = '\0';
 202   gcc_assert (diff_seen);
 203   return get_identifier (grp_name);
 204 }
 205
 206 /* Returns true iff we can make the base and complete [cd]tor aliases of
 207    the same symbol rather than separate functions.  */
 208
 209 static bool
 210 can_alias_cdtor (tree fn)
 211 {
 212   /* If aliases aren't supported by the assembler, fail.  */
 213   if (!TARGET_SUPPORTS_ALIASES)
 214     return false;
 215
 216   /* We can't use an alias if there are virtual bases.  */
 217   if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
 218     return false;
 219   gcc_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (fn));
 220   /* Don't use aliases for weak/linkonce definitions unless we can put both
 221      symbols in the same COMDAT group.  */
 222   return (DECL_INTERFACE_KNOWN (fn)
 223           && (SUPPORTS_ONE_ONLY || !DECL_WEAK (fn))
 224           && (!DECL_ONE_ONLY (fn)
 225               || (HAVE_COMDAT_GROUP && DECL_WEAK (fn))));
 226 }
 227
 228 /* FN is a [cd]tor, fns is a pointer to an array of length 3.  Fill fns
 229    with pointers to the base, complete, and deleting variants.  */
 230
 231 static void
 232 populate_clone_array (tree fn, tree *fns)
 233 {
 234   tree clone;
 235
 236   fns[0] = NULL_TREE;
 237   fns[1] = NULL_TREE;
 238   fns[2] = NULL_TREE;
 239
 240   FOR_EACH_CLONE (clone, fn)
 241     if (DECL_NAME (clone) == complete_dtor_identifier
 242         || DECL_NAME (clone) == complete_ctor_identifier)
 243       fns[1] = clone;
 244     else if (DECL_NAME (clone) == base_dtor_identifier
 245              || DECL_NAME (clone) == base_ctor_identifier)
 246       fns[0] = clone;
 247     else if (DECL_NAME (clone) == deleting_dtor_identifier)
 248       fns[2] = clone;
 249     else
 250       gcc_unreachable ();
 251 }
 252
 253 /* FN is a constructor or destructor, and there are FUNCTION_DECLs
 254    cloned from it nearby.  Instead of cloning this body, leave it
 255    alone and create tiny one-call bodies for the cloned
 256    FUNCTION_DECLs.  These clones are sibcall candidates, and their
 257    resulting code will be very thunk-esque.  */
 258
 259 static bool
 260 maybe_thunk_body (tree fn, bool force)
 261 {
 262   tree bind, block, call, clone, clone_result, fn_parm, fn_parm_typelist;
 263   tree last_arg, modify, *args;
 264   int parmno, vtt_parmno, max_parms;
 265   tree fns[3];
 266
 267   if (!force && !flag_declone_ctor_dtor)
 268     return 0;
 269
 270   /* If function accepts variable arguments, give up.  */
 271   last_arg = tree_last (TYPE_ARG_TYPES (TREE_TYPE (fn)));
 272   if (last_arg != void_list_node)
 273     return 0;
 274
 275   /* If we got this far, we've decided to turn the clones into thunks.  */
 276
 277   /* We're going to generate code for fn, so it is no longer "abstract."
 278      Also make the unified ctor/dtor private to either the translation unit
 279      (for non-vague linkage ctors) or the COMDAT group (otherwise).  */
 280
 281   populate_clone_array (fn, fns);
 282
 283   /* Can happen during error recovery (c++/71464).  */
 284   if (!fns[0] || !fns[1])
 285     return 0;
 286
 287   /* Don't use thunks if the base clone omits inherited parameters.  */
 288   if (ctor_omit_inherited_parms (fns[0]))
 289     return 0;
 290
 291   DECL_ABSTRACT_P (fn) = false;
 292   if (!DECL_WEAK (fn))
 293     {
 294       TREE_PUBLIC (fn) = false;
 295       DECL_EXTERNAL (fn) = false;
 296       DECL_INTERFACE_KNOWN (fn) = true;
 297     }
 298   else if (HAVE_COMDAT_GROUP)
 299     {
 300       /* At eof, defer creation of mangling aliases temporarily.  */
 301       bool save_defer_mangling_aliases = defer_mangling_aliases;
 302       defer_mangling_aliases = true;
 303       tree comdat_group = cdtor_comdat_group (fns[1], fns[0]);
 304       defer_mangling_aliases = save_defer_mangling_aliases;
 305       cgraph_node::get_create (fns[0])->set_comdat_group (comdat_group);
 306       cgraph_node::get_create (fns[1])->add_to_same_comdat_group
 307         (cgraph_node::get_create (fns[0]));
 308       symtab_node::get (fn)->add_to_same_comdat_group
 309         (symtab_node::get (fns[0]));
 310       if (fns[2])
 311         /* If *[CD][12]* dtors go into the *[CD]5* comdat group and dtor is
 312            virtual, it goes into the same comdat group as well.  */
 313         cgraph_node::get_create (fns[2])->add_to_same_comdat_group
 314           (symtab_node::get (fns[0]));
 315       /* Emit them now that the thunks are same comdat group aliases.  */
 316       if (!save_defer_mangling_aliases)
 317         generate_mangling_aliases ();
 318       TREE_PUBLIC (fn) = false;
 319       DECL_EXTERNAL (fn) = false;
 320       DECL_INTERFACE_KNOWN (fn) = true;
 321       /* function_and_variable_visibility doesn't want !PUBLIC decls to
 322          have these flags set.  */
 323       DECL_WEAK (fn) = false;
 324       DECL_COMDAT (fn) = false;
 325     }
 326
 327   /* Find the vtt_parm, if present.  */
 328   for (vtt_parmno = -1, parmno = 0, fn_parm = DECL_ARGUMENTS (fn);
 329        fn_parm;
 330        ++parmno, fn_parm = TREE_CHAIN (fn_parm))
 331     {
 332       if (DECL_ARTIFICIAL (fn_parm)
 333           && DECL_NAME (fn_parm) == vtt_parm_identifier)
 334         {
 335           /* Compensate for removed in_charge parameter.  */
 336           vtt_parmno = parmno;
 337           break;
 338         }
 339     }
 340
 341   /* Allocate an argument buffer for build_cxx_call().
 342      Make sure it is large enough for any of the clones.  */
 343   max_parms = 0;
 344   FOR_EACH_CLONE (clone, fn)
 345     {
 346       int length = list_length (DECL_ARGUMENTS (fn));
 347       if (length > max_parms)
 348         max_parms = length;
 349     }
 350   args = XALLOCAVEC (tree, max_parms);
 351
 352   /* We know that any clones immediately follow FN in TYPE_FIELDS.  */
 353   FOR_EACH_CLONE (clone, fn)
 354     {
 355       tree clone_parm;
 356
 357       /* If we've already generated a body for this clone, avoid
 358          duplicating it.  (Is it possible for a clone-list to grow after we
 359          first see it?)  */
 360       if (DECL_SAVED_TREE (clone) || TREE_ASM_WRITTEN (clone))
 361         continue;
 362
 363       /* Start processing the function.  */
 364       start_preparsed_function (clone, NULL_TREE, SF_PRE_PARSED);
 365
 366       if (clone == fns[2])
 367         {
 368           for (clone_parm = DECL_ARGUMENTS (clone); clone_parm;
 369                clone_parm = TREE_CHAIN (clone_parm))
 370             DECL_ABSTRACT_ORIGIN (clone_parm) = NULL_TREE;
 371           /* Build the delete destructor by calling complete destructor and
 372              delete function.  */
 373           build_delete_destructor_body (clone, fns[1]);
 374         }
 375       else
 376         {
 377           /* Walk parameter lists together, creating parameter list for
 378              call to original function.  */
 379           for (parmno = 0,
 380                  fn_parm = DECL_ARGUMENTS (fn),
 381                  fn_parm_typelist = TYPE_ARG_TYPES (TREE_TYPE (fn)),
 382                  clone_parm = DECL_ARGUMENTS (clone);
 383                fn_parm;
 384                ++parmno,
 385                  fn_parm = TREE_CHAIN (fn_parm))
 386             {
 387               if (parmno == vtt_parmno && ! DECL_HAS_VTT_PARM_P (clone))
 388                 {
 389                   gcc_assert (fn_parm_typelist);
 390                   /* Clobber argument with formal parameter type.  */
 391                   args[parmno]
 392                     = convert (TREE_VALUE (fn_parm_typelist),
 393                                null_pointer_node);
 394                 }
 395               else if (parmno == 1 && DECL_HAS_IN_CHARGE_PARM_P (fn))
 396                 {
 397                   tree in_charge
 398                     = copy_node (in_charge_arg_for_name (DECL_NAME (clone)));
 399                   args[parmno] = in_charge;
 400                 }
 401               /* Map other parameters to their equivalents in the cloned
 402                  function.  */
 403               else
 404                 {
 405                   gcc_assert (clone_parm);
 406                   DECL_ABSTRACT_ORIGIN (clone_parm) = NULL;
 407                   args[parmno] = clone_parm;
 408                   /* Clear TREE_ADDRESSABLE on thunk arguments.  */
 409                   TREE_ADDRESSABLE (clone_parm) = 0;
 410                   clone_parm = TREE_CHAIN (clone_parm);
 411                 }
 412               if (fn_parm_typelist)
 413                 fn_parm_typelist = TREE_CHAIN (fn_parm_typelist);
 414             }
 415
 416           /* We built this list backwards; fix now.  */
 417           mark_used (fn);
 418           call = build_cxx_call (fn, parmno, args, tf_warning_or_error);
 419           /* Arguments passed to the thunk by invisible reference should
 420              be transmitted to the callee unchanged.  Do not create a
 421              temporary and invoke the copy constructor.  The thunking
 422              transformation must not introduce any constructor calls.  */
 423           CALL_FROM_THUNK_P (call) = 1;
 424           block = make_node (BLOCK);
 425           if (targetm.cxx.cdtor_returns_this ())
 426             {
 427               clone_result = DECL_RESULT (clone);
 428               modify = build2 (MODIFY_EXPR, TREE_TYPE (clone_result),
 429                                clone_result, call);
 430               modify = build1 (RETURN_EXPR, void_type_node, modify);
 431               add_stmt (modify);
 432             }
 433           else
 434             {
 435               add_stmt (call);
 436             }
 437           bind = c_build_bind_expr (DECL_SOURCE_LOCATION (clone),
 438                                     block, cur_stmt_list);
 439           DECL_SAVED_TREE (clone) = push_stmt_list ();
 440           add_stmt (bind);
 441         }
 442
 443       DECL_ABSTRACT_ORIGIN (clone) = NULL;
 444       expand_or_defer_fn (finish_function (/*inline_p=*/false));
 445     }
 446   return 1;
 447 }
 448
 449 /* FN is a function that has a complete body.  Clone the body as
 450    necessary.  Returns nonzero if there's no longer any need to
 451    process the main body.  */
 452
 453 bool
 454 maybe_clone_body (tree fn)
 455 {
 456   tree comdat_group = NULL_TREE;
 457   tree clone;
 458   tree fns[3];
 459   bool first = true;
 460   int idx;
 461   bool need_alias = false;
 462
 463   /* We only clone constructors and destructors.  */
 464   if (!DECL_MAYBE_IN_CHARGE_CDTOR_P (fn))
 465     return 0;
 466
 467   populate_clone_array (fn, fns);
 468
 469   /* Remember if we can't have multiple clones for some reason.  We need to
 470      check this before we remap local static initializers in clone_body.  */
 471   if (!tree_versionable_function_p (fn))
 472     need_alias = true;
 473
 474   /* We know that any clones immediately follow FN in the TYPE_FIELDS
 475      list.  */
 476   push_to_top_level ();
 477   for (idx = 0; idx < 3; idx++)
 478     {
 479       tree parm;
 480       tree clone_parm;
 481
 482       clone = fns[idx];
 483       if (!clone)
 484         continue;
 485
 486       /* Update CLONE's source position information to match FN's.  */
 487       DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
 488       DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
 489       DECL_DECLARED_CONSTEXPR_P (clone) = DECL_DECLARED_CONSTEXPR_P (fn);
 490       DECL_COMDAT (clone) = DECL_COMDAT (fn);
 491       DECL_WEAK (clone) = DECL_WEAK (fn);
 492
 493       /* We don't copy the comdat group from fn to clone because the assembler
 494          name of fn was corrupted by write_mangled_name by adding *INTERNAL*
 495          to it. By doing so, it also corrupted the comdat group. */
 496       if (DECL_ONE_ONLY (fn))
 497         cgraph_node::get_create (clone)->set_comdat_group (cxx_comdat_group (clone));
 498       DECL_USE_TEMPLATE (clone) = DECL_USE_TEMPLATE (fn);
 499       DECL_EXTERNAL (clone) = DECL_EXTERNAL (fn);
 500       DECL_INTERFACE_KNOWN (clone) = DECL_INTERFACE_KNOWN (fn);
 501       DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
 502       TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
 503       DECL_VISIBILITY (clone) = DECL_VISIBILITY (fn);
 504       DECL_VISIBILITY_SPECIFIED (clone) = DECL_VISIBILITY_SPECIFIED (fn);
 505       DECL_DLLIMPORT_P (clone) = DECL_DLLIMPORT_P (fn);
 506       DECL_ATTRIBUTES (clone) = copy_list (DECL_ATTRIBUTES (fn));
 507       DECL_DISREGARD_INLINE_LIMITS (clone) = DECL_DISREGARD_INLINE_LIMITS (fn);
 508       set_decl_section_name (clone, fn);
 509
 510       /* Adjust the parameter names and locations.  */
 511       parm = DECL_ARGUMENTS (fn);
 512       clone_parm = DECL_ARGUMENTS (clone);
 513       /* Update the `this' parameter, which is always first.  */
 514       update_cloned_parm (parm, clone_parm, first);
 515       parm = DECL_CHAIN (parm);
 516       clone_parm = DECL_CHAIN (clone_parm);
 517       if (DECL_HAS_IN_CHARGE_PARM_P (fn))
 518         parm = DECL_CHAIN (parm);
 519       if (DECL_HAS_VTT_PARM_P (fn))
 520         parm = DECL_CHAIN (parm);
 521       if (DECL_HAS_VTT_PARM_P (clone))
 522         clone_parm = DECL_CHAIN (clone_parm);
 523       for (; parm && clone_parm;
 524            parm = DECL_CHAIN (parm), clone_parm = DECL_CHAIN (clone_parm))
 525         /* Update this parameter.  */
 526         update_cloned_parm (parm, clone_parm, first);
 527     }
 528
 529   bool can_alias = can_alias_cdtor (fn);
 530
 531   /* If we decide to turn clones into thunks, they will branch to fn.
 532      Must have original function available to call.  */
 533   if (!can_alias && maybe_thunk_body (fn, need_alias))
 534     {
 535       pop_from_top_level ();
 536       /* We still need to emit the original function.  */
 537       return 0;
 538     }
 539
 540   /* Emit the DWARF1 abstract instance.  */
 541   (*debug_hooks->deferred_inline_function) (fn);
 542
 543   /* We know that any clones immediately follow FN in the TYPE_FIELDS. */
 544   for (idx = 0; idx < 3; idx++)
 545     {
 546       tree parm;
 547       tree clone_parm;
 548       int parmno;
 549       hash_map<tree, tree> *decl_map;
 550       bool alias = false;
 551
 552       clone = fns[idx];
 553       if (!clone)
 554         continue;
 555
 556       /* Start processing the function.  */
 557       start_preparsed_function (clone, NULL_TREE, SF_PRE_PARSED);
 558
 559       /* Tell cgraph if both ctors or both dtors are known to have
 560          the same body.  */
 561       if (can_alias
 562           && fns[0]
 563           && idx == 1
 564           && cgraph_node::get_create (fns[0])->create_same_body_alias
 565                (clone, fns[0]))
 566         {
 567           alias = true;
 568           if (DECL_ONE_ONLY (fns[0]))
 569             {
 570               /* For comdat base and complete cdtors put them
 571                  into the same, *[CD]5* comdat group instead of
 572                  *[CD][12]*.  */
 573               comdat_group = cdtor_comdat_group (fns[1], fns[0]);
 574               cgraph_node::get_create (fns[0])->set_comdat_group (comdat_group);
 575               if (symtab_node::get (clone)->same_comdat_group)
 576                 symtab_node::get (clone)->remove_from_same_comdat_group ();
 577               symtab_node::get (clone)->add_to_same_comdat_group
 578                 (symtab_node::get (fns[0]));
 579             }
 580         }
 581
 582       /* Build the delete destructor by calling complete destructor
 583          and delete function.  */
 584       if (idx == 2)
 585         {
 586           build_delete_destructor_body (clone, fns[1]);
 587           /* If *[CD][12]* dtors go into the *[CD]5* comdat group and dtor is
 588              virtual, it goes into the same comdat group as well.  */
 589           if (comdat_group)
 590             cgraph_node::get_create (clone)->add_to_same_comdat_group
 591               (symtab_node::get (fns[0]));
 592         }
 593       else if (alias)
 594         /* No need to populate body.  */ ;
 595       else
 596         {
 597           /* If we can't have multiple copies of FN (say, because there's a
 598              static local initialized with the address of a label), we need
 599              to use an alias for the complete variant.  */
 600           if (idx == 1 && need_alias)
 601             {
 602               if (DECL_STRUCT_FUNCTION (fn)->cannot_be_copied_set)
 603                 sorry (DECL_STRUCT_FUNCTION (fn)->cannot_be_copied_reason, fn);
 604               else
 605                 sorry ("making multiple clones of %qD", fn);
 606             }
 607
 608           /* Remap the parameters.  */
 609           decl_map = new hash_map<tree, tree>;
 610           for (parmno = 0,
 611                 parm = DECL_ARGUMENTS (fn),
 612                 clone_parm = DECL_ARGUMENTS (clone);
 613               parm;
 614               ++parmno,
 615                 parm = DECL_CHAIN (parm))
 616             {
 617               /* Map the in-charge parameter to an appropriate constant.  */
 618               if (DECL_HAS_IN_CHARGE_PARM_P (fn) && parmno == 1)
 619                 {
 620                   tree in_charge;
 621                   in_charge = in_charge_arg_for_name (DECL_NAME (clone));
 622                   decl_map->put (parm, in_charge);
 623                 }
 624               else if (DECL_ARTIFICIAL (parm)
 625                        && DECL_NAME (parm) == vtt_parm_identifier)
 626                 {
 627                   /* For a subobject constructor or destructor, the next
 628                      argument is the VTT parameter.  Remap the VTT_PARM
 629                      from the CLONE to this parameter.  */
 630                   if (DECL_HAS_VTT_PARM_P (clone))
 631                     {
 632                       DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
 633                       decl_map->put (parm, clone_parm);
 634                       clone_parm = DECL_CHAIN (clone_parm);
 635                     }
 636                   /* Otherwise, map the VTT parameter to `NULL'.  */
 637                   else
 638                     {
 639                       tree t
 640                         = fold_convert (TREE_TYPE (parm), null_pointer_node);
 641                       decl_map->put (parm, t);
 642                     }
 643                 }
 644               /* Map other parameters to their equivalents in the cloned
 645                  function.  */
 646               else
 647                 {
 648                   tree replacement;
 649                   if (clone_parm)
 650                     {
 651                       replacement = clone_parm;
 652                       clone_parm = DECL_CHAIN (clone_parm);
 653                     }
 654                   else
 655                     {
 656                       /* Inheriting ctors can omit parameters from the base
 657                          clone.  Replace them with null lvalues.  */
 658                       tree reftype = build_reference_type (TREE_TYPE (parm));
 659                       replacement = fold_convert (reftype, null_pointer_node);
 660                       replacement = convert_from_reference (replacement);
 661                     }
 662                   decl_map->put (parm, replacement);
 663                 }
 664             }
 665
 666           if (targetm.cxx.cdtor_returns_this ())
 667             {
 668               parm = DECL_RESULT (fn);
 669               clone_parm = DECL_RESULT (clone);
 670               decl_map->put (parm, clone_parm);
 671             }
 672
 673           /* Clone the body.  */
 674           clone_body (clone, fn, decl_map);
 675
 676           /* Clean up.  */
 677           delete decl_map;
 678         }
 679
 680       /* The clone can throw iff the original function can throw.  */
 681       cp_function_chain->can_throw = !TREE_NOTHROW (fn);
 682
 683       /* Now, expand this function into RTL, if appropriate.  */
 684       finish_function (/*inline_p=*/false);
 685       BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
 686       if (alias)
 687         {
 688           if (expand_or_defer_fn_1 (clone))
 689             emit_associated_thunks (clone);
 690           /* We didn't generate a body, so remove the empty one.  */
 691           DECL_SAVED_TREE (clone) = NULL_TREE;
 692         }
 693       else
 694         expand_or_defer_fn (clone);
 695       first = false;
 696     }
 697   pop_from_top_level ();
 698
 699   /* We don't need to process the original function any further.  */
 700   return 1;
 701 }