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