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