gcc/cp/optimize.c

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