contrib/gcc-4.0/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, 2004, 2005 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 #include "diagnostic.h"
  40
  41 /* Various flags to control the mangling process.  */
  42
  43 enum mangling_flags
  44 {
  45   /* No flags.  */
  46   mf_none = 0,
  47   /* The thing we are presently mangling is part of a template type,
  48      rather than a fully instantiated type.  Therefore, we may see
  49      complex expressions where we would normally expect to see a
  50      simple integer constant.  */
  51   mf_maybe_uninstantiated = 1,
  52   /* When mangling a numeric value, use the form `_XX_' (instead of
  53      just `XX') if the value has more than one digit.  */
  54   mf_use_underscores_around_value = 2
  55 };
  56
  57 typedef enum mangling_flags mangling_flags;
  58
  59 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
  60 static void do_build_assign_ref (tree);
  61 static void do_build_copy_constructor (tree);
  62 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
  63 static tree locate_dtor (tree, void *);
  64 static tree locate_ctor (tree, void *);
  65 static tree locate_copy (tree, void *);
  66 static tree make_alias_for_thunk (tree);
  67
  68 /* Called once to initialize method.c.  */
  69
  70 void
  71 init_method (void)
  72 {
  73   init_mangle ();
  74 }
  75 \f
  76 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  77    indicates whether it is a this or result adjusting thunk.
  78    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  79    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  80    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  81    adjusting thunks, we scale it to a byte offset. For covariant
  82    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  83    the returned thunk with finish_thunk.  */
  84
  85 tree
  86 make_thunk (tree function, bool this_adjusting,
  87             tree fixed_offset, tree virtual_offset)
  88 {
  89   HOST_WIDE_INT d;
  90   tree thunk;
  91
  92   gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
  93   /* We can have this thunks to covariant thunks, but not vice versa.  */
  94   gcc_assert (!DECL_THIS_THUNK_P (function));
  95   gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
  96
  97   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
  98   if (this_adjusting && virtual_offset)
  99     virtual_offset
 100       = size_binop (MULT_EXPR,
 101                     virtual_offset,
 102                     convert (ssizetype,
 103                              TYPE_SIZE_UNIT (vtable_entry_type)));
 104
 105   d = tree_low_cst (fixed_offset, 0);
 106
 107   /* See if we already have the thunk in question.  For this_adjusting
 108      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
 109      will be a BINFO.  */
 110   for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
 111     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
 112         && THUNK_FIXED_OFFSET (thunk) == d
 113         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
 114         && (!virtual_offset
 115             || (this_adjusting
 116                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
 117                                       virtual_offset)
 118                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
 119       return thunk;
 120
 121   /* All thunks must be created before FUNCTION is actually emitted;
 122      the ABI requires that all thunks be emitted together with the
 123      function to which they transfer control.  */
 124   gcc_assert (!TREE_ASM_WRITTEN (function));
 125   /* Likewise, we can only be adding thunks to a function declared in
 126      the class currently being laid out.  */
 127   gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
 128               && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
 129
 130   thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
 131   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
 132   cxx_dup_lang_specific_decl (thunk);
 133   DECL_THUNKS (thunk) = NULL_TREE;
 134
 135   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
 136   TREE_READONLY (thunk) = TREE_READONLY (function);
 137   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
 138   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
 139   if (flag_weak)
 140     comdat_linkage (thunk);
 141   SET_DECL_THUNK_P (thunk, this_adjusting);
 142   THUNK_TARGET (thunk) = function;
 143   THUNK_FIXED_OFFSET (thunk) = d;
 144   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 145   THUNK_ALIAS (thunk) = NULL_TREE;
 146
 147   /* The thunk itself is not a constructor or destructor, even if
 148      the thing it is thunking to is.  */
 149   DECL_INTERFACE_KNOWN (thunk) = 1;
 150   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 151   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 152   DECL_DESTRUCTOR_P (thunk) = 0;
 153   DECL_CONSTRUCTOR_P (thunk) = 0;
 154   DECL_EXTERNAL (thunk) = 1;
 155   DECL_ARTIFICIAL (thunk) = 1;
 156   /* Even if this thunk is a member of a local class, we don't
 157      need a static chain.  */
 158   DECL_NO_STATIC_CHAIN (thunk) = 1;
 159   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 160   DECL_PENDING_INLINE_P (thunk) = 0;
 161   DECL_INLINE (thunk) = 0;
 162   DECL_DECLARED_INLINE_P (thunk) = 0;
 163   /* Nor has it been deferred.  */
 164   DECL_DEFERRED_FN (thunk) = 0;
 165
 166   /* Add it to the list of thunks associated with FUNCTION.  */
 167   TREE_CHAIN (thunk) = DECL_THUNKS (function);
 168   DECL_THUNKS (function) = thunk;
 169
 170   return thunk;
 171 }
 172
 173 /* Finish THUNK, a thunk decl.  */
 174
 175 void
 176 finish_thunk (tree thunk)
 177 {
 178   tree function, name;
 179   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 180   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 181
 182   gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
 183   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 184     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 185   function = THUNK_TARGET (thunk);
 186   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 187                        fixed_offset, virtual_offset);
 188
 189   /* We can end up with declarations of (logically) different
 190      covariant thunks, that do identical adjustments.  The two thunks
 191      will be adjusting between within different hierarchies, which
 192      happen to have the same layout.  We must nullify one of them to
 193      refer to the other.  */
 194   if (DECL_RESULT_THUNK_P (thunk))
 195     {
 196       tree cov_probe;
 197
 198       for (cov_probe = DECL_THUNKS (function);
 199            cov_probe; cov_probe = TREE_CHAIN (cov_probe))
 200         if (DECL_NAME (cov_probe) == name)
 201           {
 202             gcc_assert (!DECL_THUNKS (thunk));
 203             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 204                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 205             break;
 206           }
 207     }
 208
 209   DECL_NAME (thunk) = name;
 210   SET_DECL_ASSEMBLER_NAME (thunk, name);
 211 }
 212
 213 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
 214    offset indicated by VIRTUAL_OFFSET, if that is
 215    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
 216    zero for a result adjusting thunk.  */
 217
 218 static tree
 219 thunk_adjust (tree ptr, bool this_adjusting,
 220               HOST_WIDE_INT fixed_offset, tree virtual_offset)
 221 {
 222   if (this_adjusting)
 223     /* Adjust the pointer by the constant.  */
 224     ptr = fold (build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 225                         ssize_int (fixed_offset)));
 226
 227   /* If there's a virtual offset, look up that value in the vtable and
 228      adjust the pointer again.  */
 229   if (virtual_offset)
 230     {
 231       tree vtable;
 232
 233       ptr = save_expr (ptr);
 234       /* The vptr is always at offset zero in the object.  */
 235       vtable = build1 (NOP_EXPR,
 236                        build_pointer_type (build_pointer_type
 237                                            (vtable_entry_type)),
 238                        ptr);
 239       /* Form the vtable address.  */
 240       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 241       /* Find the entry with the vcall offset.  */
 242       vtable = build2 (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
 243       /* Get the offset itself.  */
 244       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 245       /* Adjust the `this' pointer.  */
 246       ptr = fold (build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable));
 247     }
 248
 249   if (!this_adjusting)
 250     /* Adjust the pointer by the constant.  */
 251     ptr = fold (build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 252                         ssize_int (fixed_offset)));
 253
 254   return ptr;
 255 }
 256
 257 static GTY (()) int thunk_labelno;
 258
 259 /* Create a static alias to function.  */
 260
 261 static tree
 262 make_alias_for_thunk (tree function)
 263 {
 264   tree alias;
 265   char buf[256];
 266
 267   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
 268   thunk_labelno++;
 269   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
 270                       TREE_TYPE (function));
 271   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
 272   cxx_dup_lang_specific_decl (alias);
 273   DECL_CONTEXT (alias) = NULL;
 274   TREE_READONLY (alias) = TREE_READONLY (function);
 275   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
 276   TREE_PUBLIC (alias) = 0;
 277   DECL_INTERFACE_KNOWN (alias) = 1;
 278   DECL_NOT_REALLY_EXTERN (alias) = 1;
 279   DECL_THIS_STATIC (alias) = 1;
 280   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 281   DECL_DESTRUCTOR_P (alias) = 0;
 282   DECL_CONSTRUCTOR_P (alias) = 0;
 283   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
 284   DECL_EXTERNAL (alias) = 0;
 285   DECL_ARTIFICIAL (alias) = 1;
 286   DECL_NO_STATIC_CHAIN (alias) = 1;
 287   DECL_PENDING_INLINE_P (alias) = 0;
 288   DECL_INLINE (alias) = 0;
 289   DECL_DECLARED_INLINE_P (alias) = 0;
 290   DECL_DEFERRED_FN (alias) = 0;
 291   DECL_USE_TEMPLATE (alias) = 0;
 292   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 293   DECL_TEMPLATE_INFO (alias) = NULL;
 294   DECL_INITIAL (alias) = error_mark_node;
 295   TREE_ADDRESSABLE (alias) = 1;
 296   TREE_USED (alias) = 1;
 297   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 298   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
 299   if (!flag_syntax_only)
 300     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
 301   return alias;
 302 }
 303
 304 /* Emit the definition of a C++ multiple inheritance or covariant
 305    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 306    immediately.  */
 307
 308 void
 309 use_thunk (tree thunk_fndecl, bool emit_p)
 310 {
 311   tree a, t, function, alias;
 312   tree virtual_offset;
 313   HOST_WIDE_INT fixed_offset, virtual_value;
 314   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 315
 316   /* We should have called finish_thunk to give it a name.  */
 317   gcc_assert (DECL_NAME (thunk_fndecl));
 318
 319   /* We should never be using an alias, always refer to the
 320      aliased thunk.  */
 321   gcc_assert (!THUNK_ALIAS (thunk_fndecl));
 322
 323   if (TREE_ASM_WRITTEN (thunk_fndecl))
 324     return;
 325
 326   function = THUNK_TARGET (thunk_fndecl);
 327   if (DECL_RESULT (thunk_fndecl))
 328     /* We already turned this thunk into an ordinary function.
 329        There's no need to process this thunk again.  */
 330     return;
 331
 332   if (DECL_THUNK_P (function))
 333     /* The target is itself a thunk, process it now.  */
 334     use_thunk (function, emit_p);
 335
 336   /* Thunks are always addressable; they only appear in vtables.  */
 337   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 338
 339   /* Figure out what function is being thunked to.  It's referenced in
 340      this translation unit.  */
 341   TREE_ADDRESSABLE (function) = 1;
 342   mark_used (function);
 343   if (!emit_p)
 344     return;
 345
 346   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
 347    alias = make_alias_for_thunk (function);
 348   else
 349    alias = function;
 350
 351   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 352   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 353
 354   if (virtual_offset)
 355     {
 356       if (!this_adjusting)
 357         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 358       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
 359       gcc_assert (virtual_value);
 360     }
 361   else
 362     virtual_value = 0;
 363
 364   /* And, if we need to emit the thunk, it's used.  */
 365   mark_used (thunk_fndecl);
 366   /* This thunk is actually defined.  */
 367   DECL_EXTERNAL (thunk_fndecl) = 0;
 368   /* The linkage of the function may have changed.  FIXME in linkage
 369      rewrite.  */
 370   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 371   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
 372   DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
 373     = DECL_VISIBILITY_SPECIFIED (function);
 374   if (flag_weak && TREE_PUBLIC (thunk_fndecl))
 375     comdat_linkage (thunk_fndecl);
 376
 377   if (flag_syntax_only)
 378     {
 379       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 380       return;
 381     }
 382
 383   push_to_top_level ();
 384
 385   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
 386       && targetm.have_named_sections)
 387     {
 388       resolve_unique_section (function, 0, flag_function_sections);
 389
 390       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
 391         {
 392           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 393
 394           /* Output the thunk into the same section as function.  */
 395           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
 396         }
 397     }
 398
 399   /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
 400      create one.  */
 401   DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
 402
 403   /* Set up cloned argument trees for the thunk.  */
 404   t = NULL_TREE;
 405   for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 406     {
 407       tree x = copy_node (a);
 408       TREE_CHAIN (x) = t;
 409       DECL_CONTEXT (x) = thunk_fndecl;
 410       SET_DECL_RTL (x, NULL_RTX);
 411       t = x;
 412     }
 413   a = nreverse (t);
 414   DECL_ARGUMENTS (thunk_fndecl) = a;
 415   BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = a;
 416
 417   if (this_adjusting
 418       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
 419                                               virtual_value, alias))
 420     {
 421       const char *fnname;
 422       current_function_decl = thunk_fndecl;
 423       DECL_RESULT (thunk_fndecl)
 424         = build_decl (RESULT_DECL, 0, integer_type_node);
 425       fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
 426       init_function_start (thunk_fndecl);
 427       current_function_is_thunk = 1;
 428       assemble_start_function (thunk_fndecl, fnname);
 429
 430       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
 431                                        fixed_offset, virtual_value, alias);
 432
 433       assemble_end_function (thunk_fndecl, fnname);
 434       current_function_decl = 0;
 435       cfun = 0;
 436       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 437     }
 438   else
 439     {
 440       /* If this is a covariant thunk, or we don't have the necessary
 441          code for efficient thunks, generate a thunk function that
 442          just makes a call to the real function.  Unfortunately, this
 443          doesn't work for varargs.  */
 444
 445       if (varargs_function_p (function))
 446         error ("generic thunk code fails for method %q#D which uses %<...%>",
 447                function);
 448
 449       DECL_RESULT (thunk_fndecl) = NULL_TREE;
 450
 451       start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
 452       /* We don't bother with a body block for thunks.  */
 453
 454       /* There's no need to check accessibility inside the thunk body.  */
 455       push_deferring_access_checks (dk_no_check);
 456
 457       t = a;
 458       if (this_adjusting)
 459         t = thunk_adjust (t, /*this_adjusting=*/1,
 460                           fixed_offset, virtual_offset);
 461
 462       /* Build up the call to the real function.  */
 463       t = tree_cons (NULL_TREE, t, NULL_TREE);
 464       for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
 465         t = tree_cons (NULL_TREE, a, t);
 466       t = nreverse (t);
 467       t = build_call (alias, t);
 468       CALL_FROM_THUNK_P (t) = 1;
 469
 470       if (VOID_TYPE_P (TREE_TYPE (t)))
 471         finish_expr_stmt (t);
 472       else
 473         {
 474           t = force_target_expr (TREE_TYPE (t), t);
 475           if (!this_adjusting)
 476             t = thunk_adjust (t, /*this_adjusting=*/0,
 477                               fixed_offset, virtual_offset);
 478           finish_return_stmt (t);
 479         }
 480
 481       /* Since we want to emit the thunk, we explicitly mark its name as
 482          referenced.  */
 483       mark_decl_referenced (thunk_fndecl);
 484
 485       /* But we don't want debugging information about it.  */
 486       DECL_IGNORED_P (thunk_fndecl) = 1;
 487
 488       /* Re-enable access control.  */
 489       pop_deferring_access_checks ();
 490
 491       expand_body (finish_function (0));
 492     }
 493
 494   pop_from_top_level ();
 495 }
 496 \f
 497 /* Code for synthesizing methods which have default semantics defined.  */
 498
 499 /* Generate code for default X(X&) constructor.  */
 500
 501 static void
 502 do_build_copy_constructor (tree fndecl)
 503 {
 504   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 505
 506   parm = convert_from_reference (parm);
 507
 508   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 509       && is_empty_class (current_class_type))
 510     /* Don't copy the padding byte; it might not have been allocated
 511        if *this is a base subobject.  */;
 512   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 513     {
 514       tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
 515       finish_expr_stmt (t);
 516     }
 517   else
 518     {
 519       tree fields = TYPE_FIELDS (current_class_type);
 520       tree member_init_list = NULL_TREE;
 521       int cvquals = cp_type_quals (TREE_TYPE (parm));
 522       int i;
 523       tree binfo, base_binfo;
 524       VEC (tree) *vbases;
 525
 526       /* Initialize all the base-classes with the parameter converted
 527          to their type so that we get their copy constructor and not
 528          another constructor that takes current_class_type.  We must
 529          deal with the binfo's directly as a direct base might be
 530          inaccessible due to ambiguity.  */
 531       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
 532            VEC_iterate (tree, vbases, i, binfo); i++)
 533         {
 534           member_init_list
 535             = tree_cons (binfo,
 536                          build_tree_list (NULL_TREE,
 537                                           build_base_path (PLUS_EXPR, parm,
 538                                                            binfo, 1)),
 539                          member_init_list);
 540         }
 541
 542       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 543            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 544         {
 545           if (BINFO_VIRTUAL_P (base_binfo))
 546             continue;
 547
 548           member_init_list
 549             = tree_cons (base_binfo,
 550                          build_tree_list (NULL_TREE,
 551                                           build_base_path (PLUS_EXPR, parm,
 552                                                            base_binfo, 1)),
 553                          member_init_list);
 554         }
 555
 556       for (; fields; fields = TREE_CHAIN (fields))
 557         {
 558           tree init = parm;
 559           tree field = fields;
 560           tree expr_type;
 561
 562           if (TREE_CODE (field) != FIELD_DECL)
 563             continue;
 564
 565           expr_type = TREE_TYPE (field);
 566           if (DECL_NAME (field))
 567             {
 568               if (VFIELD_NAME_P (DECL_NAME (field)))
 569                 continue;
 570             }
 571           else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
 572             /* Just use the field; anonymous types can't have
 573                nontrivial copy ctors or assignment ops.  */;
 574           else
 575             continue;
 576
 577           /* Compute the type of "init->field".  If the copy-constructor
 578              parameter is, for example, "const S&", and the type of
 579              the field is "T", then the type will usually be "const
 580              T".  (There are no cv-qualified variants of reference
 581              types.)  */
 582           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
 583             {
 584               int quals = cvquals;
 585
 586               if (DECL_MUTABLE_P (field))
 587                 quals &= ~TYPE_QUAL_CONST;
 588               expr_type = cp_build_qualified_type (expr_type, quals);
 589             }
 590
 591           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 592           init = build_tree_list (NULL_TREE, init);
 593
 594           member_init_list = tree_cons (field, init, member_init_list);
 595         }
 596       finish_mem_initializers (member_init_list);
 597     }
 598 }
 599
 600 static void
 601 do_build_assign_ref (tree fndecl)
 602 {
 603   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
 604   tree compound_stmt;
 605
 606   compound_stmt = begin_compound_stmt (0);
 607   parm = convert_from_reference (parm);
 608
 609   if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
 610       && is_empty_class (current_class_type))
 611     /* Don't copy the padding byte; it might not have been allocated
 612        if *this is a base subobject.  */;
 613   else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
 614     {
 615       tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 616       finish_expr_stmt (t);
 617     }
 618   else
 619     {
 620       tree fields;
 621       int cvquals = cp_type_quals (TREE_TYPE (parm));
 622       int i;
 623       tree binfo, base_binfo;
 624
 625       /* Assign to each of the direct base classes.  */
 626       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 627            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 628         {
 629           tree converted_parm;
 630
 631           /* We must convert PARM directly to the base class
 632              explicitly since the base class may be ambiguous.  */
 633           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
 634           /* Call the base class assignment operator.  */
 635           finish_expr_stmt
 636             (build_special_member_call (current_class_ref,
 637                                         ansi_assopname (NOP_EXPR),
 638                                         build_tree_list (NULL_TREE,
 639                                                          converted_parm),
 640                                         base_binfo,
 641                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
 642         }
 643
 644       /* Assign to each of the non-static data members.  */
 645       for (fields = TYPE_FIELDS (current_class_type);
 646            fields;
 647            fields = TREE_CHAIN (fields))
 648         {
 649           tree comp = current_class_ref;
 650           tree init = parm;
 651           tree field = fields;
 652           tree expr_type;
 653           int quals;
 654
 655           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 656             continue;
 657
 658           expr_type = TREE_TYPE (field);
 659
 660           if (CP_TYPE_CONST_P (expr_type))
 661             {
 662               error ("non-static const member %q#D, can't use default "
 663                      "assignment operator", field);
 664               continue;
 665             }
 666           else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
 667             {
 668               error ("non-static reference member %q#D, can't use "
 669                      "default assignment operator", field);
 670               continue;
 671             }
 672
 673           if (DECL_NAME (field))
 674             {
 675               if (VFIELD_NAME_P (DECL_NAME (field)))
 676                 continue;
 677             }
 678           else if (ANON_AGGR_TYPE_P (expr_type)
 679                    && TYPE_FIELDS (expr_type) != NULL_TREE)
 680             /* Just use the field; anonymous types can't have
 681                nontrivial copy ctors or assignment ops.  */;
 682           else
 683             continue;
 684
 685           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
 686
 687           /* Compute the type of init->field  */
 688           quals = cvquals;
 689           if (DECL_MUTABLE_P (field))
 690             quals &= ~TYPE_QUAL_CONST;
 691           expr_type = cp_build_qualified_type (expr_type, quals);
 692
 693           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 694
 695           if (DECL_NAME (field))
 696             init = build_modify_expr (comp, NOP_EXPR, init);
 697           else
 698             init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
 699           finish_expr_stmt (init);
 700         }
 701     }
 702   finish_return_stmt (current_class_ref);
 703   finish_compound_stmt (compound_stmt);
 704 }
 705
 706 /* Synthesize FNDECL, a non-static member function.   */
 707
 708 void
 709 synthesize_method (tree fndecl)
 710 {
 711   bool nested = (current_function_decl != NULL_TREE);
 712   tree context = decl_function_context (fndecl);
 713   bool need_body = true;
 714   tree stmt;
 715   location_t save_input_location = input_location;
 716   int error_count = errorcount;
 717   int warning_count = warningcount;
 718
 719   /* Reset the source location, we might have been previously
 720      deferred, and thus have saved where we were first needed.  */
 721   DECL_SOURCE_LOCATION (fndecl)
 722     = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
 723
 724   /* If we've been asked to synthesize a clone, just synthesize the
 725      cloned function instead.  Doing so will automatically fill in the
 726      body for the clone.  */
 727   if (DECL_CLONED_FUNCTION_P (fndecl))
 728     fndecl = DECL_CLONED_FUNCTION (fndecl);
 729
 730   /* We may be in the middle of deferred access check.  Disable
 731      it now.  */
 732   push_deferring_access_checks (dk_no_deferred);
 733
 734   if (! context)
 735     push_to_top_level ();
 736   else if (nested)
 737     push_function_context_to (context);
 738
 739   input_location = DECL_SOURCE_LOCATION (fndecl);
 740
 741   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 742   stmt = begin_function_body ();
 743
 744   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 745     {
 746       do_build_assign_ref (fndecl);
 747       need_body = false;
 748     }
 749   else if (DECL_CONSTRUCTOR_P (fndecl))
 750     {
 751       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 752       if (arg_chain != void_list_node)
 753         do_build_copy_constructor (fndecl);
 754       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 755         finish_mem_initializers (NULL_TREE);
 756     }
 757
 758   /* If we haven't yet generated the body of the function, just
 759      generate an empty compound statement.  */
 760   if (need_body)
 761     {
 762       tree compound_stmt;
 763       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
 764       finish_compound_stmt (compound_stmt);
 765     }
 766
 767   finish_function_body (stmt);
 768   expand_or_defer_fn (finish_function (0));
 769
 770   input_location = save_input_location;
 771
 772   if (! context)
 773     pop_from_top_level ();
 774   else if (nested)
 775     pop_function_context_from (context);
 776
 777   pop_deferring_access_checks ();
 778
 779   if (error_count != errorcount || warning_count != warningcount)
 780     warning ("%Hsynthesized method %qD first required here ",
 781              &input_location, fndecl);
 782 }
 783
 784 /* Use EXTRACTOR to locate the relevant function called for each base &
 785    class field of TYPE. CLIENT allows additional information to be passed
 786    to EXTRACTOR.  Generates the union of all exceptions generated by those
 787    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 788    variants yet, so we need to look at the main one.  */
 789
 790 static tree
 791 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 792                            void *client)
 793 {
 794   tree raises = empty_except_spec;
 795   tree fields = TYPE_FIELDS (type);
 796   tree binfo, base_binfo;
 797   int i;
 798
 799   for (binfo = TYPE_BINFO (type), i = 0;
 800        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 801     {
 802       tree fn = (*extractor) (BINFO_TYPE (base_binfo), 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   for (; fields; fields = TREE_CHAIN (fields))
 811     {
 812       tree type = TREE_TYPE (fields);
 813       tree fn;
 814
 815       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 816         continue;
 817       while (TREE_CODE (type) == ARRAY_TYPE)
 818         type = TREE_TYPE (type);
 819       if (TREE_CODE (type) != RECORD_TYPE)
 820         continue;
 821
 822       fn = (*extractor) (type, client);
 823       if (fn)
 824         {
 825           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 826
 827           raises = merge_exception_specifiers (raises, fn_raises);
 828         }
 829     }
 830   return raises;
 831 }
 832
 833 /* Locate the dtor of TYPE.  */
 834
 835 static tree
 836 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 837 {
 838   return CLASSTYPE_DESTRUCTORS (type);
 839 }
 840
 841 /* Locate the default ctor of TYPE.  */
 842
 843 static tree
 844 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 845 {
 846   tree fns;
 847
 848   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 849     return NULL_TREE;
 850
 851   /* Call lookup_fnfields_1 to create the constructor declarations, if
 852      necessary.  */
 853   if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
 854     return lazily_declare_fn (sfk_constructor, type);
 855
 856   for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
 857     {
 858       tree fn = OVL_CURRENT (fns);
 859       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 860
 861       if (sufficient_parms_p (TREE_CHAIN (parms)))
 862         return fn;
 863     }
 864   return NULL_TREE;
 865 }
 866
 867 struct copy_data
 868 {
 869   tree name;
 870   int quals;
 871 };
 872
 873 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 874    points to a COPY_DATA holding the name (NULL for the ctor)
 875    and desired qualifiers of the source operand.  */
 876
 877 static tree
 878 locate_copy (tree type, void *client_)
 879 {
 880   struct copy_data *client = (struct copy_data *)client_;
 881   tree fns;
 882   tree best = NULL_TREE;
 883   bool excess_p = false;
 884
 885   if (client->name)
 886     {
 887       int ix;
 888       ix = lookup_fnfields_1 (type, client->name);
 889       if (ix < 0)
 890         return NULL_TREE;
 891       fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
 892     }
 893   else if (TYPE_HAS_INIT_REF (type))
 894     {
 895       /* If construction of the copy constructor was postponed, create
 896          it now.  */
 897       if (CLASSTYPE_LAZY_COPY_CTOR (type))
 898         lazily_declare_fn (sfk_copy_constructor, type);
 899       fns = CLASSTYPE_CONSTRUCTORS (type);
 900     }
 901   else
 902     return NULL_TREE;
 903   for (; fns; fns = OVL_NEXT (fns))
 904     {
 905       tree fn = OVL_CURRENT (fns);
 906       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 907       tree src_type;
 908       int excess;
 909       int quals;
 910
 911       parms = TREE_CHAIN (parms);
 912       if (!parms)
 913         continue;
 914       src_type = non_reference (TREE_VALUE (parms));
 915       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 916         continue;
 917       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 918         continue;
 919       quals = cp_type_quals (src_type);
 920       if (client->quals & ~quals)
 921         continue;
 922       excess = quals & ~client->quals;
 923       if (!best || (excess_p && !excess))
 924         {
 925           best = fn;
 926           excess_p = excess;
 927         }
 928       else
 929         /* Ambiguous */
 930         return NULL_TREE;
 931     }
 932   return best;
 933 }
 934
 935 /* Implicitly declare the special function indicated by KIND, as a
 936    member of TYPE.  For copy constructors and assignment operators,
 937    CONST_P indicates whether these functions should take a const
 938    reference argument or a non-const reference.  Returns the
 939    FUNCTION_DECL for the implicitly declared function.  */
 940
 941 tree
 942 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 943 {
 944   tree fn;
 945   tree parameter_types = void_list_node;
 946   tree return_type;
 947   tree fn_type;
 948   tree raises = empty_except_spec;
 949   tree rhs_parm_type = NULL_TREE;
 950   tree name;
 951   HOST_WIDE_INT saved_processing_template_decl;
 952
 953   /* Because we create declarations for implictly declared functions
 954      lazily, we may be creating the declaration for a member of TYPE
 955      while in some completely different context.  However, TYPE will
 956      never be a dependent class (because we never want to do lookups
 957      for implicitly defined functions in a dependent class).
 958      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
 959      because we only create clones for constructors and destructors
 960      when not in a template.  */
 961   gcc_assert (!dependent_type_p (type));
 962   saved_processing_template_decl = processing_template_decl;
 963   processing_template_decl = 0;
 964
 965   type = TYPE_MAIN_VARIANT (type);
 966
 967   if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
 968     {
 969       if (kind == sfk_destructor)
 970         /* See comment in check_special_function_return_type.  */
 971         return_type = build_pointer_type (void_type_node);
 972       else
 973         return_type = build_pointer_type (type);
 974     }
 975   else
 976     return_type = void_type_node;
 977
 978   switch (kind)
 979     {
 980     case sfk_destructor:
 981       /* Destructor.  */
 982       name = constructor_name (type);
 983       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 984       break;
 985
 986     case sfk_constructor:
 987       /* Default constructor.  */
 988       name = constructor_name (type);
 989       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 990       break;
 991
 992     case sfk_copy_constructor:
 993     case sfk_assignment_operator:
 994     {
 995       struct copy_data data;
 996
 997       data.name = NULL;
 998       data.quals = 0;
 999       if (kind == sfk_assignment_operator)
1000         {
1001           return_type = build_reference_type (type);
1002           name = ansi_assopname (NOP_EXPR);
1003           data.name = name;
1004         }
1005       else
1006         name = constructor_name (type);
1007
1008       if (const_p)
1009         {
1010           data.quals = TYPE_QUAL_CONST;
1011           rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1012         }
1013       else
1014         rhs_parm_type = type;
1015       rhs_parm_type = build_reference_type (rhs_parm_type);
1016       parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1017       raises = synthesize_exception_spec (type, &locate_copy, &data);
1018       break;
1019     }
1020     default:
1021       gcc_unreachable ();
1022     }
1023
1024   /* Create the function.  */
1025   fn_type = build_method_type_directly (type, return_type, parameter_types);
1026   if (raises)
1027     fn_type = build_exception_variant (fn_type, raises);
1028   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1029   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1030   if (kind == sfk_constructor || kind == sfk_copy_constructor)
1031     DECL_CONSTRUCTOR_P (fn) = 1;
1032   else if (kind == sfk_destructor)
1033     DECL_DESTRUCTOR_P (fn) = 1;
1034   else
1035     {
1036       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1037       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1038     }
1039   /* Create the argument list.  The call to "grokclassfn" will add the
1040      "this" parameter and any other implicit parameters.  */
1041   if (rhs_parm_type)
1042     {
1043       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1044          want its type to be included in the mangled function
1045          name.  */
1046       DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1047       TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1048     }
1049
1050   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL,
1051                TYPE_UNQUALIFIED);
1052   grok_special_member_properties (fn);
1053   set_linkage_according_to_type (type, fn);
1054   rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1055   DECL_IN_AGGR_P (fn) = 1;
1056   DECL_ARTIFICIAL (fn) = 1;
1057   DECL_NOT_REALLY_EXTERN (fn) = 1;
1058   DECL_DECLARED_INLINE_P (fn) = 1;
1059   DECL_INLINE (fn) = 1;
1060   gcc_assert (!TREE_USED (fn));
1061
1062   /* Restore PROCESSING_TEMPLATE_DECL.  */
1063   processing_template_decl = saved_processing_template_decl;
1064
1065   return fn;
1066 }
1067
1068 /* Add an implicit declaration to TYPE for the kind of function
1069    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
1070    declaration.  */
1071
1072 tree
1073 lazily_declare_fn (special_function_kind sfk, tree type)
1074 {
1075   tree fn;
1076   bool const_p;
1077
1078   /* Figure out whether or not the argument has a const reference
1079      type.  */
1080   if (sfk == sfk_copy_constructor)
1081     const_p = TYPE_HAS_CONST_INIT_REF (type);
1082   else if (sfk == sfk_assignment_operator)
1083     const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1084   else
1085     /* In this case, CONST_P will be ignored.  */
1086     const_p = false;
1087   /* Declare the function.  */
1088   fn = implicitly_declare_fn (sfk, type, const_p);
1089   /* A destructor may be virtual.  */
1090   if (sfk == sfk_destructor)
1091     check_for_override (fn, type);
1092   /* Add it to CLASSTYPE_METHOD_VEC.  */
1093   add_method (type, fn);
1094   /* Add it to TYPE_METHODS.  */
1095   if (sfk == sfk_destructor
1096       && DECL_VIRTUAL_P (fn)
1097       && abi_version_at_least (2))
1098     /* The ABI requires that a virtual destructor go at the end of the
1099        vtable.  */
1100     TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1101   else
1102     {
1103       /* G++ 3.2 put the implicit destructor at the *beginning* of the
1104          TYPE_METHODS list, which cause the destructor to be emitted
1105          in an incorrect location in the vtable.  */
1106       if (warn_abi && DECL_VIRTUAL_P (fn))
1107         warning ("vtable layout for class %qT may not be ABI-compliant"
1108                  "and may change in a future version of GCC due to "
1109                  "implicit virtual destructor",
1110                  type);
1111       TREE_CHAIN (fn) = TYPE_METHODS (type);
1112       TYPE_METHODS (type) = fn;
1113     }
1114   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1115   if (sfk == sfk_assignment_operator)
1116     CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1117   else
1118     {
1119       /* Remember that the function has been created.  */
1120       if (sfk == sfk_constructor)
1121         CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1122       else if (sfk == sfk_copy_constructor)
1123         CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1124       else if (sfk == sfk_destructor)
1125         CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1126       /* Create appropriate clones.  */
1127       clone_function_decl (fn, /*update_method_vec=*/true);
1128     }
1129
1130   return fn;
1131 }
1132
1133 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1134    as there are artificial parms in FN.  */
1135
1136 tree
1137 skip_artificial_parms_for (tree fn, tree list)
1138 {
1139   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1140     list = TREE_CHAIN (list);
1141   else
1142     return list;
1143
1144   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1145     list = TREE_CHAIN (list);
1146   if (DECL_HAS_VTT_PARM_P (fn))
1147     list = TREE_CHAIN (list);
1148   return list;
1149 }
1150
1151 #include "gt-cp-method.h"