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 Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6    This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22
  23 #ifndef PARM_CAN_BE_ARRAY_TYPE
  24 #define PARM_CAN_BE_ARRAY_TYPE 1
  25 #endif
  26
  27 /* Handle method declarations.  */
  28 #include <stdio.h>
  29 #include "config.h"
  30 #include "tree.h"
  31 #include "cp-tree.h"
  32 #include "class.h"
  33 #include "obstack.h"
  34 #include <ctype.h>
  35 #include "rtl.h"
  36 #include "expr.h"
  37 #include "output.h"
  38 #include "hard-reg-set.h"
  39 #include "flags.h"
  40
  41 /* TREE_LIST of the current inline functions that need to be
  42    processed.  */
  43 struct pending_inline *pending_inlines;
  44
  45 #define obstack_chunk_alloc xmalloc
  46 #define obstack_chunk_free free
  47
  48 /* Obstack where we build text strings for overloading, etc.  */
  49 static struct obstack scratch_obstack;
  50 static char *scratch_firstobj;
  51
  52 # define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0)
  53 # define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C)))
  54 # define OB_PUTC2(C1,C2)        \
  55   (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2)))
  56 # define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1))
  57 # define OB_PUTID(ID)  \
  58   (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID),     \
  59                  IDENTIFIER_LENGTH (ID)))
  60 # define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S)))
  61 # define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
  62
  63 #ifdef NO_AUTO_OVERLOAD
  64 int is_overloaded ();
  65 #endif
  66
  67 void
  68 init_method ()
  69 {
  70   gcc_obstack_init (&scratch_obstack);
  71   scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
  72 }
  73
  74 /* This must be large enough to hold any printed integer or floating-point
  75    value.  */
  76 static char digit_buffer[128];
  77
  78 /* Move inline function definitions out of structure so that they
  79    can be processed normally.  CNAME is the name of the class
  80    we are working from, METHOD_LIST is the list of method lists
  81    of the structure.  We delete friend methods here, after
  82    saving away their inline function definitions (if any).  */
  83
  84 void
  85 do_inline_function_hair (type, friend_list)
  86      tree type, friend_list;
  87 {
  88   tree method = TYPE_METHODS (type);
  89
  90   if (method && TREE_CODE (method) == TREE_VEC)
  91     {
  92       if (TREE_VEC_ELT (method, 0))
  93         method = TREE_VEC_ELT (method, 0);
  94       else
  95         method = TREE_VEC_ELT (method, 1);
  96     }
  97
  98   while (method)
  99     {
 100       /* Do inline member functions.  */
 101       struct pending_inline *info = DECL_PENDING_INLINE_INFO (method);
 102       if (info)
 103         {
 104           tree args;
 105
 106           my_friendly_assert (info->fndecl == method, 238);
 107           args = DECL_ARGUMENTS (method);
 108           while (args)
 109             {
 110               DECL_CONTEXT (args) = method;
 111               args = TREE_CHAIN (args);
 112             }
 113
 114           /* Allow this decl to be seen in global scope.  Don't do this for
 115              local class methods, though.  */
 116           if (! current_function_decl)
 117             IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (method)) = method;
 118         }
 119       method = TREE_CHAIN (method);
 120     }
 121   while (friend_list)
 122     {
 123       tree fndecl = TREE_VALUE (friend_list);
 124       struct pending_inline *info = DECL_PENDING_INLINE_INFO (fndecl);
 125       if (info)
 126         {
 127           tree args;
 128
 129           my_friendly_assert (info->fndecl == fndecl, 239);
 130           args = DECL_ARGUMENTS (fndecl);
 131           while (args)
 132             {
 133               DECL_CONTEXT (args) = fndecl;
 134               args = TREE_CHAIN (args);
 135             }
 136
 137           /* Allow this decl to be seen in global scope */
 138           if (! current_function_decl)
 139             IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (fndecl)) = fndecl;
 140         }
 141
 142       friend_list = TREE_CHAIN (friend_list);
 143     }
 144 }
 145 \f
 146 /* Report an argument type mismatch between the best declared function
 147    we could find and the current argument list that we have.  */
 148 void
 149 report_type_mismatch (cp, parmtypes, name_kind)
 150      struct candidate *cp;
 151      tree parmtypes;
 152      char *name_kind;
 153 {
 154   int i = cp->u.bad_arg;
 155   tree ttf, tta;
 156   char *tmp_firstobj;
 157
 158   switch (i)
 159     {
 160     case -4:
 161       my_friendly_assert (TREE_CODE (cp->function) == TEMPLATE_DECL, 240);
 162       cp_error ("type unification failed for function template `%#D'",
 163                 cp->function);
 164       return;
 165
 166     case -3:
 167       if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes))))
 168         cp_error ("call to const %s `%#D' with non-const object", name_kind,
 169                   cp->function);
 170       else
 171         cp_error ("call to non-const %s `%#D' with const object", name_kind,
 172                   cp->function);
 173       return;
 174     case -2:
 175       cp_error ("too few arguments for %s `%#D'", name_kind, cp->function);
 176       return;
 177     case -1:
 178       cp_error ("too many arguments for %s `%#D'", name_kind, cp->function);
 179       return;
 180     case 0:
 181       if (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
 182         {
 183           /* Happens when we have an ambiguous base class.  */
 184           my_friendly_assert (get_binfo (DECL_CLASS_CONTEXT (cp->function),
 185                              TREE_TYPE (TREE_TYPE (TREE_VALUE (parmtypes))), 1) == error_mark_node,
 186                               241);
 187           return;
 188         }
 189     }
 190
 191   ttf = TYPE_ARG_TYPES (TREE_TYPE (cp->function));
 192   tta = parmtypes;
 193
 194   while (i-- > 0)
 195     {
 196       ttf = TREE_CHAIN (ttf);
 197       tta = TREE_CHAIN (tta);
 198     }
 199
 200   OB_INIT ();
 201   OB_PUTS ("bad argument ");
 202   sprintf (digit_buffer, "%d", cp->u.bad_arg
 203            - (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
 204            + 1);
 205   OB_PUTCP (digit_buffer);
 206
 207   OB_PUTS (" for function `");
 208   OB_PUTCP (decl_as_string (cp->function, 1));
 209   OB_PUTS ("' (type was ");
 210
 211   /* Reset `i' so that type printing routines do the right thing.  */
 212   if (tta)
 213     {
 214       enum tree_code code = TREE_CODE (TREE_TYPE (TREE_VALUE (tta)));
 215       if (code == ERROR_MARK)
 216         OB_PUTS ("(failed type instantiation)");
 217       else
 218         {
 219           i = (code == FUNCTION_TYPE || code == METHOD_TYPE);
 220           OB_PUTCP (type_as_string (TREE_TYPE (TREE_VALUE (tta)), 1));
 221         }
 222     }
 223   else OB_PUTS ("void");
 224   OB_PUTC (')');
 225   OB_FINISH ();
 226
 227   tmp_firstobj = (char *)alloca (obstack_object_size (&scratch_obstack));
 228   bcopy (obstack_base (&scratch_obstack), tmp_firstobj,
 229          obstack_object_size (&scratch_obstack));
 230   error (tmp_firstobj);
 231 }
 232 \f
 233 /* Here is where overload code starts.  */
 234
 235 /* Array of types seen so far in top-level call to `build_overload_name'.
 236    Allocated and deallocated by caller.  */
 237 static tree *typevec;
 238
 239 /* Number of types interned by `build_overload_name' so far.  */
 240 static int maxtype;
 241
 242 /* Number of occurrences of last type seen.  */
 243 static int nrepeats;
 244
 245 /* Nonzero if we should not try folding parameter types.  */
 246 static int nofold;
 247
 248 #define ALLOCATE_TYPEVEC(PARMTYPES) \
 249   do { maxtype = 0, nrepeats = 0; \
 250        typevec = (tree *)alloca (list_length (PARMTYPES) * sizeof (tree)); } while (0)
 251
 252 #define DEALLOCATE_TYPEVEC(PARMTYPES) \
 253   do { tree t = (PARMTYPES); \
 254        while (t) { TREE_USED (TREE_VALUE (t)) = 0; t = TREE_CHAIN (t); } \
 255   } while (0)
 256
 257 /* Code to concatenate an asciified integer to a string.  */
 258 static
 259 #ifdef __GNUC__
 260 __inline
 261 #endif
 262 void
 263 icat (i)
 264      int i;
 265 {
 266   /* Handle this case first, to go really quickly.  For many common values,
 267      the result of i/10 below is 1.  */
 268   if (i == 1)
 269     {
 270       OB_PUTC ('1');
 271       return;
 272     }
 273
 274   if (i < 0)
 275     {
 276       OB_PUTC ('m');
 277       i = -i;
 278     }
 279   if (i < 10)
 280     OB_PUTC ('0' + i);
 281   else
 282     {
 283       icat (i / 10);
 284       OB_PUTC ('0' + (i % 10));
 285     }
 286 }
 287
 288 static
 289 #ifdef __GNUC__
 290 __inline
 291 #endif
 292 void
 293 flush_repeats (type)
 294      tree type;
 295 {
 296   int tindex = 0;
 297
 298   while (typevec[tindex] != type)
 299     tindex++;
 300
 301   if (nrepeats > 1)
 302     {
 303       OB_PUTC ('N');
 304       icat (nrepeats);
 305       if (nrepeats > 9)
 306         OB_PUTC ('_');
 307     }
 308   else
 309     OB_PUTC ('T');
 310   nrepeats = 0;
 311   icat (tindex);
 312   if (tindex > 9)
 313     OB_PUTC ('_');
 314 }
 315
 316 static int numeric_outputed_need_bar;
 317 static void build_overload_identifier ();
 318
 319 static void
 320 build_overload_nested_name (context)
 321      tree context;
 322 {
 323   /* We use DECL_NAME here, because pushtag now sets the DECL_ASSEMBLER_NAME.  */
 324   tree name = DECL_NAME (context);
 325   if (DECL_CONTEXT (context))
 326     {
 327       context = DECL_CONTEXT (context);
 328       if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
 329         context = TYPE_NAME (context);
 330       build_overload_nested_name (context);
 331     }
 332   build_overload_identifier (name);
 333 }
 334
 335 static void
 336 build_overload_value (type, value)
 337      tree type, value;
 338 {
 339   while (TREE_CODE (value) == NON_LVALUE_EXPR
 340          || TREE_CODE (value) == NOP_EXPR)
 341     value = TREE_OPERAND (value, 0);
 342   my_friendly_assert (TREE_CODE (type) == PARM_DECL, 242);
 343   type = TREE_TYPE (type);
 344   switch (TREE_CODE (type))
 345     {
 346     case INTEGER_TYPE:
 347     case ENUMERAL_TYPE:
 348       {
 349         my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243);
 350         if (TYPE_PRECISION (value) == 2 * HOST_BITS_PER_WIDE_INT)
 351           {
 352             if (tree_int_cst_lt (value, integer_zero_node))
 353               {
 354                 OB_PUTC ('m');
 355                 value = build_int_2 (~ TREE_INT_CST_LOW (value),
 356                                      - TREE_INT_CST_HIGH (value));
 357               }
 358             if (TREE_INT_CST_HIGH (value)
 359                 != (TREE_INT_CST_LOW (value) >> (HOST_BITS_PER_WIDE_INT - 1)))
 360               {
 361                 /* need to print a DImode value in decimal */
 362                 sorry ("conversion of long long as PT parameter");
 363               }
 364             /* else fall through to print in smaller mode */
 365           }
 366         /* Wordsize or smaller */
 367         icat (TREE_INT_CST_LOW (value));
 368         return;
 369       }
 370     case BOOLEAN_TYPE:
 371       {
 372         icat (TREE_INT_CST_LOW (value));
 373         return;
 374       }
 375 #ifndef REAL_IS_NOT_DOUBLE
 376     case REAL_TYPE:
 377       {
 378         REAL_VALUE_TYPE val;
 379         char *bufp = digit_buffer;
 380         extern char *index ();
 381
 382         my_friendly_assert (TREE_CODE (value) == REAL_CST, 244);
 383         val = TREE_REAL_CST (value);
 384         if (val < 0)
 385           {
 386             val = -val;
 387             *bufp++ = 'm';
 388           }
 389         sprintf (bufp, "%e", val);
 390         bufp = (char *) index (bufp, 'e');
 391         if (!bufp)
 392           strcat (digit_buffer, "e0");
 393         else
 394           {
 395             char *p;
 396             bufp++;
 397             if (*bufp == '-')
 398               {
 399                 *bufp++ = 'm';
 400               }
 401             p = bufp;
 402             if (*p == '+')
 403               p++;
 404             while (*p == '0')
 405               p++;
 406             if (*p == 0)
 407               {
 408                 *bufp++ = '0';
 409                 *bufp = 0;
 410               }
 411             else if (p != bufp)
 412               {
 413                 while (*p)
 414                   *bufp++ = *p++;
 415                 *bufp = 0;
 416               }
 417           }
 418         OB_PUTCP (digit_buffer);
 419         return;
 420       }
 421 #endif
 422     case POINTER_TYPE:
 423       value = TREE_OPERAND (value, 0);
 424       if (TREE_CODE (value) == VAR_DECL)
 425         {
 426           my_friendly_assert (DECL_NAME (value) != 0, 245);
 427           build_overload_identifier (DECL_NAME (value));
 428           return;
 429         }
 430       else if (TREE_CODE (value) == FUNCTION_DECL)
 431         {
 432           my_friendly_assert (DECL_NAME (value) != 0, 246);
 433           build_overload_identifier (DECL_NAME (value));
 434           return;
 435         }
 436       else
 437         my_friendly_abort (71);
 438       break; /* not really needed */
 439
 440     default:
 441       sorry ("conversion of %s as template parameter",
 442              tree_code_name [(int) TREE_CODE (type)]);
 443       my_friendly_abort (72);
 444     }
 445 }
 446
 447 static void
 448 build_overload_identifier (name)
 449      tree name;
 450 {
 451   if (IDENTIFIER_TEMPLATE (name))
 452     {
 453       tree template, parmlist, arglist, tname;
 454       int i, nparms;
 455       template = IDENTIFIER_TEMPLATE (name);
 456       arglist = TREE_VALUE (template);
 457       template = TREE_PURPOSE (template);
 458       tname = DECL_NAME (template);
 459       parmlist = DECL_ARGUMENTS (template);
 460       nparms = TREE_VEC_LENGTH (parmlist);
 461       OB_PUTC ('t');
 462       icat (IDENTIFIER_LENGTH (tname));
 463       OB_PUTID (tname);
 464       icat (nparms);
 465       for (i = 0; i < nparms; i++)
 466         {
 467           tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i));
 468           tree arg = TREE_VEC_ELT (arglist, i);
 469           if (TREE_CODE (parm) == TYPE_DECL)
 470             {
 471               /* This parameter is a type.  */
 472               OB_PUTC ('Z');
 473               build_overload_name (arg, 0, 0);
 474             }
 475           else
 476             {
 477               /* It's a PARM_DECL.  */
 478               build_overload_name (TREE_TYPE (parm), 0, 0);
 479               build_overload_value (parm, arg);
 480               numeric_outputed_need_bar = 1;
 481             }
 482         }
 483     }
 484   else
 485     {
 486       if (numeric_outputed_need_bar)
 487         {
 488           OB_PUTC ('_');
 489           numeric_outputed_need_bar = 0;
 490         }
 491       icat (IDENTIFIER_LENGTH (name));
 492       OB_PUTID (name);
 493     }
 494 }
 495
 496 /* Given a list of parameters in PARMTYPES, create an unambiguous
 497    overload string. Should distinguish any type that C (or C++) can
 498    distinguish. I.e., pointers to functions are treated correctly.
 499
 500    Caller must deal with whether a final `e' goes on the end or not.
 501
 502    Any default conversions must take place before this function
 503    is called.
 504
 505    BEGIN and END control initialization and finalization of the
 506    obstack where we build the string.  */
 507
 508 char *
 509 build_overload_name (parmtypes, begin, end)
 510      tree parmtypes;
 511      int begin, end;
 512 {
 513   int just_one;
 514   tree parmtype;
 515
 516   if (begin) OB_INIT ();
 517
 518   if ((just_one = (TREE_CODE (parmtypes) != TREE_LIST)))
 519     {
 520       parmtype = parmtypes;
 521       goto only_one;
 522     }
 523
 524   while (parmtypes)
 525     {
 526       parmtype = TREE_VALUE (parmtypes);
 527
 528     only_one:
 529
 530       if (! nofold)
 531         {
 532           if (! just_one)
 533             /* Every argument gets counted.  */
 534             typevec[maxtype++] = parmtype;
 535
 536           if (TREE_USED (parmtype))
 537             {
 538               if (! just_one && parmtype == typevec[maxtype-2])
 539                 nrepeats++;
 540               else
 541                 {
 542                   if (nrepeats)
 543                     flush_repeats (parmtype);
 544                   if (! just_one && TREE_CHAIN (parmtypes)
 545                       && parmtype == TREE_VALUE (TREE_CHAIN (parmtypes)))
 546                     nrepeats++;
 547                   else
 548                     {
 549                       int tindex = 0;
 550
 551                       while (typevec[tindex] != parmtype)
 552                         tindex++;
 553                       OB_PUTC ('T');
 554                       icat (tindex);
 555                       if (tindex > 9)
 556                         OB_PUTC ('_');
 557                     }
 558                 }
 559               goto next;
 560             }
 561           if (nrepeats)
 562             flush_repeats (typevec[maxtype-2]);
 563           if (! just_one
 564               /* Only cache types which take more than one character.  */
 565               && (parmtype != TYPE_MAIN_VARIANT (parmtype)
 566                   || (TREE_CODE (parmtype) != INTEGER_TYPE
 567                       && TREE_CODE (parmtype) != REAL_TYPE)))
 568             TREE_USED (parmtype) = 1;
 569         }
 570
 571       if (TYPE_PTRMEMFUNC_P (parmtype))
 572         parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
 573
 574       if (TREE_READONLY (parmtype))
 575         OB_PUTC ('C');
 576       if (TREE_CODE (parmtype) == INTEGER_TYPE
 577           && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype)))
 578         OB_PUTC ('U');
 579       if (TYPE_VOLATILE (parmtype))
 580         OB_PUTC ('V');
 581
 582       switch (TREE_CODE (parmtype))
 583         {
 584         case OFFSET_TYPE:
 585           OB_PUTC ('O');
 586           build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0);
 587           OB_PUTC ('_');
 588           build_overload_name (TREE_TYPE (parmtype), 0, 0);
 589           break;
 590
 591         case REFERENCE_TYPE:
 592           OB_PUTC ('R');
 593           goto more;
 594
 595         case ARRAY_TYPE:
 596 #if PARM_CAN_BE_ARRAY_TYPE
 597           {
 598             tree length;
 599
 600             OB_PUTC ('A');
 601             if (TYPE_DOMAIN (parmtype) == NULL_TREE)
 602               error ("pointer or reference to array of unknown bound in parm type");
 603             else
 604               {
 605                 length = array_type_nelts (parmtype);
 606                 if (TREE_CODE (length) == INTEGER_CST)
 607                   icat (TREE_INT_CST_LOW (length) + 1);
 608               }
 609             OB_PUTC ('_');
 610             goto more;
 611           }
 612 #else
 613           OB_PUTC ('P');
 614           goto more;
 615 #endif
 616
 617         case POINTER_TYPE:
 618           OB_PUTC ('P');
 619         more:
 620           build_overload_name (TREE_TYPE (parmtype), 0, 0);
 621           break;
 622
 623         case FUNCTION_TYPE:
 624         case METHOD_TYPE:
 625           {
 626             tree firstarg = TYPE_ARG_TYPES (parmtype);
 627             /* Otherwise have to implement reentrant typevecs,
 628                unmark and remark types, etc.  */
 629             int old_nofold = nofold;
 630             nofold = 1;
 631
 632             if (nrepeats)
 633               flush_repeats (typevec[maxtype-1]);
 634
 635             /* @@ It may be possible to pass a function type in
 636                which is not preceded by a 'P'.  */
 637             if (TREE_CODE (parmtype) == FUNCTION_TYPE)
 638               {
 639                 OB_PUTC ('F');
 640                 if (firstarg == NULL_TREE)
 641                   OB_PUTC ('e');
 642                 else if (firstarg == void_list_node)
 643                   OB_PUTC ('v');
 644                 else
 645                   build_overload_name (firstarg, 0, 0);
 646               }
 647             else
 648               {
 649                 int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg)));
 650                 int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg)));
 651                 OB_PUTC ('M');
 652                 firstarg = TREE_CHAIN (firstarg);
 653
 654                 build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0);
 655                 if (constp)
 656                   OB_PUTC ('C');
 657                 if (volatilep)
 658                   OB_PUTC ('V');
 659
 660                 /* For cfront 2.0 compatibility.  */
 661                 OB_PUTC ('F');
 662
 663                 if (firstarg == NULL_TREE)
 664                   OB_PUTC ('e');
 665                 else if (firstarg == void_list_node)
 666                   OB_PUTC ('v');
 667                 else
 668                   build_overload_name (firstarg, 0, 0);
 669               }
 670
 671             /* Separate args from return type.  */
 672             OB_PUTC ('_');
 673             build_overload_name (TREE_TYPE (parmtype), 0, 0);
 674             nofold = old_nofold;
 675             break;
 676           }
 677
 678         case INTEGER_TYPE:
 679           parmtype = TYPE_MAIN_VARIANT (parmtype);
 680           if (parmtype == integer_type_node
 681               || parmtype == unsigned_type_node)
 682             OB_PUTC ('i');
 683           else if (parmtype == long_integer_type_node
 684                    || parmtype == long_unsigned_type_node)
 685             OB_PUTC ('l');
 686           else if (parmtype == short_integer_type_node
 687                    || parmtype == short_unsigned_type_node)
 688             OB_PUTC ('s');
 689           else if (parmtype == signed_char_type_node)
 690             {
 691               OB_PUTC ('S');
 692               OB_PUTC ('c');
 693             }
 694           else if (parmtype == char_type_node
 695                    || parmtype == unsigned_char_type_node)
 696             OB_PUTC ('c');
 697           else if (parmtype == wchar_type_node)
 698             OB_PUTC ('w');
 699           else if (parmtype == long_long_integer_type_node
 700               || parmtype == long_long_unsigned_type_node)
 701             OB_PUTC ('x');
 702 #if 0
 703           /* it would seem there is no way to enter these in source code,
 704              yet.  (mrs) */
 705           else if (parmtype == long_long_long_integer_type_node
 706               || parmtype == long_long_long_unsigned_type_node)
 707             OB_PUTC ('q');
 708 #endif
 709           else
 710             my_friendly_abort (73);
 711           break;
 712
 713         case BOOLEAN_TYPE:
 714           OB_PUTC ('b');
 715           break;
 716
 717         case REAL_TYPE:
 718           parmtype = TYPE_MAIN_VARIANT (parmtype);
 719           if (parmtype == long_double_type_node)
 720             OB_PUTC ('r');
 721           else if (parmtype == double_type_node)
 722             OB_PUTC ('d');
 723           else if (parmtype == float_type_node)
 724             OB_PUTC ('f');
 725           else my_friendly_abort (74);
 726           break;
 727
 728         case VOID_TYPE:
 729           if (! just_one)
 730             {
 731 #if 0
 732               extern tree void_list_node;
 733
 734               /* See if anybody is wasting memory.  */
 735               my_friendly_assert (parmtypes == void_list_node, 247);
 736 #endif
 737               /* This is the end of a parameter list.  */
 738               if (end) OB_FINISH ();
 739               return (char *)obstack_base (&scratch_obstack);
 740             }
 741           OB_PUTC ('v');
 742           break;
 743
 744         case ERROR_MARK:        /* not right, but nothing is anyway */
 745           break;
 746
 747           /* have to do these */
 748         case UNION_TYPE:
 749         case RECORD_TYPE:
 750           if (! just_one)
 751             /* Make this type signature look incompatible
 752                with AT&T.  */
 753             OB_PUTC ('G');
 754           goto common;
 755         case ENUMERAL_TYPE:
 756         common:
 757           {
 758             tree name = TYPE_NAME (parmtype);
 759             int i = 1;
 760
 761             if (TREE_CODE (name) == TYPE_DECL)
 762               {
 763                 tree context = name;
 764                 while (DECL_CONTEXT (context))
 765                   {
 766                     i += 1;
 767                     context = DECL_CONTEXT (context);
 768                     if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
 769                       context = TYPE_NAME (context);
 770                   }
 771                 name = DECL_NAME (name);
 772               }
 773             my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 248);
 774             if (i > 1)
 775               {
 776                 OB_PUTC ('Q');
 777                 if (i > 9)
 778                   OB_PUTC ('_');
 779                 icat (i);
 780                 if (i > 9)
 781                   OB_PUTC ('_');
 782                 numeric_outputed_need_bar = 0;
 783                 build_overload_nested_name (TYPE_NAME (parmtype));
 784               }
 785             else
 786               build_overload_identifier (name);
 787             break;
 788           }
 789
 790         case UNKNOWN_TYPE:
 791           /* This will take some work.  */
 792           OB_PUTC ('?');
 793           break;
 794
 795         case TEMPLATE_TYPE_PARM:
 796         case TEMPLATE_CONST_PARM:
 797         case UNINSTANTIATED_P_TYPE:
 798           /* We don't ever want this output, but it's inconvenient not to
 799              be able to build the string.  This should cause assembler
 800              errors we'll notice.  */
 801           {
 802             static int n;
 803             sprintf (digit_buffer, " *%d", n++);
 804             OB_PUTCP (digit_buffer);
 805           }
 806           break;
 807
 808         default:
 809           my_friendly_abort (75);
 810         }
 811
 812     next:
 813       if (just_one) break;
 814       parmtypes = TREE_CHAIN (parmtypes);
 815     }
 816   if (! just_one)
 817     {
 818       if (nrepeats)
 819         flush_repeats (typevec[maxtype-1]);
 820
 821       /* To get here, parms must end with `...'. */
 822       OB_PUTC ('e');
 823     }
 824
 825   if (end) OB_FINISH ();
 826   return (char *)obstack_base (&scratch_obstack);
 827 }
 828
 829 tree
 830 build_static_name (basetype, name)
 831   tree basetype, name;
 832 {
 833   char *basename  = build_overload_name (basetype, 1, 1);
 834   char *buf = (char *) alloca (IDENTIFIER_LENGTH (name)
 835                                + sizeof (STATIC_NAME_FORMAT)
 836                                + strlen (basename));
 837   sprintf (buf, STATIC_NAME_FORMAT, basename, IDENTIFIER_POINTER (name));
 838   return get_identifier (buf);
 839 }
 840 \f
 841 /* Generate an identifier that encodes the (ANSI) exception TYPE. */
 842
 843 /* This should be part of `ansi_opname', or at least be defined by the std.  */
 844 #define EXCEPTION_NAME_PREFIX "__ex"
 845 #define EXCEPTION_NAME_LENGTH 4
 846
 847 tree
 848 cplus_exception_name (type)
 849      tree type;
 850 {
 851   OB_INIT ();
 852   OB_PUTS (EXCEPTION_NAME_PREFIX);
 853   return get_identifier (build_overload_name (type, 0, 1));
 854 }
 855 \f
 856 /* Change the name of a function definition so that it may be
 857    overloaded. NAME is the name of the function to overload,
 858    PARMS is the parameter list (which determines what name the
 859    final function obtains).
 860
 861    FOR_METHOD is 1 if this overload is being performed
 862    for a method, rather than a function type.  It is 2 if
 863    this overload is being performed for a constructor.  */
 864 tree
 865 build_decl_overload (dname, parms, for_method)
 866      tree dname;
 867      tree parms;
 868      int for_method;
 869 {
 870   char *name = IDENTIFIER_POINTER (dname);
 871
 872   /* member operators new and delete look like methods at this point.  */
 873   if (! for_method && parms != NULL_TREE && TREE_CODE (parms) == TREE_LIST)
 874     {
 875       if (dname == ansi_opname[(int) DELETE_EXPR])
 876         return get_identifier ("__builtin_delete");
 877       else if (dname == ansi_opname[(int) VEC_DELETE_EXPR])
 878         return get_identifier ("__builtin_vec_delete");
 879       else if (TREE_CHAIN (parms) == void_list_node)
 880         {
 881           if (dname == ansi_opname[(int) NEW_EXPR])
 882             return get_identifier ("__builtin_new");
 883           else if (dname == ansi_opname[(int) VEC_NEW_EXPR])
 884             return get_identifier ("__builtin_vec_new");
 885         }
 886     }
 887
 888   OB_INIT ();
 889   if (for_method != 2)
 890     OB_PUTCP (name);
 891   /* Otherwise, we can divine that this is a constructor,
 892      and figure out its name without any extra encoding.  */
 893
 894   OB_PUTC2 ('_', '_');
 895   if (for_method)
 896     {
 897 #if 0
 898       /* We can get away without doing this.  */
 899       OB_PUTC ('M');
 900 #endif
 901       {
 902         tree this_type = TREE_VALUE (parms);
 903
 904         if (TREE_CODE (this_type) == RECORD_TYPE)  /* a signature pointer */
 905           parms = temp_tree_cons (NULL_TREE, SIGNATURE_TYPE (this_type),
 906                                   TREE_CHAIN (parms));
 907         else
 908           parms = temp_tree_cons (NULL_TREE, TREE_TYPE (this_type),
 909                                   TREE_CHAIN (parms));
 910       }
 911     }
 912   else
 913     OB_PUTC ('F');
 914
 915   if (parms == NULL_TREE)
 916     OB_PUTC2 ('e', '\0');
 917   else if (parms == void_list_node)
 918     OB_PUTC2 ('v', '\0');
 919   else
 920     {
 921       ALLOCATE_TYPEVEC (parms);
 922       nofold = 0;
 923       numeric_outputed_need_bar = 0;
 924       if (for_method)
 925         {
 926           build_overload_name (TREE_VALUE (parms), 0, 0);
 927
 928           typevec[maxtype++] = TREE_VALUE (parms);
 929           TREE_USED (TREE_VALUE (parms)) = 1;
 930
 931           if (TREE_CHAIN (parms))
 932             build_overload_name (TREE_CHAIN (parms), 0, 1);
 933           else
 934             OB_PUTC2 ('e', '\0');
 935         }
 936       else
 937         build_overload_name (parms, 0, 1);
 938       DEALLOCATE_TYPEVEC (parms);
 939     }
 940   {
 941     tree n = get_identifier (obstack_base (&scratch_obstack));
 942     if (IDENTIFIER_OPNAME_P (dname))
 943       IDENTIFIER_OPNAME_P (n) = 1;
 944     return n;
 945   }
 946 }
 947
 948 /* Build an overload name for the type expression TYPE.  */
 949 tree
 950 build_typename_overload (type)
 951      tree type;
 952 {
 953   tree id;
 954
 955   OB_INIT ();
 956   OB_PUTID (ansi_opname[(int) TYPE_EXPR]);
 957   nofold = 1;
 958   build_overload_name (type, 0, 1);
 959   id = get_identifier (obstack_base (&scratch_obstack));
 960   IDENTIFIER_OPNAME_P (id) = 1;
 961 #if 0
 962   IDENTIFIER_GLOBAL_VALUE (id) = TYPE_NAME (type);
 963 #endif
 964   TREE_TYPE (id) = type;
 965   return id;
 966 }
 967
 968 #ifndef NO_DOLLAR_IN_LABEL
 969 #define T_DESC_FORMAT "TD$"
 970 #define I_DESC_FORMAT "ID$"
 971 #define M_DESC_FORMAT "MD$"
 972 #else
 973 #if !defined(NO_DOT_IN_LABEL)
 974 #define T_DESC_FORMAT "TD."
 975 #define I_DESC_FORMAT "ID."
 976 #define M_DESC_FORMAT "MD."
 977 #else
 978 #define T_DESC_FORMAT "__t_desc_"
 979 #define I_DESC_FORMAT "__i_desc_"
 980 #define M_DESC_FORMAT "__m_desc_"
 981 #endif
 982 #endif
 983
 984 /* Build an overload name for the type expression TYPE.  */
 985 tree
 986 build_t_desc_overload (type)
 987      tree type;
 988 {
 989   OB_INIT ();
 990   OB_PUTS (T_DESC_FORMAT);
 991   nofold = 1;
 992
 993 #if 0
 994   /* Use a different format if the type isn't defined yet.  */
 995   if (TYPE_SIZE (type) == NULL_TREE)
 996     {
 997       char *p;
 998       int changed;
 999
1000       for (p = tname; *p; p++)
1001         if (isupper (*p))
1002           {
1003             changed = 1;
1004             *p = tolower (*p);
1005           }
1006       /* If there's no change, we have an inappropriate T_DESC_FORMAT.  */
1007       my_friendly_assert (changed != 0, 249);
1008     }
1009 #endif
1010
1011   build_overload_name (type, 0, 1);
1012   return get_identifier (obstack_base (&scratch_obstack));
1013 }
1014
1015 /* Top-level interface to explicit overload requests. Allow NAME
1016    to be overloaded. Error if NAME is already declared for the current
1017    scope. Warning if function is redundantly overloaded. */
1018
1019 void
1020 declare_overloaded (name)
1021      tree name;
1022 {
1023 #ifdef NO_AUTO_OVERLOAD
1024   if (is_overloaded (name))
1025     warning ("function `%s' already declared overloaded",
1026              IDENTIFIER_POINTER (name));
1027   else if (IDENTIFIER_GLOBAL_VALUE (name))
1028     error ("overloading function `%s' that is already defined",
1029            IDENTIFIER_POINTER (name));
1030   else
1031     {
1032       TREE_OVERLOADED (name) = 1;
1033       IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
1034       TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
1035     }
1036 #else
1037   if (current_lang_name == lang_name_cplusplus)
1038     {
1039       if (0)
1040         warning ("functions are implicitly overloaded in C++");
1041     }
1042   else if (current_lang_name == lang_name_c)
1043     error ("overloading function `%s' cannot be done in C language context");
1044   else
1045     my_friendly_abort (76);
1046 #endif
1047 }
1048
1049 #ifdef NO_AUTO_OVERLOAD
1050 /* Check to see if NAME is overloaded. For first approximation,
1051    check to see if its TREE_OVERLOADED is set.  This is used on
1052    IDENTIFIER nodes.  */
1053 int
1054 is_overloaded (name)
1055      tree name;
1056 {
1057   /* @@ */
1058   return (TREE_OVERLOADED (name)
1059           && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
1060           && ! IDENTIFIER_LOCAL_VALUE (name));
1061 }
1062 #endif
1063 \f
1064 /* Given a tree_code CODE, and some arguments (at least one),
1065    attempt to use an overloaded operator on the arguments.
1066
1067    For unary operators, only the first argument need be checked.
1068    For binary operators, both arguments may need to be checked.
1069
1070    Member functions can convert class references to class pointers,
1071    for one-level deep indirection.  More than that is not supported.
1072    Operators [](), ()(), and ->() must be member functions.
1073
1074    We call function call building calls with LOOKUP_COMPLAIN if they
1075    are our only hope.  This is true when we see a vanilla operator
1076    applied to something of aggregate type.  If this fails, we are free
1077    to return `error_mark_node', because we will have reported the
1078    error.
1079
1080    Operators NEW and DELETE overload in funny ways: operator new takes
1081    a single `size' parameter, and operator delete takes a pointer to the
1082    storage being deleted.  When overloading these operators, success is
1083    assumed.  If there is a failure, report an error message and return
1084    `error_mark_node'.  */
1085
1086 /* NOSTRICT */
1087 tree
1088 build_opfncall (code, flags, xarg1, xarg2, arg3)
1089      enum tree_code code;
1090      int flags;
1091      tree xarg1, xarg2, arg3;
1092 {
1093   tree rval = 0;
1094   tree arg1, arg2;
1095   tree type1, type2, fnname;
1096   tree fields1 = 0, parms = 0;
1097   tree global_fn;
1098   int try_second;
1099   int binary_is_unary;
1100
1101   if (xarg1 == error_mark_node)
1102     return error_mark_node;
1103
1104   if (code == COND_EXPR)
1105     {
1106       if (TREE_CODE (xarg2) == ERROR_MARK
1107           || TREE_CODE (arg3) == ERROR_MARK)
1108         return error_mark_node;
1109     }
1110   if (code == COMPONENT_REF)
1111     if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE)
1112       return rval;
1113
1114   /* First, see if we can work with the first argument */
1115   type1 = TREE_TYPE (xarg1);
1116
1117   /* Some tree codes have length > 1, but we really only want to
1118      overload them if their first argument has a user defined type.  */
1119   switch (code)
1120     {
1121     case PREINCREMENT_EXPR:
1122     case PREDECREMENT_EXPR:
1123     case POSTINCREMENT_EXPR:
1124     case POSTDECREMENT_EXPR:
1125     case COMPONENT_REF:
1126       binary_is_unary = 1;
1127       try_second = 0;
1128       break;
1129
1130       /* ARRAY_REFs and CALL_EXPRs must overload successfully.
1131          If they do not, return error_mark_node instead of NULL_TREE.  */
1132     case ARRAY_REF:
1133       if (xarg2 == error_mark_node)
1134         return error_mark_node;
1135     case CALL_EXPR:
1136       rval = error_mark_node;
1137       binary_is_unary = 0;
1138       try_second = 0;
1139       break;
1140
1141     case VEC_NEW_EXPR:
1142     case NEW_EXPR:
1143       {
1144         tree args = tree_cons (NULL_TREE, xarg2, arg3);
1145         fnname = ansi_opname[(int) code];
1146         if (flags & LOOKUP_GLOBAL)
1147           return build_overload_call (fnname, args, flags & LOOKUP_COMPLAIN,
1148                                       (struct candidate *)0);
1149
1150         rval = build_method_call
1151           (build_indirect_ref (build1 (NOP_EXPR, xarg1, error_mark_node),
1152                                "new"),
1153            fnname, args, NULL_TREE, flags);
1154         if (rval == error_mark_node)
1155           /* User might declare fancy operator new, but invoke it
1156              like standard one.  */
1157           return rval;
1158
1159         TREE_TYPE (rval) = xarg1;
1160         TREE_CALLS_NEW (rval) = 1;
1161         return rval;
1162       }
1163       break;
1164
1165     case VEC_DELETE_EXPR:
1166     case DELETE_EXPR:
1167       {
1168         fnname = ansi_opname[(int) code];
1169         if (flags & LOOKUP_GLOBAL)
1170           return build_overload_call (fnname,
1171                                       build_tree_list (NULL_TREE, xarg1),
1172                                       flags & LOOKUP_COMPLAIN,
1173                                       (struct candidate *)0);
1174
1175         rval = build_method_call
1176           (build_indirect_ref (build1 (NOP_EXPR, TREE_TYPE (xarg1),
1177                                        error_mark_node),
1178                                NULL_PTR),
1179            fnname, tree_cons (NULL_TREE, xarg1,
1180                                build_tree_list (NULL_TREE, xarg2)),
1181            NULL_TREE, flags);
1182         /* This happens when the user mis-declares `operator delete'.
1183            Should now be impossible.  */
1184         my_friendly_assert (rval != error_mark_node, 250);
1185         TREE_TYPE (rval) = void_type_node;
1186         return rval;
1187       }
1188       break;
1189
1190     default:
1191       binary_is_unary = 0;
1192       try_second = tree_code_length [(int) code] == 2;
1193       if (try_second && xarg2 == error_mark_node)
1194         return error_mark_node;
1195       break;
1196     }
1197
1198   if (try_second && xarg2 == error_mark_node)
1199     return error_mark_node;
1200
1201   /* What ever it was, we do not know how to deal with it.  */
1202   if (type1 == NULL_TREE)
1203     return rval;
1204
1205   if (TREE_CODE (type1) == OFFSET_TYPE)
1206     type1 = TREE_TYPE (type1);
1207
1208   if (TREE_CODE (type1) == REFERENCE_TYPE)
1209     {
1210       arg1 = convert_from_reference (xarg1);
1211       type1 = TREE_TYPE (arg1);
1212     }
1213   else
1214     {
1215       arg1 = xarg1;
1216     }
1217
1218   if (!IS_AGGR_TYPE (type1) || TYPE_PTRMEMFUNC_P (type1))
1219     {
1220       /* Try to fail. First, fail if unary */
1221       if (! try_second)
1222         return rval;
1223       /* Second, see if second argument is non-aggregate. */
1224       type2 = TREE_TYPE (xarg2);
1225       if (TREE_CODE (type2) == OFFSET_TYPE)
1226         type2 = TREE_TYPE (type2);
1227       if (TREE_CODE (type2) == REFERENCE_TYPE)
1228         {
1229           arg2 = convert_from_reference (xarg2);
1230           type2 = TREE_TYPE (arg2);
1231         }
1232       else
1233         {
1234           arg2 = xarg2;
1235         }
1236
1237       if (!IS_AGGR_TYPE (type2))
1238         return rval;
1239       try_second = 0;
1240     }
1241
1242   if (try_second)
1243     {
1244       /* First arg may succeed; see whether second should.  */
1245       type2 = TREE_TYPE (xarg2);
1246       if (TREE_CODE (type2) == OFFSET_TYPE)
1247         type2 = TREE_TYPE (type2);
1248       if (TREE_CODE (type2) == REFERENCE_TYPE)
1249         {
1250           arg2 = convert_from_reference (xarg2);
1251           type2 = TREE_TYPE (arg2);
1252         }
1253       else
1254         {
1255           arg2 = xarg2;
1256         }
1257
1258       if (! IS_AGGR_TYPE (type2))
1259         try_second = 0;
1260     }
1261
1262   if (type1 == unknown_type_node
1263       || (try_second && TREE_TYPE (xarg2) == unknown_type_node))
1264     {
1265       /* This will not be implemented in the foreseeable future.  */
1266       return rval;
1267     }
1268
1269   if (code == MODIFY_EXPR)
1270     fnname = ansi_assopname[(int) TREE_CODE (arg3)];
1271   else
1272     fnname = ansi_opname[(int) code];
1273
1274   global_fn = lookup_name_nonclass (fnname);
1275
1276   /* This is the last point where we will accept failure.  This
1277      may be too eager if we wish an overloaded operator not to match,
1278      but would rather a normal operator be called on a type-converted
1279      argument.  */
1280
1281   if (IS_AGGR_TYPE (type1))
1282     {
1283       fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0);
1284       /* ARM $13.4.7, prefix/postfix ++/--.  */
1285       if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1286         {
1287           xarg2 = integer_zero_node;
1288           binary_is_unary = 0;
1289
1290           if (fields1)
1291             {
1292               tree t, t2;
1293               int have_postfix = 0;
1294
1295               /* Look for an `operator++ (int)'.  If they didn't have
1296                  one, then we fall back to the old way of doing things.  */
1297               for (t = TREE_VALUE (fields1); t ; t = TREE_CHAIN (t))
1298                 {
1299                   t2 = TYPE_ARG_TYPES (TREE_TYPE (t));
1300                   if (TREE_CHAIN (t2) != NULL_TREE
1301                       && TREE_VALUE (TREE_CHAIN (t2)) == integer_type_node)
1302                     {
1303                       have_postfix = 1;
1304                       break;
1305                     }
1306                 }
1307
1308               if (! have_postfix)
1309                 {
1310                   char *op = POSTINCREMENT_EXPR ? "++" : "--";
1311
1312                   /* There's probably a LOT of code in the world that
1313                      relies upon this old behavior.  So we'll only give this
1314                      warning when we've been given -pedantic.  A few
1315                      releases after 2.4, we'll convert this to be a pedwarn
1316                      or something else more appropriate.  */
1317                   if (pedantic)
1318                     warning ("no `operator%s (int)' declared for postfix `%s'",
1319                              op, op);
1320                   xarg2 = NULL_TREE;
1321                   binary_is_unary = 1;
1322                 }
1323             }
1324         }
1325     }
1326
1327   if (fields1 == NULL_TREE && global_fn == NULL_TREE)
1328     return rval;
1329
1330   /* If RVAL winds up being `error_mark_node', we will return
1331      that... There is no way that normal semantics of these
1332      operators will succeed.  */
1333
1334   /* This argument may be an uncommitted OFFSET_REF.  This is
1335      the case for example when dealing with static class members
1336      which are referenced from their class name rather than
1337      from a class instance.  */
1338   if (TREE_CODE (xarg1) == OFFSET_REF
1339       && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL)
1340     xarg1 = TREE_OPERAND (xarg1, 1);
1341   if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF
1342       && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL)
1343     xarg2 = TREE_OPERAND (xarg2, 1);
1344
1345   if (global_fn)
1346     flags |= LOOKUP_GLOBAL;
1347
1348   if (code == CALL_EXPR)
1349     {
1350       /* This can only be a member function.  */
1351       return build_method_call (xarg1, fnname, xarg2,
1352                                 NULL_TREE, LOOKUP_NORMAL);
1353     }
1354   else if (tree_code_length[(int) code] == 1 || binary_is_unary)
1355     {
1356       parms = NULL_TREE;
1357       rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags);
1358     }
1359   else if (code == COND_EXPR)
1360     {
1361       parms = tree_cons (0, xarg2, build_tree_list (NULL_TREE, arg3));
1362       rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1363     }
1364   else if (code == METHOD_CALL_EXPR)
1365     {
1366       /* must be a member function.  */
1367       parms = tree_cons (NULL_TREE, xarg2, arg3);
1368       return build_method_call (xarg1, fnname, parms, NULL_TREE,
1369                                 LOOKUP_NORMAL);
1370     }
1371   else if (fields1)
1372     {
1373       parms = build_tree_list (NULL_TREE, xarg2);
1374       rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1375     }
1376   else
1377     {
1378       parms = tree_cons (NULL_TREE, xarg1,
1379                          build_tree_list (NULL_TREE, xarg2));
1380       rval = build_overload_call (fnname, parms, flags,
1381                                   (struct candidate *)0);
1382     }
1383
1384   return rval;
1385 }
1386 \f
1387 /* This function takes an identifier, ID, and attempts to figure out what
1388    it means. There are a number of possible scenarios, presented in increasing
1389    order of hair:
1390
1391    1) not in a class's scope
1392    2) in class's scope, member name of the class's method
1393    3) in class's scope, but not a member name of the class
1394    4) in class's scope, member name of a class's variable
1395
1396    NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
1397    VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
1398    yychar is the pending input character (suitably encoded :-).
1399
1400    As a last ditch, try to look up the name as a label and return that
1401    address.
1402
1403    Values which are declared as being of REFERENCE_TYPE are
1404    automatically dereferenced here (as a hack to make the
1405    compiler faster).  */
1406
1407 tree
1408 hack_identifier (value, name, yychar)
1409      tree value, name;
1410      int yychar;
1411 {
1412   tree type;
1413
1414   if (TREE_CODE (value) == ERROR_MARK)
1415     {
1416       if (current_class_name)
1417         {
1418           tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 1);
1419           if (fields == error_mark_node)
1420             return error_mark_node;
1421           if (fields)
1422             {
1423               tree fndecl;
1424
1425               fndecl = TREE_VALUE (fields);
1426               my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
1427               if (DECL_CHAIN (fndecl) == NULL_TREE)
1428                 {
1429                   warning ("methods cannot be converted to function pointers");
1430                   return fndecl;
1431                 }
1432               else
1433                 {
1434                   error ("ambiguous request for method pointer `%s'",
1435                          IDENTIFIER_POINTER (name));
1436                   return error_mark_node;
1437                 }
1438             }
1439         }
1440       if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name))
1441         {
1442           return IDENTIFIER_LABEL_VALUE (name);
1443         }
1444       return error_mark_node;
1445     }
1446
1447   type = TREE_TYPE (value);
1448   if (TREE_CODE (value) == FIELD_DECL)
1449     {
1450       if (current_class_decl == NULL_TREE)
1451         {
1452           error ("request for member `%s' in static member function",
1453                  IDENTIFIER_POINTER (DECL_NAME (value)));
1454           return error_mark_node;
1455         }
1456       TREE_USED (current_class_decl) = 1;
1457       if (yychar == '(')
1458         if (! ((TYPE_LANG_SPECIFIC (type)
1459                 && TYPE_OVERLOADS_CALL_EXPR (type))
1460                || (TREE_CODE (type) == REFERENCE_TYPE
1461                    && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
1462                    && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (type))))
1463             && TREE_CODE (type) != FUNCTION_TYPE
1464             && TREE_CODE (type) != METHOD_TYPE
1465             && !TYPE_PTRMEMFUNC_P (type)
1466             && (TREE_CODE (type) != POINTER_TYPE
1467                 || (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
1468                     && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)))
1469           {
1470             error ("component `%s' is not a method",
1471                    IDENTIFIER_POINTER (name));
1472             return error_mark_node;
1473           }
1474       /* Mark so that if we are in a constructor, and then find that
1475          this field was initialized by a base initializer,
1476          we can emit an error message.  */
1477       TREE_USED (value) = 1;
1478       return build_component_ref (C_C_D, name, 0, 1);
1479     }
1480
1481   if (really_overloaded_fn (value))
1482     {
1483       tree t = get_first_fn (value);
1484       for (; t; t = DECL_CHAIN (t))
1485         {
1486           if (TREE_CODE (t) == TEMPLATE_DECL)
1487             continue;
1488
1489           assemble_external (t);
1490           TREE_USED (t) = 1;
1491         }
1492     }
1493   else if (TREE_CODE (value) == TREE_LIST)
1494     {
1495       tree t = value;
1496       while (t && TREE_CODE (t) == TREE_LIST)
1497         {
1498           assemble_external (TREE_VALUE (t));
1499           TREE_USED (t) = 1;
1500           t = TREE_CHAIN (t);
1501         }
1502     }
1503   else
1504     {
1505       assemble_external (value);
1506       TREE_USED (value) = 1;
1507     }
1508
1509   if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && DECL_NONLOCAL (value))
1510     {
1511       if (DECL_LANG_SPECIFIC (value)
1512           && DECL_CLASS_CONTEXT (value) != current_class_type)
1513         {
1514           tree path;
1515           enum access_type access;
1516           register tree context
1517             = (TREE_CODE (value) == FUNCTION_DECL && DECL_VIRTUAL_P (value))
1518               ? DECL_CLASS_CONTEXT (value)
1519               : DECL_CONTEXT (value);
1520
1521           get_base_distance (context, current_class_type, 0, &path);
1522           if (path)
1523             {
1524               access = compute_access (path, value);
1525               if (access != access_public)
1526                 {
1527                   if (TREE_CODE (value) == VAR_DECL)
1528                     error ("static member `%s' is %s",
1529                            IDENTIFIER_POINTER (name),
1530                            TREE_PRIVATE (value) ? "private" :
1531                            "from a private base class");
1532                   else
1533                     error ("enum `%s' is from private base class",
1534                            IDENTIFIER_POINTER (name));
1535                   return error_mark_node;
1536                 }
1537             }
1538         }
1539       return value;
1540     }
1541   if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value))
1542     {
1543       if (type == 0)
1544         {
1545           error ("request for member `%s' is ambiguous in multiple inheritance lattice",
1546                  IDENTIFIER_POINTER (name));
1547           return error_mark_node;
1548         }
1549
1550       return value;
1551     }
1552
1553   if (TREE_CODE (type) == REFERENCE_TYPE)
1554     {
1555       my_friendly_assert (TREE_CODE (value) == VAR_DECL
1556                           || TREE_CODE (value) == PARM_DECL
1557                           || TREE_CODE (value) == RESULT_DECL, 252);
1558       if (DECL_REFERENCE_SLOT (value))
1559         return DECL_REFERENCE_SLOT (value);
1560     }
1561   return value;
1562 }
1563
1564 \f
1565 #if 0
1566 /* Given an object OF, and a type conversion operator COMPONENT
1567    build a call to the conversion operator, if a call is requested,
1568    or return the address (as a pointer to member function) if one is not.
1569
1570    OF can be a TYPE_DECL or any kind of datum that would normally
1571    be passed to `build_component_ref'.  It may also be NULL_TREE,
1572    in which case `current_class_type' and `current_class_decl'
1573    provide default values.
1574
1575    BASETYPE_PATH, if non-null, is the path of basetypes
1576    to go through before we get the the instance of interest.
1577
1578    PROTECT says whether we apply C++ scoping rules or not.  */
1579 tree
1580 build_component_type_expr (of, component, basetype_path, protect)
1581      tree of, component, basetype_path;
1582      int protect;
1583 {
1584   tree cname = NULL_TREE;
1585   tree tmp, last;
1586   tree name;
1587   int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN;
1588
1589   if (of)
1590     my_friendly_assert (IS_AGGR_TYPE (TREE_TYPE (of)), 253);
1591   my_friendly_assert (TREE_CODE (component) == TYPE_EXPR, 254);
1592
1593   tmp = TREE_OPERAND (component, 0);
1594   last = NULL_TREE;
1595
1596   while (tmp)
1597     {
1598       switch (TREE_CODE (tmp))
1599         {
1600         case CALL_EXPR:
1601           if (last)
1602             TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
1603           else
1604             TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0);
1605
1606           last = groktypename (build_tree_list (TREE_TYPE (component),
1607                                                 TREE_OPERAND (component, 0)));
1608           name = build_typename_overload (last);
1609           TREE_TYPE (name) = last;
1610
1611           if (TREE_OPERAND (tmp, 0)
1612               && TREE_OPERAND (tmp, 0) != void_list_node)
1613             {
1614               cp_error ("`operator %T' requires empty parameter list", last);
1615               TREE_OPERAND (tmp, 0) = NULL_TREE;
1616             }
1617
1618           if (of && TREE_CODE (of) != TYPE_DECL)
1619             return build_method_call (of, name, NULL_TREE, NULL_TREE, flags);
1620           else if (of)
1621             {
1622               tree this_this;
1623
1624               if (current_class_decl == NULL_TREE)
1625                 {
1626                   cp_error ("object required for `operator %T' call",
1627                             TREE_TYPE (name));
1628                   return error_mark_node;
1629                 }
1630
1631               this_this = convert_pointer_to (TREE_TYPE (of),
1632                                               current_class_decl);
1633               this_this = build_indirect_ref (this_this, NULL_PTR);
1634               return build_method_call (this_this, name, NULL_TREE,
1635                                         NULL_TREE, flags | LOOKUP_NONVIRTUAL);
1636             }
1637           else if (current_class_decl)
1638             return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags);
1639
1640           cp_error ("object required for `operator %T' call",
1641                     TREE_TYPE (name));
1642           return error_mark_node;
1643
1644         case INDIRECT_REF:
1645         case ADDR_EXPR:
1646         case ARRAY_REF:
1647           break;
1648
1649         case SCOPE_REF:
1650           my_friendly_assert (cname == 0, 255);
1651           cname = TREE_OPERAND (tmp, 0);
1652           tmp = TREE_OPERAND (tmp, 1);
1653           break;
1654
1655         default:
1656           my_friendly_abort (77);
1657         }
1658       last = tmp;
1659       tmp = TREE_OPERAND (tmp, 0);
1660     }
1661
1662   last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0)));
1663   name = build_typename_overload (last);
1664   TREE_TYPE (name) = last;
1665   if (of && TREE_CODE (of) == TYPE_DECL)
1666     {
1667       if (cname == NULL_TREE)
1668         {
1669           cname = DECL_NAME (of);
1670           of = NULL_TREE;
1671         }
1672       else my_friendly_assert (cname == DECL_NAME (of), 256);
1673     }
1674
1675   if (of)
1676     {
1677       tree this_this;
1678
1679       if (current_class_decl == NULL_TREE)
1680         {
1681           cp_error ("object required for `operator %T' call",
1682                     TREE_TYPE (name));
1683           return error_mark_node;
1684         }
1685
1686       this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
1687       return build_component_ref (this_this, name, 0, protect);
1688     }
1689   else if (cname)
1690     return build_offset_ref (cname, name);
1691   else if (current_class_name)
1692     return build_offset_ref (current_class_name, name);
1693
1694   cp_error ("object required for `operator %T' member reference",
1695             TREE_TYPE (name));
1696   return error_mark_node;
1697 }
1698 #endif
1699 \f
1700 static char *
1701 thunk_printable_name (decl)
1702      tree decl;
1703 {
1704   return "<thunk function>";
1705 }
1706
1707 tree
1708 make_thunk (function, delta)
1709      tree function;
1710      int delta;
1711 {
1712   char buffer[250];
1713   tree thunk_fndecl, thunk_id;
1714   tree thunk;
1715   char *func_name;
1716   static int thunk_number = 0;
1717   tree func_decl;
1718   if (TREE_CODE (function) != ADDR_EXPR)
1719     abort ();
1720   func_decl = TREE_OPERAND (function, 0);
1721   if (TREE_CODE (func_decl) != FUNCTION_DECL)
1722     abort ();
1723   func_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func_decl));
1724   sprintf (buffer, "__thunk_%d_%s", -delta, func_name);
1725   thunk_id = get_identifier (buffer);
1726   thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id);
1727   if (thunk && TREE_CODE (thunk) != THUNK_DECL)
1728     {
1729       error_with_decl ("implementation-reserved name `%s' used");
1730       IDENTIFIER_GLOBAL_VALUE (thunk_id) = thunk = NULL_TREE;
1731     }
1732   if (thunk == NULL_TREE)
1733     {
1734       thunk = build_decl (THUNK_DECL, thunk_id, TREE_TYPE (func_decl));
1735       DECL_RESULT (thunk)
1736         = build_decl (RESULT_DECL, NULL_TREE, TREE_TYPE (vtable_entry_type));
1737       make_function_rtl (thunk);
1738       DECL_INITIAL (thunk) = function;
1739       THUNK_DELTA (thunk) = delta;
1740       /* So that finish_file can write out any thunks that need to be: */
1741       pushdecl_top_level (thunk);
1742     }
1743   return thunk;
1744 }
1745
1746 void
1747 emit_thunk (thunk_fndecl)
1748   tree thunk_fndecl;
1749 {
1750   rtx insns;
1751   char *fnname;
1752   char buffer[250];
1753   tree argp;
1754   struct args_size stack_args_size;
1755   tree function = TREE_OPERAND (DECL_INITIAL (thunk_fndecl), 0);
1756   int delta = THUNK_DELTA (thunk_fndecl);
1757   int tem;
1758   int failure = 0;
1759   int current_call_is_indirect = 0;     /* needed for HPPA FUNCTION_ARG */
1760
1761   /* Used to remember which regs we need to emit a USE rtx for. */
1762   rtx need_use[FIRST_PSEUDO_REGISTER];
1763   int need_use_count = 0;
1764
1765   /* rtx for the 'this' parameter. */
1766   rtx this_rtx = 0, this_reg_rtx = 0, fixed_this_rtx;
1767
1768   char *(*save_decl_printable_name) () = decl_printable_name;
1769   /* Data on reg parms scanned so far.  */
1770   CUMULATIVE_ARGS args_so_far;
1771
1772   if (TREE_ASM_WRITTEN (thunk_fndecl))
1773     return;
1774
1775   TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1776
1777   if (TREE_PUBLIC (function))
1778     {
1779       TREE_PUBLIC (thunk_fndecl) = 1;
1780       if (DECL_EXTERNAL (function))
1781         {
1782           DECL_EXTERNAL (thunk_fndecl) = 1;
1783           assemble_external (thunk_fndecl);
1784           return;
1785         }
1786     }
1787
1788   decl_printable_name = thunk_printable_name;
1789   if (current_function_decl)
1790     abort ();
1791   current_function_decl = thunk_fndecl;
1792   init_function_start (thunk_fndecl, input_filename, lineno);
1793   pushlevel (0);
1794   expand_start_bindings (1);
1795
1796   /* Start updating where the next arg would go.  */
1797   INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (function), NULL_RTX);
1798   stack_args_size.constant = 0;
1799   stack_args_size.var = 0;
1800   /* SETUP for possible structure return address FIXME */
1801
1802   /* Now look through all the parameters, make sure that we
1803      don't clobber any registers used for parameters.
1804      Also, pick up an rtx for the first "this" parameter. */
1805   for (argp = TYPE_ARG_TYPES (TREE_TYPE (function));
1806        argp != NULL_TREE;
1807        argp = TREE_CHAIN (argp))
1808
1809     {
1810       tree passed_type = TREE_VALUE (argp);
1811       register rtx entry_parm;
1812       int named = 1; /* FIXME */
1813       struct args_size stack_offset;
1814       struct args_size arg_size;
1815
1816       if (passed_type == void_type_node)
1817         break;
1818
1819       if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
1820            && contains_placeholder_p (TYPE_SIZE (passed_type)))
1821 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1822           || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far,
1823                                              TYPE_MODE (passed_type),
1824                                              passed_type, named)
1825 #endif
1826           )
1827         passed_type = build_pointer_type (passed_type);
1828
1829       entry_parm = FUNCTION_ARG (args_so_far,
1830                                  TYPE_MODE (passed_type),
1831                                  passed_type,
1832                                  named);
1833       if (entry_parm != 0)
1834         need_use[need_use_count++] = entry_parm;
1835
1836       locate_and_pad_parm (TYPE_MODE (passed_type), passed_type,
1837 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1838                            1,
1839 #else
1840                            entry_parm != 0,
1841 #endif
1842                            thunk_fndecl,
1843                            &stack_args_size, &stack_offset, &arg_size);
1844
1845 /*    REGNO (entry_parm);*/
1846       if (this_rtx == 0)
1847         {
1848           this_reg_rtx = entry_parm;
1849           if (!entry_parm)
1850             {
1851               rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
1852
1853               rtx internal_arg_pointer, stack_parm;
1854
1855               if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
1856                    || ! (fixed_regs[ARG_POINTER_REGNUM]
1857                          || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
1858                 internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
1859               else
1860                 internal_arg_pointer = virtual_incoming_args_rtx;
1861
1862               if (offset_rtx == const0_rtx)
1863                 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1864                                       internal_arg_pointer);
1865               else
1866                 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1867                                       gen_rtx (PLUS, Pmode,
1868                                                internal_arg_pointer,
1869                                                offset_rtx));
1870             }
1871
1872           this_rtx = entry_parm;
1873         }
1874
1875       FUNCTION_ARG_ADVANCE (args_so_far,
1876                             TYPE_MODE (passed_type),
1877                             passed_type,
1878                             named);
1879     }
1880
1881   fixed_this_rtx = plus_constant (this_rtx, delta);
1882   if (this_rtx != fixed_this_rtx)
1883     emit_move_insn (this_rtx, fixed_this_rtx);
1884
1885   if (this_reg_rtx)
1886     emit_insn (gen_rtx (USE, VOIDmode, this_reg_rtx));
1887
1888   emit_indirect_jump (XEXP (DECL_RTL (function), 0));
1889
1890   while (need_use_count > 0)
1891     emit_insn (gen_rtx (USE, VOIDmode, need_use[--need_use_count]));
1892
1893   expand_end_bindings (NULL, 1, 0);
1894   poplevel (0, 0, 0);
1895
1896   /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
1897      Note that that may have been done above, in save_for_inline_copying.
1898      The call to resume_temporary_allocation near the end of this function
1899      goes back to the usual state of affairs.  */
1900
1901   rtl_in_current_obstack ();
1902
1903   insns = get_insns ();
1904
1905   /* Copy any shared structure that should not be shared.  */
1906
1907   unshare_all_rtl (insns);
1908
1909   /* We are no longer anticipating cse in this function, at least.  */
1910
1911   cse_not_expected = 1;
1912
1913   /* Now we choose between stupid (pcc-like) register allocation
1914      (if we got the -noreg switch and not -opt)
1915      and smart register allocation.  */
1916
1917   if (optimize > 0)                     /* Stupid allocation probably won't work */
1918     obey_regdecls = 0;          /* if optimizations being done.  */
1919
1920   regclass_init ();
1921
1922   regclass (insns, max_reg_num ());
1923   if (obey_regdecls)
1924     {
1925       stupid_life_analysis (insns, max_reg_num (), NULL);
1926       failure = reload (insns, 0, NULL);
1927     }
1928   else
1929     {
1930       /* Do control and data flow analysis,
1931          and write some of the results to dump file.  */
1932
1933       flow_analysis (insns, max_reg_num (), NULL);
1934       local_alloc ();
1935       failure = global_alloc (NULL);
1936     }
1937
1938   reload_completed = 1;
1939
1940 #ifdef LEAF_REGISTERS
1941   leaf_function = 0;
1942   if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
1943     leaf_function = 1;
1944 #endif
1945
1946   /* If a machine dependent reorganization is needed, call it.  */
1947 #ifdef MACHINE_DEPENDENT_REORG
1948    MACHINE_DEPENDENT_REORG (insns);
1949 #endif
1950
1951   /* Now turn the rtl into assembler code.  */
1952
1953     {
1954       char *fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
1955       assemble_start_function (thunk_fndecl, fnname);
1956       final (insns, asm_out_file, optimize, 0);
1957       assemble_end_function (thunk_fndecl, fnname);
1958     };
1959
1960  exit_rest_of_compilation:
1961
1962   reload_completed = 0;
1963
1964   /* Cancel the effect of rtl_in_current_obstack.  */
1965
1966   resume_temporary_allocation ();
1967
1968   decl_printable_name = save_decl_printable_name;
1969   current_function_decl = 0;
1970 }
1971 \f
1972 /* Code for synthesizing methods which have default semantics defined.  */
1973
1974 void
1975 build_default_constructor (fndecl)
1976      tree fndecl;
1977 {
1978   start_function (NULL_TREE, fndecl, NULL_TREE, 1);
1979   store_parm_decls ();
1980   setup_vtbl_ptr ();
1981   finish_function (lineno, 0);
1982 }
1983
1984 /* For the anonymous union in TYPE, return the member that is at least as
1985    large as the rest of the members, so we can copy it.  */
1986 static tree
1987 largest_union_member (type)
1988      tree type;
1989 {
1990   tree f, type_size = TYPE_SIZE (type);
1991
1992   for (f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f))
1993     if (simple_cst_equal (DECL_SIZE (f), type_size))
1994       return f;
1995
1996   /* We should always find one.  */
1997   my_friendly_abort (323);
1998   return NULL_TREE;
1999 }
2000
2001 /* Generate code for default X(X&) constructor.  */
2002 void
2003 build_copy_constructor (fndecl)
2004      tree fndecl;
2005 {
2006   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
2007   tree t;
2008
2009   start_function (NULL_TREE, fndecl, NULL_TREE, 1);
2010   store_parm_decls ();
2011   clear_last_expr ();
2012   push_momentary ();
2013
2014   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
2015     parm = TREE_CHAIN (parm);
2016   parm = convert_from_reference (parm);
2017
2018   if (! TYPE_HAS_COMPLEX_INIT_REF (current_class_type))
2019     {
2020       t = build (INIT_EXPR, void_type_node, C_C_D, parm);
2021       TREE_SIDE_EFFECTS (t) = 1;
2022       cplus_expand_expr_stmt (t);
2023     }
2024   else
2025     {
2026       tree fields = TYPE_FIELDS (current_class_type);
2027       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
2028       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
2029       int i;
2030
2031       for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
2032            t = TREE_CHAIN (t))
2033         {
2034           tree basetype = BINFO_TYPE (t);
2035           tree p = convert (build_reference_type (basetype), parm);
2036           p = convert_from_reference (p);
2037           current_base_init_list = tree_cons (TYPE_NESTED_NAME (basetype),
2038                                               p, current_base_init_list);
2039         }
2040
2041       for (i = 0; i < n_bases; ++i)
2042         {
2043           tree p, basetype = TREE_VEC_ELT (binfos, i);
2044           if (TREE_VIA_VIRTUAL (basetype))
2045             continue;
2046
2047           basetype = BINFO_TYPE (basetype);
2048           p = convert (build_reference_type (basetype), parm);
2049           p = convert_from_reference (p);
2050           current_base_init_list = tree_cons (TYPE_NESTED_NAME (basetype),
2051                                               p, current_base_init_list);
2052         }
2053       for (; fields; fields = TREE_CHAIN (fields))
2054         {
2055           tree name, init, t;
2056           if (TREE_CODE (fields) != FIELD_DECL)
2057             continue;
2058           if (DECL_NAME (fields))
2059             {
2060               if (VFIELD_NAME_P (DECL_NAME (fields)))
2061                 continue;
2062               if (VBASE_NAME_P (DECL_NAME (fields)))
2063                 continue;
2064
2065               /* True for duplicate members.  */
2066               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) != fields)
2067                 continue;
2068             }
2069           else if ((t = TREE_TYPE (fields)) != NULL_TREE
2070                    && TREE_CODE (t) == UNION_TYPE
2071                    && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))
2072                    && TYPE_FIELDS (t) != NULL_TREE)
2073             fields = largest_union_member (t);
2074           else
2075             continue;
2076
2077           init = build (COMPONENT_REF, TREE_TYPE (fields), parm, fields);
2078           init = build_tree_list (NULL_TREE, init);
2079
2080           current_member_init_list
2081             = tree_cons (DECL_NAME (fields), init, current_member_init_list);
2082         }
2083       current_member_init_list = nreverse (current_member_init_list);
2084       setup_vtbl_ptr ();
2085     }
2086
2087   pop_momentary ();
2088   finish_function (lineno, 0);
2089 }
2090
2091 void
2092 build_assign_ref (fndecl)
2093      tree fndecl;
2094 {
2095   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
2096
2097   start_function (NULL_TREE, fndecl, NULL_TREE, 1);
2098   store_parm_decls ();
2099   push_momentary ();
2100
2101   parm = convert_from_reference (parm);
2102
2103   if (! TYPE_HAS_COMPLEX_ASSIGN_REF (current_class_type))
2104     {
2105       tree t = build (MODIFY_EXPR, void_type_node, C_C_D, parm);
2106       TREE_SIDE_EFFECTS (t) = 1;
2107       cplus_expand_expr_stmt (t);
2108     }
2109   else
2110     {
2111       tree fields = TYPE_FIELDS (current_class_type);
2112       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
2113       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
2114       int i;
2115
2116       for (i = 0; i < n_bases; ++i)
2117         {
2118           tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
2119           if (TYPE_HAS_ASSIGN_REF (basetype))
2120             {
2121               tree p = convert (build_reference_type (basetype), parm);
2122               p = convert_from_reference (p);
2123               p = build_member_call (TYPE_NESTED_NAME (basetype),
2124                                      ansi_opname [MODIFY_EXPR],
2125                                      build_tree_list (NULL_TREE, p));
2126               expand_expr_stmt (p);
2127             }
2128         }
2129       for (; fields; fields = TREE_CHAIN (fields))
2130         {
2131           tree comp, init, t;
2132           if (TREE_CODE (fields) != FIELD_DECL)
2133             continue;
2134           if (DECL_NAME (fields))
2135             {
2136               if (VFIELD_NAME_P (DECL_NAME (fields)))
2137                 continue;
2138               if (VBASE_NAME_P (DECL_NAME (fields)))
2139                 continue;
2140
2141               /* True for duplicate members.  */
2142               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) != fields)
2143                 continue;
2144             }
2145           else if ((t = TREE_TYPE (fields)) != NULL_TREE
2146                    && TREE_CODE (t) == UNION_TYPE
2147                    && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))
2148                    && TYPE_FIELDS (t) != NULL_TREE)
2149             fields = largest_union_member (t);
2150           else
2151             continue;
2152
2153           comp = build (COMPONENT_REF, TREE_TYPE (fields), C_C_D, fields);
2154           init = build (COMPONENT_REF, TREE_TYPE (fields), parm, fields);
2155
2156           expand_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
2157         }
2158     }
2159   c_expand_return (C_C_D);
2160   pop_momentary ();
2161   finish_function (lineno, 0);
2162 }
2163
2164 void
2165 build_dtor (fndecl)
2166      tree fndecl;
2167 {
2168   start_function (NULL_TREE, fndecl, NULL_TREE, 1);
2169   store_parm_decls ();
2170   finish_function (lineno, 0);
2171 }