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 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 static tree make_alias_for_thunk (tree);
  66
  67 /* Called once to initialize method.c.  */
  68
  69 void
  70 init_method (void)
  71 {
  72   init_mangle ();
  73 }
  74 \f
  75 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  76    indicates whether it is a this or result adjusting thunk.
  77    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  78    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  79    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  80    adjusting thunks, we scale it to a byte offset. For covariant
  81    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  82    the returned thunk with finish_thunk.  */
  83
  84 tree
  85 make_thunk (tree function, bool this_adjusting,
  86             tree fixed_offset, tree virtual_offset)
  87 {
  88   HOST_WIDE_INT d;
  89   tree thunk;
  90
  91   my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 20021025);
  92   /* We can have this thunks to covariant thunks, but not vice versa.  */
  93   my_friendly_assert (!DECL_THIS_THUNK_P (function), 20021127);
  94   my_friendly_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting,
  95                       20031123);
  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   my_friendly_assert (!TREE_ASM_WRITTEN (function), 20021025);
 125   /* Likewise, we can only be adding thunks to a function declared in
 126      the class currently being laid out.  */
 127   my_friendly_assert (TYPE_SIZE (DECL_CONTEXT (function))
 128                       && TYPE_BEING_DEFINED (DECL_CONTEXT (function)),
 129                       20031211);
 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   /* And neither is it a clone.  */
 156   DECL_CLONED_FUNCTION (thunk) = NULL_TREE;
 157   DECL_EXTERNAL (thunk) = 1;
 158   DECL_ARTIFICIAL (thunk) = 1;
 159   /* Even if this thunk is a member of a local class, we don't
 160      need a static chain.  */
 161   DECL_NO_STATIC_CHAIN (thunk) = 1;
 162   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 163   DECL_PENDING_INLINE_P (thunk) = 0;
 164   DECL_INLINE (thunk) = 0;
 165   DECL_DECLARED_INLINE_P (thunk) = 0;
 166   /* Nor has it been deferred.  */
 167   DECL_DEFERRED_FN (thunk) = 0;
 168
 169   /* Add it to the list of thunks associated with FUNCTION.  */
 170   TREE_CHAIN (thunk) = DECL_THUNKS (function);
 171   DECL_THUNKS (function) = thunk;
 172
 173   return thunk;
 174 }
 175
 176 /* Finish THUNK, a thunk decl.  */
 177
 178 void
 179 finish_thunk (tree thunk)
 180 {
 181   tree function, name;
 182   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 183   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 184
 185   my_friendly_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk), 20021127);
 186   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 187     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 188   function = THUNK_TARGET (thunk);
 189   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 190                        fixed_offset, virtual_offset);
 191
 192   /* We can end up with declarations of (logically) different
 193      covariant thunks, that do identical adjustments.  The two thunks
 194      will be adjusting between within different hierarchies, which
 195      happen to have the same layout.  We must nullify one of them to
 196      refer to the other.  */
 197   if (DECL_RESULT_THUNK_P (thunk))
 198     {
 199       tree cov_probe;
 200
 201       for (cov_probe = DECL_THUNKS (function);
 202            cov_probe; cov_probe = TREE_CHAIN (cov_probe))
 203         if (DECL_NAME (cov_probe) == name)
 204           {
 205             my_friendly_assert (!DECL_THUNKS (thunk), 20031023);
 206             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 207                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 208             break;
 209           }
 210     }
 211
 212   DECL_NAME (thunk) = name;
 213   SET_DECL_ASSEMBLER_NAME (thunk, name);
 214 }
 215
 216 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
 217    offset indicated by VIRTUAL_OFFSET, if that is
 218    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
 219    zero for a result adjusting thunk.  */
 220
 221 static tree
 222 thunk_adjust (tree ptr, bool this_adjusting,
 223               HOST_WIDE_INT fixed_offset, tree virtual_offset)
 224 {
 225   if (this_adjusting)
 226     /* Adjust the pointer by the constant.  */
 227     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 228                        ssize_int (fixed_offset)));
 229
 230   /* If there's a virtual offset, look up that value in the vtable and
 231      adjust the pointer again.  */
 232   if (virtual_offset)
 233     {
 234       tree vtable;
 235
 236       ptr = save_expr (ptr);
 237       /* The vptr is always at offset zero in the object.  */
 238       vtable = build1 (NOP_EXPR,
 239                        build_pointer_type (build_pointer_type
 240                                            (vtable_entry_type)),
 241                        ptr);
 242       /* Form the vtable address.  */
 243       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 244       /* Find the entry with the vcall offset.  */
 245       vtable = build (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
 246       /* Get the offset itself.  */
 247       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 248       /* Adjust the `this' pointer.  */
 249       ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable));
 250     }
 251
 252   if (!this_adjusting)
 253     /* Adjust the pointer by the constant.  */
 254     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 255                        ssize_int (fixed_offset)));
 256
 257   return ptr;
 258 }
 259
 260 static GTY (()) int thunk_labelno;
 261
 262 /* Create a static alias to function.  */
 263
 264 static tree
 265 make_alias_for_thunk (tree function)
 266 {
 267   tree alias;
 268   char buf[256];
 269
 270   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
 271   thunk_labelno++;
 272   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
 273                       TREE_TYPE (function));
 274   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
 275   cxx_dup_lang_specific_decl (alias);
 276   DECL_CONTEXT (alias) = NULL;
 277   TREE_READONLY (alias) = TREE_READONLY (function);
 278   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
 279   TREE_PUBLIC (alias) = 0;
 280   DECL_INTERFACE_KNOWN (alias) = 1;
 281   DECL_NOT_REALLY_EXTERN (alias) = 1;
 282   DECL_THIS_STATIC (alias) = 1;
 283   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 284   DECL_DESTRUCTOR_P (alias) = 0;
 285   DECL_CONSTRUCTOR_P (alias) = 0;
 286   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
 287   DECL_EXTERNAL (alias) = 0;
 288   DECL_ARTIFICIAL (alias) = 1;
 289   DECL_NO_STATIC_CHAIN (alias) = 1;
 290   DECL_PENDING_INLINE_P (alias) = 0;
 291   DECL_INLINE (alias) = 0;
 292   DECL_DECLARED_INLINE_P (alias) = 0;
 293   DECL_DEFERRED_FN (alias) = 0;
 294   DECL_USE_TEMPLATE (alias) = 0;
 295   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 296   DECL_TEMPLATE_INFO (alias) = NULL;
 297   DECL_INITIAL (alias) = error_mark_node;
 298   TREE_ADDRESSABLE (alias) = 1;
 299   TREE_USED (alias) = 1;
 300   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 301   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
 302   if (!flag_syntax_only)
 303     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
 304   return alias;
 305 }
 306
 307 /* Emit the definition of a C++ multiple inheritance or covariant
 308    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 309    immediately.  */
 310
 311 void
 312 use_thunk (tree thunk_fndecl, bool emit_p)
 313 {
 314   tree a, t, function, alias;
 315   tree virtual_offset;
 316   HOST_WIDE_INT fixed_offset, virtual_value;
 317   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 318
 319   /* We should have called finish_thunk to give it a name.  */
 320   my_friendly_assert (DECL_NAME (thunk_fndecl), 20021127);
 321
 322   /* We should never be using an alias, always refer to the
 323      aliased thunk.  */
 324   my_friendly_assert (!THUNK_ALIAS (thunk_fndecl), 20031023);
 325
 326   if (TREE_ASM_WRITTEN (thunk_fndecl))
 327     return;
 328
 329   function = THUNK_TARGET (thunk_fndecl);
 330   if (DECL_RESULT (thunk_fndecl))
 331     /* We already turned this thunk into an ordinary function.
 332        There's no need to process this thunk again.  */
 333     return;
 334
 335   /* Thunks are always addressable; they only appear in vtables.  */
 336   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 337
 338   /* Figure out what function is being thunked to.  It's referenced in
 339      this translation unit.  */
 340   TREE_ADDRESSABLE (function) = 1;
 341   mark_used (function);
 342   if (!emit_p)
 343     return;
 344
 345   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
 346    alias = make_alias_for_thunk (function);
 347   else
 348    alias = function;
 349
 350   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 351   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 352
 353   if (virtual_offset)
 354     {
 355       if (!this_adjusting)
 356         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 357       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
 358       my_friendly_assert (virtual_value, 20021026);
 359     }
 360   else
 361     virtual_value = 0;
 362
 363   /* And, if we need to emit the thunk, it's used.  */
 364   mark_used (thunk_fndecl);
 365   /* This thunk is actually defined.  */
 366   DECL_EXTERNAL (thunk_fndecl) = 0;
 367   /* The linkage of the function may have changed.  FIXME in linkage
 368      rewrite.  */
 369   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 370   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
 371   if (flag_weak && TREE_PUBLIC (thunk_fndecl))
 372     comdat_linkage (thunk_fndecl);
 373
 374   if (flag_syntax_only)
 375     {
 376       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 377       return;
 378     }
 379
 380   push_to_top_level ();
 381
 382   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
 383       && targetm.have_named_sections)
 384     {
 385       resolve_unique_section (function, 0, flag_function_sections);
 386
 387       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
 388         {
 389           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 390
 391           /* Output the thunk into the same section as function.  */
 392           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
 393         }
 394     }
 395
 396   /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
 397      create one.  */
 398   DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
 399
 400   /* Set up cloned argument trees for the thunk.  */
 401   t = NULL_TREE;
 402   for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 403     {
 404       tree x = copy_node (a);
 405       TREE_CHAIN (x) = t;
 406       DECL_CONTEXT (x) = thunk_fndecl;
 407       SET_DECL_RTL (x, NULL_RTX);
 408       t = x;
 409     }
 410   a = nreverse (t);
 411   DECL_ARGUMENTS (thunk_fndecl) = a;
 412   BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = a;
 413
 414   if (this_adjusting
 415       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
 416                                               virtual_value, alias))
 417     {
 418       const char *fnname;
 419       current_function_decl = thunk_fndecl;
 420       DECL_RESULT (thunk_fndecl)
 421         = build_decl (RESULT_DECL, 0, integer_type_node);
 422       fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
 423       init_function_start (thunk_fndecl);
 424       current_function_is_thunk = 1;
 425       assemble_start_function (thunk_fndecl, fnname);
 426
 427       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
 428                                        fixed_offset, virtual_value, alias);
 429
 430       assemble_end_function (thunk_fndecl, fnname);
 431       current_function_decl = 0;
 432       cfun = 0;
 433       /* Because init_function_start increments this, we must
 434          decrement it.  */
 435       immediate_size_expand--;
 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 `%#D' which uses `...'",
 447                function);
 448
 449       DECL_RESULT (thunk_fndecl) = NULL_TREE;
 450
 451       start_function (NULL_TREE, 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   tree t;
 506
 507   parm = convert_from_reference (parm);
 508
 509   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 510       && is_empty_class (current_class_type))
 511     /* Don't copy the padding byte; it might not have been allocated
 512        if *this is a base subobject.  */;
 513   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 514     {
 515       t = build (INIT_EXPR, void_type_node, current_class_ref, parm);
 516       finish_expr_stmt (t);
 517     }
 518   else
 519     {
 520       tree fields = TYPE_FIELDS (current_class_type);
 521       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 522       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 523       tree member_init_list = NULL_TREE;
 524       int cvquals = cp_type_quals (TREE_TYPE (parm));
 525       int i;
 526
 527       /* Initialize all the base-classes with the parameter converted
 528          to their type so that we get their copy constructor and not
 529          another constructor that takes current_class_type.  We must
 530          deal with the binfo's directly as a direct base might be
 531          inaccessible due to ambiguity.  */
 532       for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
 533            t = TREE_CHAIN (t))
 534         {
 535           tree binfo = TREE_VALUE (t);
 536
 537           member_init_list
 538             = tree_cons (binfo,
 539                          build_tree_list (NULL_TREE,
 540                                           build_base_path (PLUS_EXPR, parm,
 541                                                            binfo, 1)),
 542                          member_init_list);
 543         }
 544
 545       for (i = 0; i < n_bases; ++i)
 546         {
 547           tree binfo = TREE_VEC_ELT (binfos, i);
 548           if (TREE_VIA_VIRTUAL (binfo))
 549             continue;
 550
 551           member_init_list
 552             = tree_cons (binfo,
 553                          build_tree_list (NULL_TREE,
 554                                           build_base_path (PLUS_EXPR, parm,
 555                                                            binfo, 1)),
 556                          member_init_list);
 557         }
 558
 559       for (; fields; fields = TREE_CHAIN (fields))
 560         {
 561           tree init;
 562           tree field = fields;
 563           tree expr_type;
 564
 565           if (TREE_CODE (field) != FIELD_DECL)
 566             continue;
 567
 568           init = parm;
 569           if (DECL_NAME (field))
 570             {
 571               if (VFIELD_NAME_P (DECL_NAME (field)))
 572                 continue;
 573
 574               /* True for duplicate members.  */
 575               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 576                 continue;
 577             }
 578           else if ((t = TREE_TYPE (field)) != NULL_TREE
 579                    && ANON_AGGR_TYPE_P (t)
 580                    && TYPE_FIELDS (t) != NULL_TREE)
 581             /* Just use the field; anonymous types can't have
 582                nontrivial copy ctors or assignment ops.  */;
 583           else
 584             continue;
 585
 586           /* Compute the type of "init->field".  If the copy-constructor
 587              parameter is, for example, "const S&", and the type of
 588              the field is "T", then the type will usually be "const
 589              T".  (There are no cv-qualified variants of reference
 590              types.)  */
 591           expr_type = TREE_TYPE (field);
 592           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
 593             expr_type = cp_build_qualified_type (expr_type, cvquals);
 594           init = build (COMPONENT_REF, expr_type, init, field);
 595           init = build_tree_list (NULL_TREE, init);
 596
 597           member_init_list
 598             = tree_cons (field, init, member_init_list);
 599         }
 600       finish_mem_initializers (member_init_list);
 601     }
 602 }
 603
 604 static void
 605 do_build_assign_ref (tree fndecl)
 606 {
 607   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
 608   tree compound_stmt;
 609
 610   compound_stmt = begin_compound_stmt (0);
 611   parm = convert_from_reference (parm);
 612
 613   if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
 614       && is_empty_class (current_class_type))
 615     /* Don't copy the padding byte; it might not have been allocated
 616        if *this is a base subobject.  */;
 617   else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
 618     {
 619       tree t = build (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 620       finish_expr_stmt (t);
 621     }
 622   else
 623     {
 624       tree fields;
 625       int cvquals = cp_type_quals (TREE_TYPE (parm));
 626       int i;
 627
 628       /* Assign to each of the direct base classes.  */
 629       for (i = 0; i < CLASSTYPE_N_BASECLASSES (current_class_type); ++i)
 630         {
 631           tree binfo;
 632           tree converted_parm;
 633
 634           binfo = BINFO_BASETYPE (TYPE_BINFO (current_class_type), i);
 635           /* We must convert PARM directly to the base class
 636              explicitly since the base class may be ambiguous.  */
 637           converted_parm = build_base_path (PLUS_EXPR, parm, binfo, 1);
 638           /* Call the base class assignment operator.  */
 639           finish_expr_stmt
 640             (build_special_member_call (current_class_ref,
 641                                         ansi_assopname (NOP_EXPR),
 642                                         build_tree_list (NULL_TREE,
 643                                                          converted_parm),
 644                                         binfo,
 645                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
 646         }
 647
 648       /* Assign to each of the non-static data members.  */
 649       for (fields = TYPE_FIELDS (current_class_type);
 650            fields;
 651            fields = TREE_CHAIN (fields))
 652         {
 653           tree comp, init, t;
 654           tree field = fields;
 655
 656           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 657             continue;
 658
 659           if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 660             {
 661               error ("non-static const member `%#D', can't use default assignment operator", field);
 662               continue;
 663             }
 664           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 665             {
 666               error ("non-static reference member `%#D', can't use default assignment operator", field);
 667               continue;
 668             }
 669
 670           comp = current_class_ref;
 671           init = parm;
 672
 673           if (DECL_NAME (field))
 674             {
 675               if (VFIELD_NAME_P (DECL_NAME (field)))
 676                 continue;
 677
 678               /* True for duplicate members.  */
 679               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 680                 continue;
 681             }
 682           else if ((t = TREE_TYPE (field)) != NULL_TREE
 683                    && ANON_AGGR_TYPE_P (t)
 684                    && TYPE_FIELDS (t) != NULL_TREE)
 685             /* Just use the field; anonymous types can't have
 686                nontrivial copy ctors or assignment ops.  */;
 687           else
 688             continue;
 689
 690           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field);
 691           init = build (COMPONENT_REF,
 692                         cp_build_qualified_type (TREE_TYPE (field), cvquals),
 693                         init, field);
 694
 695           if (DECL_NAME (field))
 696             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 697           else
 698             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 699                                      init));
 700         }
 701     }
 702   finish_return_stmt (current_class_ref);
 703   finish_compound_stmt (compound_stmt);
 704 }
 705
 706 void
 707 synthesize_method (tree fndecl)
 708 {
 709   bool nested = (current_function_decl != NULL_TREE);
 710   tree context = decl_function_context (fndecl);
 711   bool need_body = true;
 712   tree stmt;
 713
 714   if (at_eof)
 715     import_export_decl (fndecl);
 716
 717   /* If we've been asked to synthesize a clone, just synthesize the
 718      cloned function instead.  Doing so will automatically fill in the
 719      body for the clone.  */
 720   if (DECL_CLONED_FUNCTION_P (fndecl))
 721     {
 722       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 723       return;
 724     }
 725
 726   /* We may be in the middle of deferred access check.  Disable
 727      it now.  */
 728   push_deferring_access_checks (dk_no_deferred);
 729
 730   if (! context)
 731     push_to_top_level ();
 732   else if (nested)
 733     push_function_context_to (context);
 734
 735   /* Put the function definition at the position where it is needed,
 736      rather than within the body of the class.  That way, an error
 737      during the generation of the implicit body points at the place
 738      where the attempt to generate the function occurs, giving the
 739      user a hint as to why we are attempting to generate the
 740      function.  */
 741   DECL_SOURCE_LOCATION (fndecl) = input_location;
 742
 743   interface_unknown = 1;
 744   start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 745   clear_last_expr ();
 746   stmt = begin_function_body ();
 747
 748   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 749     {
 750       do_build_assign_ref (fndecl);
 751       need_body = false;
 752     }
 753   else if (DECL_CONSTRUCTOR_P (fndecl))
 754     {
 755       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 756       if (arg_chain != void_list_node)
 757         do_build_copy_constructor (fndecl);
 758       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 759         finish_mem_initializers (NULL_TREE);
 760     }
 761
 762   /* If we haven't yet generated the body of the function, just
 763      generate an empty compound statement.  */
 764   if (need_body)
 765     {
 766       tree compound_stmt;
 767       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
 768       finish_compound_stmt (compound_stmt);
 769     }
 770
 771   finish_function_body (stmt);
 772   expand_or_defer_fn (finish_function (0));
 773
 774   extract_interface_info ();
 775   if (! context)
 776     pop_from_top_level ();
 777   else if (nested)
 778     pop_function_context_from (context);
 779
 780   pop_deferring_access_checks ();
 781 }
 782
 783 /* Use EXTRACTOR to locate the relevant function called for each base &
 784    class field of TYPE. CLIENT allows additional information to be passed
 785    to EXTRACTOR.  Generates the union of all exceptions generated by those
 786    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 787    variants yet, so we need to look at the main one.  */
 788
 789 static tree
 790 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 791                            void *client)
 792 {
 793   tree raises = empty_except_spec;
 794   tree fields = TYPE_FIELDS (type);
 795   int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
 796   tree binfos = TYPE_BINFO_BASETYPES (type);
 797
 798   for (i = 0; i != n_bases; i++)
 799     {
 800       tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 801       tree fn = (*extractor) (base, client);
 802       if (fn)
 803         {
 804           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 805
 806           raises = merge_exception_specifiers (raises, fn_raises);
 807         }
 808     }
 809   for (; fields; fields = TREE_CHAIN (fields))
 810     {
 811       tree type = TREE_TYPE (fields);
 812       tree fn;
 813
 814       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 815         continue;
 816       while (TREE_CODE (type) == ARRAY_TYPE)
 817         type = TREE_TYPE (type);
 818       if (TREE_CODE (type) != RECORD_TYPE)
 819         continue;
 820
 821       fn = (*extractor) (type, client);
 822       if (fn)
 823         {
 824           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 825
 826           raises = merge_exception_specifiers (raises, fn_raises);
 827         }
 828     }
 829   return raises;
 830 }
 831
 832 /* Locate the dtor of TYPE.  */
 833
 834 static tree
 835 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 836 {
 837   tree fns;
 838
 839   if (!TYPE_HAS_DESTRUCTOR (type))
 840     return NULL_TREE;
 841   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 842                       CLASSTYPE_DESTRUCTOR_SLOT);
 843   return fns;
 844 }
 845
 846 /* Locate the default ctor of TYPE.  */
 847
 848 static tree
 849 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 850 {
 851   tree fns;
 852
 853   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 854     return NULL_TREE;
 855
 856   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 857                       CLASSTYPE_CONSTRUCTOR_SLOT);
 858   for (; fns; fns = OVL_NEXT (fns))
 859     {
 860       tree fn = OVL_CURRENT (fns);
 861       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 862
 863       if (sufficient_parms_p (TREE_CHAIN (parms)))
 864         return fn;
 865     }
 866   return NULL_TREE;
 867 }
 868
 869 struct copy_data
 870 {
 871   tree name;
 872   int quals;
 873 };
 874
 875 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 876    points to a COPY_DATA holding the name (NULL for the ctor)
 877    and desired qualifiers of the source operand.  */
 878
 879 static tree
 880 locate_copy (tree type, void *client_)
 881 {
 882   struct copy_data *client = (struct copy_data *)client_;
 883   tree fns;
 884   int ix = -1;
 885   tree best = NULL_TREE;
 886   bool excess_p = false;
 887
 888   if (client->name)
 889     {
 890       if (TYPE_HAS_ASSIGN_REF (type))
 891         ix = lookup_fnfields_1 (type, client->name);
 892     }
 893   else if (TYPE_HAS_INIT_REF (type))
 894     ix = CLASSTYPE_CONSTRUCTOR_SLOT;
 895   if (ix < 0)
 896     return NULL_TREE;
 897   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix);
 898
 899   for (; fns; fns = OVL_NEXT (fns))
 900     {
 901       tree fn = OVL_CURRENT (fns);
 902       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 903       tree src_type;
 904       int excess;
 905       int quals;
 906
 907       parms = TREE_CHAIN (parms);
 908       if (!parms)
 909         continue;
 910       src_type = non_reference (TREE_VALUE (parms));
 911       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 912         continue;
 913       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 914         continue;
 915       quals = cp_type_quals (src_type);
 916       if (client->quals & ~quals)
 917         continue;
 918       excess = quals & ~client->quals;
 919       if (!best || (excess_p && !excess))
 920         {
 921           best = fn;
 922           excess_p = excess;
 923         }
 924       else
 925         /* Ambiguous */
 926         return NULL_TREE;
 927     }
 928   return best;
 929 }
 930
 931 /* Implicitly declare the special function indicated by KIND, as a
 932    member of TYPE.  For copy constructors and assignment operators,
 933    CONST_P indicates whether these functions should take a const
 934    reference argument or a non-const reference.  */
 935
 936 tree
 937 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 938 {
 939   tree declspecs = NULL_TREE;
 940   tree fn, args = NULL_TREE;
 941   tree raises = empty_except_spec;
 942   bool retref = false;
 943   bool has_parm = false;
 944   tree name = constructor_name (type);
 945
 946   switch (kind)
 947     {
 948     case sfk_destructor:
 949       /* Destructor.  */
 950       name = build_nt (BIT_NOT_EXPR, name);
 951       args = void_list_node;
 952       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 953       break;
 954
 955     case sfk_constructor:
 956       /* Default constructor.  */
 957       args = void_list_node;
 958       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 959       break;
 960
 961     case sfk_copy_constructor:
 962     case sfk_assignment_operator:
 963     {
 964       struct copy_data data;
 965       tree argtype = type;
 966
 967       has_parm = true;
 968       data.name = NULL;
 969       data.quals = 0;
 970       if (kind == sfk_assignment_operator)
 971         {
 972           retref = true;
 973           declspecs = build_tree_list (NULL_TREE, type);
 974
 975           name = ansi_assopname (NOP_EXPR);
 976           data.name = name;
 977         }
 978       if (const_p)
 979         {
 980           data.quals = TYPE_QUAL_CONST;
 981           argtype = build_qualified_type (argtype, TYPE_QUAL_CONST);
 982         }
 983
 984       argtype = build_reference_type (argtype);
 985       args = build_tree_list (hash_tree_chain (argtype, NULL_TREE),
 986                               get_identifier ("_ctor_arg"));
 987       args = tree_cons (NULL_TREE, args, void_list_node);
 988
 989       raises = synthesize_exception_spec (type, &locate_copy, &data);
 990       break;
 991     }
 992     default:
 993       abort ();
 994     }
 995
 996   TREE_PARMLIST (args) = 1;
 997
 998   {
 999     tree declarator = make_call_declarator (name, args, NULL_TREE, raises);
1000
1001     if (retref)
1002       declarator = build_nt (ADDR_EXPR, declarator);
1003
1004     fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
1005     if (has_parm)
1006       TREE_USED (FUNCTION_FIRST_USER_PARM (fn)) = 1;
1007   }
1008
1009   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 20000408);
1010
1011   DECL_ARTIFICIAL (fn) = 1;
1012   DECL_NOT_REALLY_EXTERN (fn) = 1;
1013   DECL_DECLARED_INLINE_P (fn) = 1;
1014   DECL_INLINE (fn) = 1;
1015   if (TREE_USED (fn))
1016     abort ();
1017
1018   return fn;
1019 }
1020
1021 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1022    as there are artificial parms in FN.  */
1023
1024 tree
1025 skip_artificial_parms_for (tree fn, tree list)
1026 {
1027   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1028     list = TREE_CHAIN (list);
1029   else
1030     return list;
1031
1032   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1033     list = TREE_CHAIN (list);
1034   if (DECL_HAS_VTT_PARM_P (fn))
1035     list = TREE_CHAIN (list);
1036   return list;
1037 }
1038
1039 #include "gt-cp-method.h"