gcc/cp/method.c

   1 /* Handle the hair of processing (but not expanding) inline functions.
   2    Also manage function and variable name overloading.
   3    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24
  25 /* Handle method declarations.  */
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "cp-tree.h"
  32 #include "rtl.h"
  33 #include "expr.h"
  34 #include "output.h"
  35 #include "flags.h"
  36 #include "toplev.h"
  37 #include "tm_p.h"
  38 #include "target.h"
  39
  40 /* Various flags to control the mangling process.  */
  41
  42 enum mangling_flags
  43 {
  44   /* No flags.  */
  45   mf_none = 0,
  46   /* The thing we are presently mangling is part of a template type,
  47      rather than a fully instantiated type.  Therefore, we may see
  48      complex expressions where we would normally expect to see a
  49      simple integer constant.  */
  50   mf_maybe_uninstantiated = 1,
  51   /* When mangling a numeric value, use the form `_XX_' (instead of
  52      just `XX') if the value has more than one digit.  */
  53   mf_use_underscores_around_value = 2
  54 };
  55
  56 typedef enum mangling_flags mangling_flags;
  57
  58 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
  59 static void do_build_assign_ref (tree);
  60 static void do_build_copy_constructor (tree);
  61 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
  62 static tree locate_dtor (tree, void *);
  63 static tree locate_ctor (tree, void *);
  64 static tree locate_copy (tree, void *);
  65 #ifdef ASM_OUTPUT_DEF
  66 static tree make_alias_for_thunk (tree);
  67 #endif
  68
  69 /* Called once to initialize method.c.  */
  70
  71 void
  72 init_method (void)
  73 {
  74   init_mangle ();
  75 }
  76
  77 \f
  78 /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL.  */
  79
  80 void
  81 set_mangled_name_for_decl (tree decl)
  82 {
  83   if (processing_template_decl)
  84     /* There's no need to mangle the name of a template function.  */
  85     return;
  86
  87   mangle_decl (decl);
  88 }
  89
  90 \f
  91 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  92    indicates whether it is a this or result adjusting thunk.
  93    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  94    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  95    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  96    adjusting thunks, we scale it to a byte offset. For covariant
  97    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  98    the returned thunk with finish_thunk.  */
  99
 100 tree
 101 make_thunk (tree function, bool this_adjusting,
 102             tree fixed_offset, tree virtual_offset)
 103 {
 104   HOST_WIDE_INT d;
 105   tree thunk;
 106
 107   my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 20021025);
 108   /* We can have this thunks to covariant thunks, but not vice versa.  */
 109   my_friendly_assert (!DECL_THIS_THUNK_P (function), 20021127);
 110
 111   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
 112   if (this_adjusting && virtual_offset)
 113     virtual_offset
 114       = size_binop (MULT_EXPR,
 115                     virtual_offset,
 116                     convert (ssizetype,
 117                              TYPE_SIZE_UNIT (vtable_entry_type)));
 118
 119   d = tree_low_cst (fixed_offset, 0);
 120
 121   /* See if we already have the thunk in question.  For this_adjusting
 122      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
 123      will be a BINFO.  */
 124   for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
 125     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
 126         && THUNK_FIXED_OFFSET (thunk) == d
 127         && (this_adjusting
 128             ? (!THUNK_VIRTUAL_OFFSET (thunk) == !virtual_offset
 129                && (!virtual_offset
 130                    || tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
 131                                           virtual_offset)))
 132             : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset))
 133       return thunk;
 134
 135   /* All thunks must be created before FUNCTION is actually emitted;
 136      the ABI requires that all thunks be emitted together with the
 137      function to which they transfer control.  */
 138   my_friendly_assert (!TREE_ASM_WRITTEN (function), 20021025);
 139
 140   thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
 141   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
 142   cxx_dup_lang_specific_decl (thunk);
 143   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
 144   TREE_READONLY (thunk) = TREE_READONLY (function);
 145   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
 146   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
 147   if (flag_weak)
 148     comdat_linkage (thunk);
 149   SET_DECL_THUNK_P (thunk, this_adjusting);
 150   THUNK_TARGET (thunk) = function;
 151   THUNK_FIXED_OFFSET (thunk) = d;
 152   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 153
 154   /* The thunk itself is not a constructor or destructor, even if
 155      the thing it is thunking to is.  */
 156   DECL_INTERFACE_KNOWN (thunk) = 1;
 157   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 158   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 159   DECL_DESTRUCTOR_P (thunk) = 0;
 160   DECL_CONSTRUCTOR_P (thunk) = 0;
 161   /* And neither is it a clone.  */
 162   DECL_CLONED_FUNCTION (thunk) = NULL_TREE;
 163   DECL_EXTERNAL (thunk) = 1;
 164   DECL_ARTIFICIAL (thunk) = 1;
 165   /* Even if this thunk is a member of a local class, we don't
 166      need a static chain.  */
 167   DECL_NO_STATIC_CHAIN (thunk) = 1;
 168   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 169   DECL_PENDING_INLINE_P (thunk) = 0;
 170   DECL_INLINE (thunk) = 0;
 171   DECL_DECLARED_INLINE_P (thunk) = 0;
 172   /* Nor has it been deferred.  */
 173   DECL_DEFERRED_FN (thunk) = 0;
 174   /* Add it to the list of thunks associated with FUNCTION.  */
 175   TREE_CHAIN (thunk) = DECL_THUNKS (function);
 176   DECL_THUNKS (function) = thunk;
 177
 178   return thunk;
 179 }
 180
 181 /* Finish THUNK, a thunk decl.  */
 182
 183 void
 184 finish_thunk (tree thunk)
 185 {
 186   tree function, name;
 187   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 188   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 189
 190   my_friendly_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk), 20021127);
 191   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 192     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 193   function = THUNK_TARGET (thunk);
 194   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 195                        fixed_offset, virtual_offset);
 196   DECL_NAME (thunk) = name;
 197   SET_DECL_ASSEMBLER_NAME (thunk, name);
 198 }
 199
 200 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
 201    offset indicated by VIRTUAL_OFFSET, if that is
 202    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
 203    zero for a result adjusting thunk.  */
 204
 205 static tree
 206 thunk_adjust (tree ptr, bool this_adjusting,
 207               HOST_WIDE_INT fixed_offset, tree virtual_offset)
 208 {
 209   if (this_adjusting)
 210     /* Adjust the pointer by the constant.  */
 211     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 212                        ssize_int (fixed_offset)));
 213
 214   /* If there's a virtual offset, look up that value in the vtable and
 215      adjust the pointer again.  */
 216   if (virtual_offset)
 217     {
 218       tree vtable;
 219
 220       ptr = save_expr (ptr);
 221       /* The vptr is always at offset zero in the object.  */
 222       vtable = build1 (NOP_EXPR,
 223                        build_pointer_type (build_pointer_type
 224                                            (vtable_entry_type)),
 225                        ptr);
 226       /* Form the vtable address.  */
 227       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 228       /* Find the entry with the vcall offset.  */
 229       vtable = build (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
 230       /* Get the offset itself.  */
 231       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 232       /* Adjust the `this' pointer.  */
 233       ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable));
 234     }
 235
 236   if (!this_adjusting)
 237     /* Adjust the pointer by the constant.  */
 238     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 239                        ssize_int (fixed_offset)));
 240
 241   return ptr;
 242 }
 243
 244 /* Garbage collector tables contains thunk_labelno even when places
 245    inside ifdef block.  */
 246 static GTY (()) int thunk_labelno;
 247 #ifdef ASM_OUTPUT_DEF
 248
 249 /* Create a static alias to function.  */
 250
 251 static tree
 252 make_alias_for_thunk (tree function)
 253 {
 254   tree alias;
 255   char buf[256];
 256
 257   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
 258   thunk_labelno++;
 259   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
 260                       TREE_TYPE (function));
 261   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
 262   cxx_dup_lang_specific_decl (alias);
 263   DECL_CONTEXT (alias) = NULL;
 264   TREE_READONLY (alias) = TREE_READONLY (function);
 265   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
 266   TREE_PUBLIC (alias) = 0;
 267   DECL_INTERFACE_KNOWN (alias) = 1;
 268   DECL_NOT_REALLY_EXTERN (alias) = 1;
 269   DECL_THIS_STATIC (alias) = 1;
 270   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 271   DECL_DESTRUCTOR_P (alias) = 0;
 272   DECL_CONSTRUCTOR_P (alias) = 0;
 273   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
 274   DECL_EXTERNAL (alias) = 0;
 275   DECL_ARTIFICIAL (alias) = 1;
 276   DECL_NO_STATIC_CHAIN (alias) = 1;
 277   DECL_PENDING_INLINE_P (alias) = 0;
 278   DECL_INLINE (alias) = 0;
 279   DECL_DECLARED_INLINE_P (alias) = 0;
 280   DECL_DEFERRED_FN (alias) = 0;
 281   DECL_USE_TEMPLATE (alias) = 0;
 282   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 283   DECL_TEMPLATE_INFO (alias) = NULL;
 284   DECL_INITIAL (alias) = error_mark_node;
 285   TREE_ADDRESSABLE (alias) = 1;
 286   TREE_USED (alias) = 1;
 287   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 288   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
 289   if (!flag_syntax_only)
 290     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
 291   return alias;
 292 }
 293 #endif
 294
 295 /* Emit the definition of a C++ multiple inheritance or covariant
 296    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 297    immediately.  */
 298
 299 void
 300 use_thunk (tree thunk_fndecl, bool emit_p)
 301 {
 302   tree function, alias;
 303   tree virtual_offset;
 304   HOST_WIDE_INT fixed_offset, virtual_value;
 305   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 306
 307   /* We should have called finish_thunk to give it a name.  */
 308   my_friendly_assert (DECL_NAME (thunk_fndecl), 20021127);
 309
 310   if (TREE_ASM_WRITTEN (thunk_fndecl))
 311     return;
 312
 313   function = THUNK_TARGET (thunk_fndecl);
 314   if (DECL_RESULT (thunk_fndecl))
 315     /* We already turned this thunk into an ordinary function.
 316        There's no need to process this thunk again.  */
 317     return;
 318
 319   /* Thunks are always addressable; they only appear in vtables.  */
 320   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 321
 322   /* Figure out what function is being thunked to.  It's referenced in
 323      this translation unit.  */
 324   TREE_ADDRESSABLE (function) = 1;
 325   mark_used (function);
 326   mark_referenced (DECL_ASSEMBLER_NAME (function));
 327   if (!emit_p)
 328     return;
 329
 330 #ifdef ASM_OUTPUT_DEF
 331   alias = make_alias_for_thunk (function);
 332 #else
 333   alias = function;
 334 #endif
 335
 336   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 337   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 338
 339   if (virtual_offset)
 340     {
 341       if (!this_adjusting)
 342         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 343       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
 344       my_friendly_assert (virtual_value, 20021026);
 345     }
 346   else
 347     virtual_value = 0;
 348
 349   /* And, if we need to emit the thunk, it's used.  */
 350   mark_used (thunk_fndecl);
 351   /* This thunk is actually defined.  */
 352   DECL_EXTERNAL (thunk_fndecl) = 0;
 353   /* The linkage of the function may have changed.  FIXME in linkage
 354      rewrite.  */
 355   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 356
 357   if (flag_syntax_only)
 358     {
 359       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 360       return;
 361     }
 362
 363   push_to_top_level ();
 364
 365 #ifdef ASM_OUTPUT_DEF
 366   if (targetm.have_named_sections)
 367     {
 368       resolve_unique_section (function, 0, flag_function_sections);
 369
 370       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
 371         {
 372           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 373
 374           /* Output the thunk into the same section as function.  */
 375           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
 376         }
 377     }
 378 #endif
 379
 380   /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
 381      create one.  */
 382   DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
 383   BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = DECL_ARGUMENTS (thunk_fndecl);
 384
 385   if (this_adjusting
 386       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
 387                                               virtual_value, alias))
 388     {
 389       const char *fnname;
 390       current_function_decl = thunk_fndecl;
 391       DECL_RESULT (thunk_fndecl)
 392         = build_decl (RESULT_DECL, 0, integer_type_node);
 393       fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
 394       init_function_start (thunk_fndecl);
 395       current_function_is_thunk = 1;
 396       assemble_start_function (thunk_fndecl, fnname);
 397
 398       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
 399                                        fixed_offset, virtual_value, alias);
 400
 401       assemble_end_function (thunk_fndecl, fnname);
 402       current_function_decl = 0;
 403       cfun = 0;
 404       /* Because init_function_start increments this, we must
 405          decrement it.  */
 406       immediate_size_expand--;
 407       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 408     }
 409   else
 410     {
 411       /* If this is a covariant thunk, or we don't have the necessary
 412          code for efficient thunks, generate a thunk function that
 413          just makes a call to the real function.  Unfortunately, this
 414          doesn't work for varargs.  */
 415
 416       tree a, t;
 417
 418       if (varargs_function_p (function))
 419         error ("generic thunk code fails for method `%#D' which uses `...'",
 420                function);
 421
 422       /* Set up cloned argument trees for the thunk.  */
 423       t = NULL_TREE;
 424       for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 425         {
 426           tree x = copy_node (a);
 427           TREE_CHAIN (x) = t;
 428           DECL_CONTEXT (x) = thunk_fndecl;
 429           SET_DECL_RTL (x, NULL_RTX);
 430           t = x;
 431         }
 432       a = nreverse (t);
 433       DECL_ARGUMENTS (thunk_fndecl) = a;
 434       DECL_RESULT (thunk_fndecl) = NULL_TREE;
 435
 436       start_function (NULL_TREE, thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
 437       /* We don't bother with a body block for thunks.  */
 438
 439       /* There's no need to check accessibility inside the thunk body.  */
 440       push_deferring_access_checks (dk_no_check);
 441
 442       t = a;
 443       if (this_adjusting)
 444         t = thunk_adjust (t, /*this_adjusting=*/1,
 445                           fixed_offset, virtual_offset);
 446
 447       /* Build up the call to the real function.  */
 448       t = tree_cons (NULL_TREE, t, NULL_TREE);
 449       for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
 450         t = tree_cons (NULL_TREE, a, t);
 451       t = nreverse (t);
 452       t = build_call (alias, t);
 453       if (!this_adjusting)
 454         t = thunk_adjust (t, /*this_adjusting=*/0,
 455                           fixed_offset, virtual_offset);
 456
 457       if (VOID_TYPE_P (TREE_TYPE (t)))
 458         finish_expr_stmt (t);
 459       else
 460         finish_return_stmt (t);
 461
 462       /* Since we want to emit the thunk, we explicitly mark its name as
 463          referenced.  */
 464       mark_referenced (DECL_ASSEMBLER_NAME (thunk_fndecl));
 465
 466       /* But we don't want debugging information about it.  */
 467       DECL_IGNORED_P (thunk_fndecl) = 1;
 468
 469       /* Re-enable access control.  */
 470       pop_deferring_access_checks ();
 471
 472       expand_body (finish_function (0));
 473     }
 474
 475   pop_from_top_level ();
 476 }
 477 \f
 478 /* Code for synthesizing methods which have default semantics defined.  */
 479
 480 /* Generate code for default X(X&) constructor.  */
 481
 482 static void
 483 do_build_copy_constructor (tree fndecl)
 484 {
 485   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 486   tree t;
 487
 488   parm = convert_from_reference (parm);
 489
 490   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 491       && is_empty_class (current_class_type))
 492     /* Don't copy the padding byte; it might not have been allocated
 493        if *this is a base subobject.  */;
 494   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 495     {
 496       t = build (INIT_EXPR, void_type_node, current_class_ref, parm);
 497       finish_expr_stmt (t);
 498     }
 499   else
 500     {
 501       tree fields = TYPE_FIELDS (current_class_type);
 502       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 503       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 504       tree member_init_list = NULL_TREE;
 505       int cvquals = cp_type_quals (TREE_TYPE (parm));
 506       int i;
 507
 508       /* Initialize all the base-classes with the parameter converted
 509          to their type so that we get their copy constructor and not
 510          another constructor that takes current_class_type.  We must
 511          deal with the binfo's directly as a direct base might be
 512          inaccessible due to ambiguity.  */
 513       for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
 514            t = TREE_CHAIN (t))
 515         {
 516           tree binfo = TREE_VALUE (t);
 517
 518           member_init_list
 519             = tree_cons (binfo,
 520                          build_tree_list (NULL_TREE,
 521                                           build_base_path (PLUS_EXPR, parm,
 522                                                            binfo, 1)),
 523                          member_init_list);
 524         }
 525
 526       for (i = 0; i < n_bases; ++i)
 527         {
 528           tree binfo = TREE_VEC_ELT (binfos, i);
 529           if (TREE_VIA_VIRTUAL (binfo))
 530             continue;
 531
 532           member_init_list
 533             = tree_cons (binfo,
 534                          build_tree_list (NULL_TREE,
 535                                           build_base_path (PLUS_EXPR, parm,
 536                                                            binfo, 1)),
 537                          member_init_list);
 538         }
 539
 540       for (; fields; fields = TREE_CHAIN (fields))
 541         {
 542           tree init;
 543           tree field = fields;
 544           tree expr_type;
 545
 546           if (TREE_CODE (field) != FIELD_DECL)
 547             continue;
 548
 549           init = parm;
 550           if (DECL_NAME (field))
 551             {
 552               if (VFIELD_NAME_P (DECL_NAME (field)))
 553                 continue;
 554
 555               /* True for duplicate members.  */
 556               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 557                 continue;
 558             }
 559           else if ((t = TREE_TYPE (field)) != NULL_TREE
 560                    && ANON_AGGR_TYPE_P (t)
 561                    && TYPE_FIELDS (t) != NULL_TREE)
 562             /* Just use the field; anonymous types can't have
 563                nontrivial copy ctors or assignment ops.  */;
 564           else
 565             continue;
 566
 567           /* Compute the type of "init->field".  If the copy-constructor
 568              parameter is, for example, "const S&", and the type of
 569              the field is "T", then the type will usually be "const
 570              T".  (There are no cv-qualified variants of reference
 571              types.)  */
 572           expr_type = TREE_TYPE (field);
 573           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
 574             expr_type = cp_build_qualified_type (expr_type, cvquals);
 575           init = build (COMPONENT_REF, expr_type, init, field);
 576           init = build_tree_list (NULL_TREE, init);
 577
 578           member_init_list
 579             = tree_cons (field, init, member_init_list);
 580         }
 581       finish_mem_initializers (member_init_list);
 582     }
 583 }
 584
 585 static void
 586 do_build_assign_ref (tree fndecl)
 587 {
 588   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
 589   tree compound_stmt;
 590
 591   compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
 592   parm = convert_from_reference (parm);
 593
 594   if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
 595       && is_empty_class (current_class_type))
 596     /* Don't copy the padding byte; it might not have been allocated
 597        if *this is a base subobject.  */;
 598   else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
 599     {
 600       tree t = build (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 601       finish_expr_stmt (t);
 602     }
 603   else
 604     {
 605       tree fields;
 606       int cvquals = cp_type_quals (TREE_TYPE (parm));
 607       int i;
 608
 609       /* Assign to each of the direct base classes.  */
 610       for (i = 0; i < CLASSTYPE_N_BASECLASSES (current_class_type); ++i)
 611         {
 612           tree binfo;
 613           tree converted_parm;
 614
 615           binfo = BINFO_BASETYPE (TYPE_BINFO (current_class_type), i);
 616           /* We must convert PARM directly to the base class
 617              explicitly since the base class may be ambiguous.  */
 618           converted_parm = build_base_path (PLUS_EXPR, parm, binfo, 1);
 619           /* Call the base class assignment operator.  */
 620           finish_expr_stmt
 621             (build_special_member_call (current_class_ref,
 622                                         ansi_assopname (NOP_EXPR),
 623                                         build_tree_list (NULL_TREE,
 624                                                          converted_parm),
 625                                         binfo,
 626                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
 627         }
 628
 629       /* Assign to each of the non-static data members.  */
 630       for (fields = TYPE_FIELDS (current_class_type);
 631            fields;
 632            fields = TREE_CHAIN (fields))
 633         {
 634           tree comp, init, t;
 635           tree field = fields;
 636
 637           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 638             continue;
 639
 640           if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 641             {
 642               error ("non-static const member `%#D', can't use default assignment operator", field);
 643               continue;
 644             }
 645           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 646             {
 647               error ("non-static reference member `%#D', can't use default assignment operator", field);
 648               continue;
 649             }
 650
 651           comp = current_class_ref;
 652           init = parm;
 653
 654           if (DECL_NAME (field))
 655             {
 656               if (VFIELD_NAME_P (DECL_NAME (field)))
 657                 continue;
 658
 659               /* True for duplicate members.  */
 660               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 661                 continue;
 662             }
 663           else if ((t = TREE_TYPE (field)) != NULL_TREE
 664                    && ANON_AGGR_TYPE_P (t)
 665                    && TYPE_FIELDS (t) != NULL_TREE)
 666             /* Just use the field; anonymous types can't have
 667                nontrivial copy ctors or assignment ops.  */;
 668           else
 669             continue;
 670
 671           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field);
 672           init = build (COMPONENT_REF,
 673                         cp_build_qualified_type (TREE_TYPE (field), cvquals),
 674                         init, field);
 675
 676           if (DECL_NAME (field))
 677             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 678           else
 679             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 680                                      init));
 681         }
 682     }
 683   finish_return_stmt (current_class_ref);
 684   finish_compound_stmt (compound_stmt);
 685 }
 686
 687 void
 688 synthesize_method (tree fndecl)
 689 {
 690   bool nested = (current_function_decl != NULL_TREE);
 691   tree context = decl_function_context (fndecl);
 692   bool need_body = true;
 693   tree stmt;
 694
 695   if (at_eof)
 696     import_export_decl (fndecl);
 697
 698   /* If we've been asked to synthesize a clone, just synthesize the
 699      cloned function instead.  Doing so will automatically fill in the
 700      body for the clone.  */
 701   if (DECL_CLONED_FUNCTION_P (fndecl))
 702     {
 703       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 704       return;
 705     }
 706
 707   /* We may be in the middle of deferred access check.  Disable
 708      it now.  */
 709   push_deferring_access_checks (dk_no_deferred);
 710
 711   if (! context)
 712     push_to_top_level ();
 713   else if (nested)
 714     push_function_context_to (context);
 715
 716   /* Put the function definition at the position where it is needed,
 717      rather than within the body of the class.  That way, an error
 718      during the generation of the implicit body points at the place
 719      where the attempt to generate the function occurs, giving the
 720      user a hint as to why we are attempting to generate the
 721      function.  */
 722   DECL_SOURCE_LOCATION (fndecl) = input_location;
 723
 724   interface_unknown = 1;
 725   start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 726   clear_last_expr ();
 727   stmt = begin_function_body ();
 728
 729   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 730     {
 731       do_build_assign_ref (fndecl);
 732       need_body = false;
 733     }
 734   else if (DECL_CONSTRUCTOR_P (fndecl))
 735     {
 736       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 737       if (arg_chain != void_list_node)
 738         do_build_copy_constructor (fndecl);
 739       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 740         finish_mem_initializers (NULL_TREE);
 741     }
 742
 743   /* If we haven't yet generated the body of the function, just
 744      generate an empty compound statement.  */
 745   if (need_body)
 746     {
 747       tree compound_stmt;
 748       compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
 749       finish_compound_stmt (compound_stmt);
 750     }
 751
 752   finish_function_body (stmt);
 753   expand_or_defer_fn (finish_function (0));
 754
 755   extract_interface_info ();
 756   if (! context)
 757     pop_from_top_level ();
 758   else if (nested)
 759     pop_function_context_from (context);
 760
 761   pop_deferring_access_checks ();
 762 }
 763
 764 /* Use EXTRACTOR to locate the relevant function called for each base &
 765    class field of TYPE. CLIENT allows additional information to be passed
 766    to EXTRACTOR.  Generates the union of all exceptions generated by those
 767    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 768    variants yet, so we need to look at the main one.  */
 769
 770 static tree
 771 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 772                            void *client)
 773 {
 774   tree raises = empty_except_spec;
 775   tree fields = TYPE_FIELDS (type);
 776   int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
 777   tree binfos = TYPE_BINFO_BASETYPES (type);
 778
 779   for (i = 0; i != n_bases; i++)
 780     {
 781       tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 782       tree fn = (*extractor) (base, client);
 783       if (fn)
 784         {
 785           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 786
 787           raises = merge_exception_specifiers (raises, fn_raises);
 788         }
 789     }
 790   for (; fields; fields = TREE_CHAIN (fields))
 791     {
 792       tree type = TREE_TYPE (fields);
 793       tree fn;
 794
 795       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 796         continue;
 797       while (TREE_CODE (type) == ARRAY_TYPE)
 798         type = TREE_TYPE (type);
 799       if (TREE_CODE (type) != RECORD_TYPE)
 800         continue;
 801
 802       fn = (*extractor) (type, client);
 803       if (fn)
 804         {
 805           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 806
 807           raises = merge_exception_specifiers (raises, fn_raises);
 808         }
 809     }
 810   return raises;
 811 }
 812
 813 /* Locate the dtor of TYPE.  */
 814
 815 static tree
 816 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 817 {
 818   tree fns;
 819
 820   if (!TYPE_HAS_DESTRUCTOR (type))
 821     return NULL_TREE;
 822   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 823                       CLASSTYPE_DESTRUCTOR_SLOT);
 824   return fns;
 825 }
 826
 827 /* Locate the default ctor of TYPE.  */
 828
 829 static tree
 830 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 831 {
 832   tree fns;
 833
 834   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 835     return NULL_TREE;
 836
 837   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 838                       CLASSTYPE_CONSTRUCTOR_SLOT);
 839   for (; fns; fns = OVL_NEXT (fns))
 840     {
 841       tree fn = OVL_CURRENT (fns);
 842       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 843
 844       if (sufficient_parms_p (TREE_CHAIN (parms)))
 845         return fn;
 846     }
 847   return NULL_TREE;
 848 }
 849
 850 struct copy_data
 851 {
 852   tree name;
 853   int quals;
 854 };
 855
 856 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 857    points to a COPY_DATA holding the name (NULL for the ctor)
 858    and desired qualifiers of the source operand.  */
 859
 860 static tree
 861 locate_copy (tree type, void *client_)
 862 {
 863   struct copy_data *client = (struct copy_data *)client_;
 864   tree fns;
 865   int ix = -1;
 866   tree best = NULL_TREE;
 867   bool excess_p = false;
 868
 869   if (client->name)
 870     {
 871       if (TYPE_HAS_ASSIGN_REF (type))
 872         ix = lookup_fnfields_1 (type, client->name);
 873     }
 874   else if (TYPE_HAS_INIT_REF (type))
 875     ix = CLASSTYPE_CONSTRUCTOR_SLOT;
 876   if (ix < 0)
 877     return NULL_TREE;
 878   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix);
 879
 880   for (; fns; fns = OVL_NEXT (fns))
 881     {
 882       tree fn = OVL_CURRENT (fns);
 883       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 884       tree src_type;
 885       int excess;
 886       int quals;
 887
 888       parms = TREE_CHAIN (parms);
 889       if (!parms)
 890         continue;
 891       src_type = non_reference (TREE_VALUE (parms));
 892       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 893         continue;
 894       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 895         continue;
 896       quals = cp_type_quals (src_type);
 897       if (client->quals & ~quals)
 898         continue;
 899       excess = quals & ~client->quals;
 900       if (!best || (excess_p && !excess))
 901         {
 902           best = fn;
 903           excess_p = excess;
 904         }
 905       else
 906         /* Ambiguous */
 907         return NULL_TREE;
 908     }
 909   return best;
 910 }
 911
 912 /* Implicitly declare the special function indicated by KIND, as a
 913    member of TYPE.  For copy constructors and assignment operators,
 914    CONST_P indicates whether these functions should take a const
 915    reference argument or a non-const reference.  */
 916
 917 tree
 918 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 919 {
 920   tree declspecs = NULL_TREE;
 921   tree fn, args = NULL_TREE;
 922   tree raises = empty_except_spec;
 923   bool retref = false;
 924   bool has_parm = false;
 925   tree name = constructor_name (type);
 926
 927   switch (kind)
 928     {
 929     case sfk_destructor:
 930       /* Destructor.  */
 931       name = build_nt (BIT_NOT_EXPR, name);
 932       args = void_list_node;
 933       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 934       break;
 935
 936     case sfk_constructor:
 937       /* Default constructor.  */
 938       args = void_list_node;
 939       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 940       break;
 941
 942     case sfk_copy_constructor:
 943     case sfk_assignment_operator:
 944     {
 945       struct copy_data data;
 946       tree argtype = type;
 947
 948       has_parm = true;
 949       data.name = NULL;
 950       data.quals = 0;
 951       if (kind == sfk_assignment_operator)
 952         {
 953           retref = true;
 954           declspecs = build_tree_list (NULL_TREE, type);
 955
 956           name = ansi_assopname (NOP_EXPR);
 957           data.name = name;
 958         }
 959       if (const_p)
 960         {
 961           data.quals = TYPE_QUAL_CONST;
 962           argtype = build_qualified_type (argtype, TYPE_QUAL_CONST);
 963         }
 964
 965       argtype = build_reference_type (argtype);
 966       args = build_tree_list (hash_tree_chain (argtype, NULL_TREE),
 967                               get_identifier ("_ctor_arg"));
 968       args = tree_cons (NULL_TREE, args, void_list_node);
 969
 970       raises = synthesize_exception_spec (type, &locate_copy, &data);
 971       break;
 972     }
 973     default:
 974       abort ();
 975     }
 976
 977   TREE_PARMLIST (args) = 1;
 978
 979   {
 980     tree declarator = make_call_declarator (name, args, NULL_TREE, raises);
 981
 982     if (retref)
 983       declarator = build_nt (ADDR_EXPR, declarator);
 984
 985     fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
 986     if (has_parm)
 987       TREE_USED (FUNCTION_FIRST_USER_PARM (fn)) = 1;
 988   }
 989
 990   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 20000408);
 991
 992   DECL_ARTIFICIAL (fn) = 1;
 993   DECL_NOT_REALLY_EXTERN (fn) = 1;
 994   DECL_DECLARED_INLINE_P (fn) = 1;
 995   DECL_INLINE (fn) = 1;
 996   defer_fn (fn);
 997
 998   return fn;
 999 }
1000
1001 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1002    as there are artificial parms in FN.  */
1003
1004 tree
1005 skip_artificial_parms_for (tree fn, tree list)
1006 {
1007   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1008     list = TREE_CHAIN (list);
1009   else
1010     return list;
1011
1012   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1013     list = TREE_CHAIN (list);
1014   if (DECL_HAS_VTT_PARM_P (fn))
1015     list = TREE_CHAIN (list);
1016   return list;
1017 }
1018
1019 #include "gt-cp-method.h"