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