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 void build_overload_identifier ();
 317
 318 static void
 319 build_overload_nested_name (context)
 320      tree context;
 321 {
 322   /* We use DECL_NAME here, because pushtag now sets the DECL_ASSEMBLER_NAME.  */
 323   tree name = DECL_NAME (context);
 324   if (DECL_CONTEXT (context))
 325     {
 326       context = DECL_CONTEXT (context);
 327       if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
 328         context = TYPE_NAME (context);
 329       build_overload_nested_name (context);
 330     }
 331   build_overload_identifier (name);
 332 }
 333
 334 static void
 335 build_overload_value (type, value)
 336      tree type, value;
 337 {
 338   while (TREE_CODE (value) == NON_LVALUE_EXPR
 339          || TREE_CODE (value) == NOP_EXPR)
 340     value = TREE_OPERAND (value, 0);
 341   my_friendly_assert (TREE_CODE (type) == PARM_DECL, 242);
 342   type = TREE_TYPE (type);
 343   switch (TREE_CODE (type))
 344     {
 345     case INTEGER_TYPE:
 346     case ENUMERAL_TYPE:
 347       {
 348         my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243);
 349         if (TYPE_PRECISION (value) == 2 * HOST_BITS_PER_WIDE_INT)
 350           {
 351             if (tree_int_cst_lt (value, integer_zero_node))
 352               {
 353                 OB_PUTC ('m');
 354                 value = build_int_2 (~ TREE_INT_CST_LOW (value),
 355                                      - TREE_INT_CST_HIGH (value));
 356               }
 357             if (TREE_INT_CST_HIGH (value)
 358                 != (TREE_INT_CST_LOW (value) >> (HOST_BITS_PER_WIDE_INT - 1)))
 359               {
 360                 /* need to print a DImode value in decimal */
 361                 sorry ("conversion of long long as PT parameter");
 362               }
 363             /* else fall through to print in smaller mode */
 364           }
 365         /* Wordsize or smaller */
 366         icat (TREE_INT_CST_LOW (value));
 367         return;
 368       }
 369     case BOOLEAN_TYPE:
 370       {
 371         icat (TREE_INT_CST_LOW (value));
 372         return;
 373       }
 374 #ifndef REAL_IS_NOT_DOUBLE
 375     case REAL_TYPE:
 376       {
 377         REAL_VALUE_TYPE val;
 378         char *bufp = digit_buffer;
 379         extern char *index ();
 380
 381         my_friendly_assert (TREE_CODE (value) == REAL_CST, 244);
 382         val = TREE_REAL_CST (value);
 383         if (val < 0)
 384           {
 385             val = -val;
 386             *bufp++ = 'm';
 387           }
 388         sprintf (bufp, "%e", val);
 389         bufp = (char *) index (bufp, 'e');
 390         if (!bufp)
 391           strcat (digit_buffer, "e0");
 392         else
 393           {
 394             char *p;
 395             bufp++;
 396             if (*bufp == '-')
 397               {
 398                 *bufp++ = 'm';
 399               }
 400             p = bufp;
 401             if (*p == '+')
 402               p++;
 403             while (*p == '0')
 404               p++;
 405             if (*p == 0)
 406               {
 407                 *bufp++ = '0';
 408                 *bufp = 0;
 409               }
 410             else if (p != bufp)
 411               {
 412                 while (*p)
 413                   *bufp++ = *p++;
 414                 *bufp = 0;
 415               }
 416           }
 417         OB_PUTCP (digit_buffer);
 418         return;
 419       }
 420 #endif
 421     case POINTER_TYPE:
 422       value = TREE_OPERAND (value, 0);
 423       if (TREE_CODE (value) == VAR_DECL)
 424         {
 425           my_friendly_assert (DECL_NAME (value) != 0, 245);
 426           build_overload_identifier (DECL_NAME (value));
 427           return;
 428         }
 429       else if (TREE_CODE (value) == FUNCTION_DECL)
 430         {
 431           my_friendly_assert (DECL_NAME (value) != 0, 246);
 432           build_overload_identifier (DECL_NAME (value));
 433           return;
 434         }
 435       else
 436         my_friendly_abort (71);
 437       break; /* not really needed */
 438
 439     default:
 440       sorry ("conversion of %s as template parameter",
 441              tree_code_name [(int) TREE_CODE (type)]);
 442       my_friendly_abort (72);
 443     }
 444 }
 445
 446 static void
 447 build_overload_identifier (name)
 448      tree name;
 449 {
 450   if (IDENTIFIER_TEMPLATE (name))
 451     {
 452       tree template, parmlist, arglist, tname;
 453       int i, nparms;
 454       template = IDENTIFIER_TEMPLATE (name);
 455       arglist = TREE_VALUE (template);
 456       template = TREE_PURPOSE (template);
 457       tname = DECL_NAME (template);
 458       parmlist = DECL_ARGUMENTS (template);
 459       nparms = TREE_VEC_LENGTH (parmlist);
 460       OB_PUTC ('t');
 461       icat (IDENTIFIER_LENGTH (tname));
 462       OB_PUTID (tname);
 463       icat (nparms);
 464       for (i = 0; i < nparms; i++)
 465         {
 466           tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i));
 467           tree arg = TREE_VEC_ELT (arglist, i);
 468           if (TREE_CODE (parm) == TYPE_DECL)
 469             {
 470               /* This parameter is a type.  */
 471               OB_PUTC ('Z');
 472               build_overload_name (arg, 0, 0);
 473             }
 474           else
 475             {
 476               /* It's a PARM_DECL.  */
 477               build_overload_name (TREE_TYPE (parm), 0, 0);
 478               build_overload_value (parm, arg);
 479             }
 480         }
 481     }
 482   else
 483     {
 484       icat (IDENTIFIER_LENGTH (name));
 485       OB_PUTID (name);
 486     }
 487 }
 488
 489 /* Given a list of parameters in PARMTYPES, create an unambiguous
 490    overload string. Should distinguish any type that C (or C++) can
 491    distinguish. I.e., pointers to functions are treated correctly.
 492
 493    Caller must deal with whether a final `e' goes on the end or not.
 494
 495    Any default conversions must take place before this function
 496    is called.
 497
 498    BEGIN and END control initialization and finalization of the
 499    obstack where we build the string.  */
 500
 501 char *
 502 build_overload_name (parmtypes, begin, end)
 503      tree parmtypes;
 504      int begin, end;
 505 {
 506   int just_one;
 507   tree parmtype;
 508
 509   if (begin) OB_INIT ();
 510
 511   if ((just_one = (TREE_CODE (parmtypes) != TREE_LIST)))
 512     {
 513       parmtype = parmtypes;
 514       goto only_one;
 515     }
 516
 517   while (parmtypes)
 518     {
 519       parmtype = TREE_VALUE (parmtypes);
 520
 521     only_one:
 522
 523       if (! nofold)
 524         {
 525           if (! just_one)
 526             /* Every argument gets counted.  */
 527             typevec[maxtype++] = parmtype;
 528
 529           if (TREE_USED (parmtype))
 530             {
 531               if (! just_one && parmtype == typevec[maxtype-2])
 532                 nrepeats++;
 533               else
 534                 {
 535                   if (nrepeats)
 536                     flush_repeats (parmtype);
 537                   if (! just_one && TREE_CHAIN (parmtypes)
 538                       && parmtype == TREE_VALUE (TREE_CHAIN (parmtypes)))
 539                     nrepeats++;
 540                   else
 541                     {
 542                       int tindex = 0;
 543
 544                       while (typevec[tindex] != parmtype)
 545                         tindex++;
 546                       OB_PUTC ('T');
 547                       icat (tindex);
 548                       if (tindex > 9)
 549                         OB_PUTC ('_');
 550                     }
 551                 }
 552               goto next;
 553             }
 554           if (nrepeats)
 555             flush_repeats (typevec[maxtype-2]);
 556           if (! just_one
 557               /* Only cache types which take more than one character.  */
 558               && (parmtype != TYPE_MAIN_VARIANT (parmtype)
 559                   || (TREE_CODE (parmtype) != INTEGER_TYPE
 560                       && TREE_CODE (parmtype) != REAL_TYPE)))
 561             TREE_USED (parmtype) = 1;
 562         }
 563
 564       if (TYPE_PTRMEMFUNC_P (parmtype))
 565         parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
 566
 567       if (TREE_READONLY (parmtype))
 568         OB_PUTC ('C');
 569       if (TREE_CODE (parmtype) == INTEGER_TYPE
 570           && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype)))
 571         OB_PUTC ('U');
 572       if (TYPE_VOLATILE (parmtype))
 573         OB_PUTC ('V');
 574
 575       switch (TREE_CODE (parmtype))
 576         {
 577         case OFFSET_TYPE:
 578           OB_PUTC ('O');
 579           build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0);
 580           OB_PUTC ('_');
 581           build_overload_name (TREE_TYPE (parmtype), 0, 0);
 582           break;
 583
 584         case REFERENCE_TYPE:
 585           OB_PUTC ('R');
 586           goto more;
 587
 588         case ARRAY_TYPE:
 589 #if PARM_CAN_BE_ARRAY_TYPE
 590           {
 591             tree length;
 592
 593             OB_PUTC ('A');
 594             if (TYPE_DOMAIN (parmtype) == NULL_TREE)
 595               error ("pointer or reference to array of unknown bound in parm type");
 596             else
 597               {
 598                 length = array_type_nelts (parmtype);
 599                 if (TREE_CODE (length) == INTEGER_CST)
 600                   icat (TREE_INT_CST_LOW (length) + 1);
 601               }
 602             OB_PUTC ('_');
 603             goto more;
 604           }
 605 #else
 606           OB_PUTC ('P');
 607           goto more;
 608 #endif
 609
 610         case POINTER_TYPE:
 611           OB_PUTC ('P');
 612         more:
 613           build_overload_name (TREE_TYPE (parmtype), 0, 0);
 614           break;
 615
 616         case FUNCTION_TYPE:
 617         case METHOD_TYPE:
 618           {
 619             tree firstarg = TYPE_ARG_TYPES (parmtype);
 620             /* Otherwise have to implement reentrant typevecs,
 621                unmark and remark types, etc.  */
 622             int old_nofold = nofold;
 623             nofold = 1;
 624
 625             if (nrepeats)
 626               flush_repeats (typevec[maxtype-1]);
 627
 628             /* @@ It may be possible to pass a function type in
 629                which is not preceded by a 'P'.  */
 630             if (TREE_CODE (parmtype) == FUNCTION_TYPE)
 631               {
 632                 OB_PUTC ('F');
 633                 if (firstarg == NULL_TREE)
 634                   OB_PUTC ('e');
 635                 else if (firstarg == void_list_node)
 636                   OB_PUTC ('v');
 637                 else
 638                   build_overload_name (firstarg, 0, 0);
 639               }
 640             else
 641               {
 642                 int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg)));
 643                 int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg)));
 644                 OB_PUTC ('M');
 645                 firstarg = TREE_CHAIN (firstarg);
 646
 647                 build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0);
 648                 if (constp)
 649                   OB_PUTC ('C');
 650                 if (volatilep)
 651                   OB_PUTC ('V');
 652
 653                 /* For cfront 2.0 compatibility.  */
 654                 OB_PUTC ('F');
 655
 656                 if (firstarg == NULL_TREE)
 657                   OB_PUTC ('e');
 658                 else if (firstarg == void_list_node)
 659                   OB_PUTC ('v');
 660                 else
 661                   build_overload_name (firstarg, 0, 0);
 662               }
 663
 664             /* Separate args from return type.  */
 665             OB_PUTC ('_');
 666             build_overload_name (TREE_TYPE (parmtype), 0, 0);
 667             nofold = old_nofold;
 668             break;
 669           }
 670
 671         case INTEGER_TYPE:
 672           parmtype = TYPE_MAIN_VARIANT (parmtype);
 673           if (parmtype == integer_type_node
 674               || parmtype == unsigned_type_node)
 675             OB_PUTC ('i');
 676           else if (parmtype == long_integer_type_node
 677                    || parmtype == long_unsigned_type_node)
 678             OB_PUTC ('l');
 679           else if (parmtype == short_integer_type_node
 680                    || parmtype == short_unsigned_type_node)
 681             OB_PUTC ('s');
 682           else if (parmtype == signed_char_type_node)
 683             {
 684               OB_PUTC ('S');
 685               OB_PUTC ('c');
 686             }
 687           else if (parmtype == char_type_node
 688                    || parmtype == unsigned_char_type_node)
 689             OB_PUTC ('c');
 690           else if (parmtype == wchar_type_node)
 691             OB_PUTC ('w');
 692           else if (parmtype == long_long_integer_type_node
 693               || parmtype == long_long_unsigned_type_node)
 694             OB_PUTC ('x');
 695 #if 0
 696           /* it would seem there is no way to enter these in source code,
 697              yet.  (mrs) */
 698           else if (parmtype == long_long_long_integer_type_node
 699               || parmtype == long_long_long_unsigned_type_node)
 700             OB_PUTC ('q');
 701 #endif
 702           else
 703             my_friendly_abort (73);
 704           break;
 705
 706         case BOOLEAN_TYPE:
 707           OB_PUTC ('b');
 708           break;
 709
 710         case REAL_TYPE:
 711           parmtype = TYPE_MAIN_VARIANT (parmtype);
 712           if (parmtype == long_double_type_node)
 713             OB_PUTC ('r');
 714           else if (parmtype == double_type_node)
 715             OB_PUTC ('d');
 716           else if (parmtype == float_type_node)
 717             OB_PUTC ('f');
 718           else my_friendly_abort (74);
 719           break;
 720
 721         case VOID_TYPE:
 722           if (! just_one)
 723             {
 724 #if 0
 725               extern tree void_list_node;
 726
 727               /* See if anybody is wasting memory.  */
 728               my_friendly_assert (parmtypes == void_list_node, 247);
 729 #endif
 730               /* This is the end of a parameter list.  */
 731               if (end) OB_FINISH ();
 732               return (char *)obstack_base (&scratch_obstack);
 733             }
 734           OB_PUTC ('v');
 735           break;
 736
 737         case ERROR_MARK:        /* not right, but nothing is anyway */
 738           break;
 739
 740           /* have to do these */
 741         case UNION_TYPE:
 742         case RECORD_TYPE:
 743           if (! just_one)
 744             /* Make this type signature look incompatible
 745                with AT&T.  */
 746             OB_PUTC ('G');
 747           goto common;
 748         case ENUMERAL_TYPE:
 749         common:
 750           {
 751             tree name = TYPE_NAME (parmtype);
 752             int i = 1;
 753
 754             if (TREE_CODE (name) == TYPE_DECL)
 755               {
 756                 tree context = name;
 757                 while (DECL_CONTEXT (context))
 758                   {
 759                     i += 1;
 760                     context = DECL_CONTEXT (context);
 761                     if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
 762                       context = TYPE_NAME (context);
 763                   }
 764                 name = DECL_NAME (name);
 765               }
 766             my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 248);
 767             if (i > 1)
 768               {
 769                 OB_PUTC ('Q');
 770                 if (i > 9)
 771                   OB_PUTC ('_');
 772                 icat (i);
 773                 if (i > 9)
 774                   OB_PUTC ('_');
 775                 build_overload_nested_name (TYPE_NAME (parmtype));
 776               }
 777             else
 778               build_overload_identifier (name);
 779             break;
 780           }
 781
 782         case UNKNOWN_TYPE:
 783           /* This will take some work.  */
 784           OB_PUTC ('?');
 785           break;
 786
 787         case TEMPLATE_TYPE_PARM:
 788         case TEMPLATE_CONST_PARM:
 789         case UNINSTANTIATED_P_TYPE:
 790           /* We don't ever want this output, but it's inconvenient not to
 791              be able to build the string.  This should cause assembler
 792              errors we'll notice.  */
 793           {
 794             static int n;
 795             sprintf (digit_buffer, " *%d", n++);
 796             OB_PUTCP (digit_buffer);
 797           }
 798           break;
 799
 800         default:
 801           my_friendly_abort (75);
 802         }
 803
 804     next:
 805       if (just_one) break;
 806       parmtypes = TREE_CHAIN (parmtypes);
 807     }
 808   if (! just_one)
 809     {
 810       if (nrepeats)
 811         flush_repeats (typevec[maxtype-1]);
 812
 813       /* To get here, parms must end with `...'. */
 814       OB_PUTC ('e');
 815     }
 816
 817   if (end) OB_FINISH ();
 818   return (char *)obstack_base (&scratch_obstack);
 819 }
 820 \f
 821 /* Generate an identifier that encodes the (ANSI) exception TYPE. */
 822
 823 /* This should be part of `ansi_opname', or at least be defined by the std.  */
 824 #define EXCEPTION_NAME_PREFIX "__ex"
 825 #define EXCEPTION_NAME_LENGTH 4
 826
 827 tree
 828 cplus_exception_name (type)
 829      tree type;
 830 {
 831   OB_INIT ();
 832   OB_PUTS (EXCEPTION_NAME_PREFIX);
 833   return get_identifier (build_overload_name (type, 0, 1));
 834 }
 835 \f
 836 /* Change the name of a function definition so that it may be
 837    overloaded. NAME is the name of the function to overload,
 838    PARMS is the parameter list (which determines what name the
 839    final function obtains).
 840
 841    FOR_METHOD is 1 if this overload is being performed
 842    for a method, rather than a function type.  It is 2 if
 843    this overload is being performed for a constructor.  */
 844 tree
 845 build_decl_overload (dname, parms, for_method)
 846      tree dname;
 847      tree parms;
 848      int for_method;
 849 {
 850   char *name = IDENTIFIER_POINTER (dname);
 851
 852   /* member operators new and delete look like methods at this point.  */
 853   if (! for_method && parms != NULL_TREE && TREE_CODE (parms) == TREE_LIST)
 854     {
 855       if (dname == ansi_opname[(int) DELETE_EXPR])
 856         return get_identifier ("__builtin_delete");
 857       else if (dname == ansi_opname[(int) VEC_DELETE_EXPR])
 858         return get_identifier ("__builtin_vec_delete");
 859       else if (TREE_CHAIN (parms) == void_list_node)
 860         {
 861           if (dname == ansi_opname[(int) NEW_EXPR])
 862             return get_identifier ("__builtin_new");
 863           else if (dname == ansi_opname[(int) VEC_NEW_EXPR])
 864             return get_identifier ("__builtin_vec_new");
 865         }
 866     }
 867
 868   OB_INIT ();
 869   if (for_method != 2)
 870     OB_PUTCP (name);
 871   /* Otherwise, we can divine that this is a constructor,
 872      and figure out its name without any extra encoding.  */
 873
 874   OB_PUTC2 ('_', '_');
 875   if (for_method)
 876     {
 877 #if 0
 878       /* We can get away without doing this.  */
 879       OB_PUTC ('M');
 880 #endif
 881       {
 882         tree this_type = TREE_VALUE (parms);
 883
 884         if (TREE_CODE (this_type) == RECORD_TYPE)  /* a signature pointer */
 885           parms = temp_tree_cons (NULL_TREE, SIGNATURE_TYPE (this_type),
 886                                   TREE_CHAIN (parms));
 887         else
 888           parms = temp_tree_cons (NULL_TREE, TREE_TYPE (this_type),
 889                                   TREE_CHAIN (parms));
 890       }
 891     }
 892   else
 893     OB_PUTC ('F');
 894
 895   if (parms == NULL_TREE)
 896     OB_PUTC2 ('e', '\0');
 897   else if (parms == void_list_node)
 898     OB_PUTC2 ('v', '\0');
 899   else
 900     {
 901       ALLOCATE_TYPEVEC (parms);
 902       nofold = 0;
 903       if (for_method)
 904         {
 905           build_overload_name (TREE_VALUE (parms), 0, 0);
 906
 907           typevec[maxtype++] = TREE_VALUE (parms);
 908           TREE_USED (TREE_VALUE (parms)) = 1;
 909
 910           if (TREE_CHAIN (parms))
 911             build_overload_name (TREE_CHAIN (parms), 0, 1);
 912           else
 913             OB_PUTC2 ('e', '\0');
 914         }
 915       else
 916         build_overload_name (parms, 0, 1);
 917       DEALLOCATE_TYPEVEC (parms);
 918     }
 919   {
 920     tree n = get_identifier (obstack_base (&scratch_obstack));
 921     if (IDENTIFIER_OPNAME_P (dname))
 922       IDENTIFIER_OPNAME_P (n) = 1;
 923     return n;
 924   }
 925 }
 926
 927 /* Build an overload name for the type expression TYPE.  */
 928 tree
 929 build_typename_overload (type)
 930      tree type;
 931 {
 932   tree id;
 933
 934   OB_INIT ();
 935   OB_PUTID (ansi_opname[(int) TYPE_EXPR]);
 936   nofold = 1;
 937   build_overload_name (type, 0, 1);
 938   id = get_identifier (obstack_base (&scratch_obstack));
 939   IDENTIFIER_OPNAME_P (id) = 1;
 940 #if 0
 941   IDENTIFIER_GLOBAL_VALUE (id) = TYPE_NAME (type);
 942 #endif
 943   TREE_TYPE (id) = type;
 944   return id;
 945 }
 946
 947 #ifndef NO_DOLLAR_IN_LABEL
 948 #define T_DESC_FORMAT "TD$"
 949 #define I_DESC_FORMAT "ID$"
 950 #define M_DESC_FORMAT "MD$"
 951 #else
 952 #if !defined(NO_DOT_IN_LABEL)
 953 #define T_DESC_FORMAT "TD."
 954 #define I_DESC_FORMAT "ID."
 955 #define M_DESC_FORMAT "MD."
 956 #else
 957 #define T_DESC_FORMAT "__t_desc_"
 958 #define I_DESC_FORMAT "__i_desc_"
 959 #define M_DESC_FORMAT "__m_desc_"
 960 #endif
 961 #endif
 962
 963 /* Build an overload name for the type expression TYPE.  */
 964 tree
 965 build_t_desc_overload (type)
 966      tree type;
 967 {
 968   OB_INIT ();
 969   OB_PUTS (T_DESC_FORMAT);
 970   nofold = 1;
 971
 972 #if 0
 973   /* Use a different format if the type isn't defined yet.  */
 974   if (TYPE_SIZE (type) == NULL_TREE)
 975     {
 976       char *p;
 977       int changed;
 978
 979       for (p = tname; *p; p++)
 980         if (isupper (*p))
 981           {
 982             changed = 1;
 983             *p = tolower (*p);
 984           }
 985       /* If there's no change, we have an inappropriate T_DESC_FORMAT.  */
 986       my_friendly_assert (changed != 0, 249);
 987     }
 988 #endif
 989
 990   build_overload_name (type, 0, 1);
 991   return get_identifier (obstack_base (&scratch_obstack));
 992 }
 993
 994 /* Top-level interface to explicit overload requests. Allow NAME
 995    to be overloaded. Error if NAME is already declared for the current
 996    scope. Warning if function is redundantly overloaded. */
 997
 998 void
 999 declare_overloaded (name)
1000      tree name;
1001 {
1002 #ifdef NO_AUTO_OVERLOAD
1003   if (is_overloaded (name))
1004     warning ("function `%s' already declared overloaded",
1005              IDENTIFIER_POINTER (name));
1006   else if (IDENTIFIER_GLOBAL_VALUE (name))
1007     error ("overloading function `%s' that is already defined",
1008            IDENTIFIER_POINTER (name));
1009   else
1010     {
1011       TREE_OVERLOADED (name) = 1;
1012       IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
1013       TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
1014     }
1015 #else
1016   if (current_lang_name == lang_name_cplusplus)
1017     {
1018       if (0)
1019         warning ("functions are implicitly overloaded in C++");
1020     }
1021   else if (current_lang_name == lang_name_c)
1022     error ("overloading function `%s' cannot be done in C language context");
1023   else
1024     my_friendly_abort (76);
1025 #endif
1026 }
1027
1028 #ifdef NO_AUTO_OVERLOAD
1029 /* Check to see if NAME is overloaded. For first approximation,
1030    check to see if its TREE_OVERLOADED is set.  This is used on
1031    IDENTIFIER nodes.  */
1032 int
1033 is_overloaded (name)
1034      tree name;
1035 {
1036   /* @@ */
1037   return (TREE_OVERLOADED (name)
1038           && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
1039           && ! IDENTIFIER_LOCAL_VALUE (name));
1040 }
1041 #endif
1042 \f
1043 /* Given a tree_code CODE, and some arguments (at least one),
1044    attempt to use an overloaded operator on the arguments.
1045
1046    For unary operators, only the first argument need be checked.
1047    For binary operators, both arguments may need to be checked.
1048
1049    Member functions can convert class references to class pointers,
1050    for one-level deep indirection.  More than that is not supported.
1051    Operators [](), ()(), and ->() must be member functions.
1052
1053    We call function call building calls with LOOKUP_COMPLAIN if they
1054    are our only hope.  This is true when we see a vanilla operator
1055    applied to something of aggregate type.  If this fails, we are free
1056    to return `error_mark_node', because we will have reported the
1057    error.
1058
1059    Operators NEW and DELETE overload in funny ways: operator new takes
1060    a single `size' parameter, and operator delete takes a pointer to the
1061    storage being deleted.  When overloading these operators, success is
1062    assumed.  If there is a failure, report an error message and return
1063    `error_mark_node'.  */
1064
1065 /* NOSTRICT */
1066 tree
1067 build_opfncall (code, flags, xarg1, xarg2, arg3)
1068      enum tree_code code;
1069      int flags;
1070      tree xarg1, xarg2, arg3;
1071 {
1072   tree rval = 0;
1073   tree arg1, arg2;
1074   tree type1, type2, fnname;
1075   tree fields1 = 0, parms = 0;
1076   tree global_fn;
1077   int try_second;
1078   int binary_is_unary;
1079
1080   if (xarg1 == error_mark_node)
1081     return error_mark_node;
1082
1083   if (code == COND_EXPR)
1084     {
1085       if (TREE_CODE (xarg2) == ERROR_MARK
1086           || TREE_CODE (arg3) == ERROR_MARK)
1087         return error_mark_node;
1088     }
1089   if (code == COMPONENT_REF)
1090     if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE)
1091       return rval;
1092
1093   /* First, see if we can work with the first argument */
1094   type1 = TREE_TYPE (xarg1);
1095
1096   /* Some tree codes have length > 1, but we really only want to
1097      overload them if their first argument has a user defined type.  */
1098   switch (code)
1099     {
1100     case PREINCREMENT_EXPR:
1101     case PREDECREMENT_EXPR:
1102     case POSTINCREMENT_EXPR:
1103     case POSTDECREMENT_EXPR:
1104     case COMPONENT_REF:
1105       binary_is_unary = 1;
1106       try_second = 0;
1107       break;
1108
1109       /* ARRAY_REFs and CALL_EXPRs must overload successfully.
1110          If they do not, return error_mark_node instead of NULL_TREE.  */
1111     case ARRAY_REF:
1112       if (xarg2 == error_mark_node)
1113         return error_mark_node;
1114     case CALL_EXPR:
1115       rval = error_mark_node;
1116       binary_is_unary = 0;
1117       try_second = 0;
1118       break;
1119
1120     case VEC_NEW_EXPR:
1121     case NEW_EXPR:
1122       {
1123         tree args = tree_cons (NULL_TREE, xarg2, arg3);
1124         fnname = ansi_opname[(int) code];
1125         if (flags & LOOKUP_GLOBAL)
1126           return build_overload_call (fnname, args, flags & LOOKUP_COMPLAIN,
1127                                       (struct candidate *)0);
1128
1129         rval = build_method_call
1130           (build_indirect_ref (build1 (NOP_EXPR, xarg1, error_mark_node),
1131                                "new"),
1132            fnname, args, NULL_TREE, flags);
1133         if (rval == error_mark_node)
1134           /* User might declare fancy operator new, but invoke it
1135              like standard one.  */
1136           return rval;
1137
1138         TREE_TYPE (rval) = xarg1;
1139         TREE_CALLS_NEW (rval) = 1;
1140         return rval;
1141       }
1142       break;
1143
1144     case VEC_DELETE_EXPR:
1145     case DELETE_EXPR:
1146       {
1147         fnname = ansi_opname[(int) code];
1148         if (flags & LOOKUP_GLOBAL)
1149           return build_overload_call (fnname,
1150                                       build_tree_list (NULL_TREE, xarg1),
1151                                       flags & LOOKUP_COMPLAIN,
1152                                       (struct candidate *)0);
1153
1154         rval = build_method_call
1155           (build_indirect_ref (build1 (NOP_EXPR, TREE_TYPE (xarg1),
1156                                        error_mark_node),
1157                                NULL_PTR),
1158            fnname, tree_cons (NULL_TREE, xarg1,
1159                                build_tree_list (NULL_TREE, xarg2)),
1160            NULL_TREE, flags);
1161         /* This happens when the user mis-declares `operator delete'.
1162            Should now be impossible.  */
1163         my_friendly_assert (rval != error_mark_node, 250);
1164         TREE_TYPE (rval) = void_type_node;
1165         return rval;
1166       }
1167       break;
1168
1169     default:
1170       binary_is_unary = 0;
1171       try_second = tree_code_length [(int) code] == 2;
1172       if (try_second && xarg2 == error_mark_node)
1173         return error_mark_node;
1174       break;
1175     }
1176
1177   if (try_second && xarg2 == error_mark_node)
1178     return error_mark_node;
1179
1180   /* What ever it was, we do not know how to deal with it.  */
1181   if (type1 == NULL_TREE)
1182     return rval;
1183
1184   if (TREE_CODE (type1) == OFFSET_TYPE)
1185     type1 = TREE_TYPE (type1);
1186
1187   if (TREE_CODE (type1) == REFERENCE_TYPE)
1188     {
1189       arg1 = convert_from_reference (xarg1);
1190       type1 = TREE_TYPE (arg1);
1191     }
1192   else
1193     {
1194       arg1 = xarg1;
1195     }
1196
1197   if (!IS_AGGR_TYPE (type1) || TYPE_PTRMEMFUNC_P (type1))
1198     {
1199       /* Try to fail. First, fail if unary */
1200       if (! try_second)
1201         return rval;
1202       /* Second, see if second argument is non-aggregate. */
1203       type2 = TREE_TYPE (xarg2);
1204       if (TREE_CODE (type2) == OFFSET_TYPE)
1205         type2 = TREE_TYPE (type2);
1206       if (TREE_CODE (type2) == REFERENCE_TYPE)
1207         {
1208           arg2 = convert_from_reference (xarg2);
1209           type2 = TREE_TYPE (arg2);
1210         }
1211       else
1212         {
1213           arg2 = xarg2;
1214         }
1215
1216       if (!IS_AGGR_TYPE (type2))
1217         return rval;
1218       try_second = 0;
1219     }
1220
1221   if (try_second)
1222     {
1223       /* First arg may succeed; see whether second should.  */
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         try_second = 0;
1239     }
1240
1241   if (type1 == unknown_type_node
1242       || (try_second && TREE_TYPE (xarg2) == unknown_type_node))
1243     {
1244       /* This will not be implemented in the foreseeable future.  */
1245       return rval;
1246     }
1247
1248   if (code == MODIFY_EXPR)
1249     fnname = ansi_assopname[(int) TREE_CODE (arg3)];
1250   else
1251     fnname = ansi_opname[(int) code];
1252
1253   global_fn = lookup_name_nonclass (fnname);
1254
1255   /* This is the last point where we will accept failure.  This
1256      may be too eager if we wish an overloaded operator not to match,
1257      but would rather a normal operator be called on a type-converted
1258      argument.  */
1259
1260   if (IS_AGGR_TYPE (type1))
1261     {
1262       fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0);
1263       /* ARM $13.4.7, prefix/postfix ++/--.  */
1264       if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1265         {
1266           xarg2 = integer_zero_node;
1267           binary_is_unary = 0;
1268
1269           if (fields1)
1270             {
1271               tree t, t2;
1272               int have_postfix = 0;
1273
1274               /* Look for an `operator++ (int)'.  If they didn't have
1275                  one, then we fall back to the old way of doing things.  */
1276               for (t = TREE_VALUE (fields1); t ; t = TREE_CHAIN (t))
1277                 {
1278                   t2 = TYPE_ARG_TYPES (TREE_TYPE (t));
1279                   if (TREE_CHAIN (t2) != NULL_TREE
1280                       && TREE_VALUE (TREE_CHAIN (t2)) == integer_type_node)
1281                     {
1282                       have_postfix = 1;
1283                       break;
1284                     }
1285                 }
1286
1287               if (! have_postfix)
1288                 {
1289                   char *op = POSTINCREMENT_EXPR ? "++" : "--";
1290
1291                   /* There's probably a LOT of code in the world that
1292                      relies upon this old behavior.  So we'll only give this
1293                      warning when we've been given -pedantic.  A few
1294                      releases after 2.4, we'll convert this to be a pedwarn
1295                      or something else more appropriate.  */
1296                   if (pedantic)
1297                     warning ("no `operator%s (int)' declared for postfix `%s'",
1298                              op, op);
1299                   xarg2 = NULL_TREE;
1300                   binary_is_unary = 1;
1301                 }
1302             }
1303         }
1304     }
1305
1306   if (fields1 == NULL_TREE && global_fn == NULL_TREE)
1307     return rval;
1308
1309   /* If RVAL winds up being `error_mark_node', we will return
1310      that... There is no way that normal semantics of these
1311      operators will succeed.  */
1312
1313   /* This argument may be an uncommitted OFFSET_REF.  This is
1314      the case for example when dealing with static class members
1315      which are referenced from their class name rather than
1316      from a class instance.  */
1317   if (TREE_CODE (xarg1) == OFFSET_REF
1318       && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL)
1319     xarg1 = TREE_OPERAND (xarg1, 1);
1320   if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF
1321       && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL)
1322     xarg2 = TREE_OPERAND (xarg2, 1);
1323
1324   if (global_fn)
1325     flags |= LOOKUP_GLOBAL;
1326
1327   if (code == CALL_EXPR)
1328     {
1329       /* This can only be a member function.  */
1330       return build_method_call (xarg1, fnname, xarg2,
1331                                 NULL_TREE, LOOKUP_NORMAL);
1332     }
1333   else if (tree_code_length[(int) code] == 1 || binary_is_unary)
1334     {
1335       parms = NULL_TREE;
1336       rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags);
1337     }
1338   else if (code == COND_EXPR)
1339     {
1340       parms = tree_cons (0, xarg2, build_tree_list (NULL_TREE, arg3));
1341       rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1342     }
1343   else if (code == METHOD_CALL_EXPR)
1344     {
1345       /* must be a member function.  */
1346       parms = tree_cons (NULL_TREE, xarg2, arg3);
1347       return build_method_call (xarg1, fnname, parms, NULL_TREE,
1348                                 LOOKUP_NORMAL);
1349     }
1350   else if (fields1)
1351     {
1352       parms = build_tree_list (NULL_TREE, xarg2);
1353       rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1354     }
1355   else
1356     {
1357       parms = tree_cons (NULL_TREE, xarg1,
1358                          build_tree_list (NULL_TREE, xarg2));
1359       rval = build_overload_call (fnname, parms, flags,
1360                                   (struct candidate *)0);
1361     }
1362
1363   return rval;
1364 }
1365 \f
1366 /* This function takes an identifier, ID, and attempts to figure out what
1367    it means. There are a number of possible scenarios, presented in increasing
1368    order of hair:
1369
1370    1) not in a class's scope
1371    2) in class's scope, member name of the class's method
1372    3) in class's scope, but not a member name of the class
1373    4) in class's scope, member name of a class's variable
1374
1375    NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
1376    VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
1377    yychar is the pending input character (suitably encoded :-).
1378
1379    As a last ditch, try to look up the name as a label and return that
1380    address.
1381
1382    Values which are declared as being of REFERENCE_TYPE are
1383    automatically dereferenced here (as a hack to make the
1384    compiler faster).  */
1385
1386 tree
1387 hack_identifier (value, name, yychar)
1388      tree value, name;
1389      int yychar;
1390 {
1391   tree type;
1392
1393   if (TREE_CODE (value) == ERROR_MARK)
1394     {
1395       if (current_class_name)
1396         {
1397           tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 1);
1398           if (fields == error_mark_node)
1399             return error_mark_node;
1400           if (fields)
1401             {
1402               tree fndecl;
1403
1404               fndecl = TREE_VALUE (fields);
1405               my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
1406               if (DECL_CHAIN (fndecl) == NULL_TREE)
1407                 {
1408                   warning ("methods cannot be converted to function pointers");
1409                   return fndecl;
1410                 }
1411               else
1412                 {
1413                   error ("ambiguous request for method pointer `%s'",
1414                          IDENTIFIER_POINTER (name));
1415                   return error_mark_node;
1416                 }
1417             }
1418         }
1419       if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name))
1420         {
1421           return IDENTIFIER_LABEL_VALUE (name);
1422         }
1423       return error_mark_node;
1424     }
1425
1426   type = TREE_TYPE (value);
1427   if (TREE_CODE (value) == FIELD_DECL)
1428     {
1429       if (current_class_decl == NULL_TREE)
1430         {
1431           error ("request for member `%s' in static member function",
1432                  IDENTIFIER_POINTER (DECL_NAME (value)));
1433           return error_mark_node;
1434         }
1435       TREE_USED (current_class_decl) = 1;
1436       if (yychar == '(')
1437         if (! ((TYPE_LANG_SPECIFIC (type)
1438                 && TYPE_OVERLOADS_CALL_EXPR (type))
1439                || (TREE_CODE (type) == REFERENCE_TYPE
1440                    && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
1441                    && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (type))))
1442             && TREE_CODE (type) != FUNCTION_TYPE
1443             && TREE_CODE (type) != METHOD_TYPE
1444             && !TYPE_PTRMEMFUNC_P (type)
1445             && (TREE_CODE (type) != POINTER_TYPE
1446                 || (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
1447                     && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)))
1448           {
1449             error ("component `%s' is not a method",
1450                    IDENTIFIER_POINTER (name));
1451             return error_mark_node;
1452           }
1453       /* Mark so that if we are in a constructor, and then find that
1454          this field was initialized by a base initializer,
1455          we can emit an error message.  */
1456       TREE_USED (value) = 1;
1457       return build_component_ref (C_C_D, name, 0, 1);
1458     }
1459
1460   if (really_overloaded_fn (value))
1461     {
1462       tree t = get_first_fn (value);
1463       while (t)
1464         {
1465           assemble_external (t);
1466           TREE_USED (t) = 1;
1467           t = DECL_CHAIN (t);
1468         }
1469     }
1470   else if (TREE_CODE (value) == TREE_LIST)
1471     {
1472       tree t = value;
1473       while (t && TREE_CODE (t) == TREE_LIST)
1474         {
1475           assemble_external (TREE_VALUE (t));
1476           TREE_USED (t) = 1;
1477           t = TREE_CHAIN (t);
1478         }
1479     }
1480   else
1481     {
1482       assemble_external (value);
1483       TREE_USED (value) = 1;
1484     }
1485
1486   if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && DECL_NONLOCAL (value))
1487     {
1488       if (DECL_LANG_SPECIFIC (value)
1489           && DECL_CLASS_CONTEXT (value) != current_class_type)
1490         {
1491           tree path;
1492           enum access_type access;
1493           register tree context
1494             = (TREE_CODE (value) == FUNCTION_DECL && DECL_VIRTUAL_P (value))
1495               ? DECL_CLASS_CONTEXT (value)
1496               : DECL_CONTEXT (value);
1497
1498           get_base_distance (context, current_class_type, 0, &path);
1499           if (path)
1500             {
1501               access = compute_access (path, value);
1502               if (access != access_public)
1503                 {
1504                   if (TREE_CODE (value) == VAR_DECL)
1505                     error ("static member `%s' is %s",
1506                            IDENTIFIER_POINTER (name),
1507                            TREE_PRIVATE (value) ? "private" :
1508                            "from a private base class");
1509                   else
1510                     error ("enum `%s' is from private base class",
1511                            IDENTIFIER_POINTER (name));
1512                   return error_mark_node;
1513                 }
1514             }
1515         }
1516       return value;
1517     }
1518   if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value))
1519     {
1520       if (type == 0)
1521         {
1522           error ("request for member `%s' is ambiguous in multiple inheritance lattice",
1523                  IDENTIFIER_POINTER (name));
1524           return error_mark_node;
1525         }
1526
1527       return value;
1528     }
1529
1530   if (TREE_CODE (type) == REFERENCE_TYPE)
1531     {
1532       my_friendly_assert (TREE_CODE (value) == VAR_DECL
1533                           || TREE_CODE (value) == PARM_DECL
1534                           || TREE_CODE (value) == RESULT_DECL, 252);
1535       if (DECL_REFERENCE_SLOT (value))
1536         return DECL_REFERENCE_SLOT (value);
1537     }
1538   return value;
1539 }
1540
1541 \f
1542 #if 0
1543 /* Given an object OF, and a type conversion operator COMPONENT
1544    build a call to the conversion operator, if a call is requested,
1545    or return the address (as a pointer to member function) if one is not.
1546
1547    OF can be a TYPE_DECL or any kind of datum that would normally
1548    be passed to `build_component_ref'.  It may also be NULL_TREE,
1549    in which case `current_class_type' and `current_class_decl'
1550    provide default values.
1551
1552    BASETYPE_PATH, if non-null, is the path of basetypes
1553    to go through before we get the the instance of interest.
1554
1555    PROTECT says whether we apply C++ scoping rules or not.  */
1556 tree
1557 build_component_type_expr (of, component, basetype_path, protect)
1558      tree of, component, basetype_path;
1559      int protect;
1560 {
1561   tree cname = NULL_TREE;
1562   tree tmp, last;
1563   tree name;
1564   int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN;
1565
1566   if (of)
1567     my_friendly_assert (IS_AGGR_TYPE (TREE_TYPE (of)), 253);
1568   my_friendly_assert (TREE_CODE (component) == TYPE_EXPR, 254);
1569
1570   tmp = TREE_OPERAND (component, 0);
1571   last = NULL_TREE;
1572
1573   while (tmp)
1574     {
1575       switch (TREE_CODE (tmp))
1576         {
1577         case CALL_EXPR:
1578           if (last)
1579             TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
1580           else
1581             TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0);
1582
1583           last = groktypename (build_tree_list (TREE_TYPE (component),
1584                                                 TREE_OPERAND (component, 0)));
1585           name = build_typename_overload (last);
1586           TREE_TYPE (name) = last;
1587
1588           if (TREE_OPERAND (tmp, 0)
1589               && TREE_OPERAND (tmp, 0) != void_list_node)
1590             {
1591               cp_error ("`operator %T' requires empty parameter list", last);
1592               TREE_OPERAND (tmp, 0) = NULL_TREE;
1593             }
1594
1595           if (of && TREE_CODE (of) != TYPE_DECL)
1596             return build_method_call (of, name, NULL_TREE, NULL_TREE, flags);
1597           else if (of)
1598             {
1599               tree this_this;
1600
1601               if (current_class_decl == NULL_TREE)
1602                 {
1603                   cp_error ("object required for `operator %T' call",
1604                             TREE_TYPE (name));
1605                   return error_mark_node;
1606                 }
1607
1608               this_this = convert_pointer_to (TREE_TYPE (of),
1609                                               current_class_decl);
1610               this_this = build_indirect_ref (this_this, NULL_PTR);
1611               return build_method_call (this_this, name, NULL_TREE,
1612                                         NULL_TREE, flags | LOOKUP_NONVIRTUAL);
1613             }
1614           else if (current_class_decl)
1615             return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags);
1616
1617           cp_error ("object required for `operator %T' call",
1618                     TREE_TYPE (name));
1619           return error_mark_node;
1620
1621         case INDIRECT_REF:
1622         case ADDR_EXPR:
1623         case ARRAY_REF:
1624           break;
1625
1626         case SCOPE_REF:
1627           my_friendly_assert (cname == 0, 255);
1628           cname = TREE_OPERAND (tmp, 0);
1629           tmp = TREE_OPERAND (tmp, 1);
1630           break;
1631
1632         default:
1633           my_friendly_abort (77);
1634         }
1635       last = tmp;
1636       tmp = TREE_OPERAND (tmp, 0);
1637     }
1638
1639   last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0)));
1640   name = build_typename_overload (last);
1641   TREE_TYPE (name) = last;
1642   if (of && TREE_CODE (of) == TYPE_DECL)
1643     {
1644       if (cname == NULL_TREE)
1645         {
1646           cname = DECL_NAME (of);
1647           of = NULL_TREE;
1648         }
1649       else my_friendly_assert (cname == DECL_NAME (of), 256);
1650     }
1651
1652   if (of)
1653     {
1654       tree this_this;
1655
1656       if (current_class_decl == NULL_TREE)
1657         {
1658           cp_error ("object required for `operator %T' call",
1659                     TREE_TYPE (name));
1660           return error_mark_node;
1661         }
1662
1663       this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
1664       return build_component_ref (this_this, name, 0, protect);
1665     }
1666   else if (cname)
1667     return build_offset_ref (cname, name);
1668   else if (current_class_name)
1669     return build_offset_ref (current_class_name, name);
1670
1671   cp_error ("object required for `operator %T' member reference",
1672             TREE_TYPE (name));
1673   return error_mark_node;
1674 }
1675 #endif
1676 \f
1677 static char *
1678 thunk_printable_name (decl)
1679      tree decl;
1680 {
1681   return "<thunk function>";
1682 }
1683
1684 tree
1685 make_thunk (function, delta)
1686      tree function;
1687      int delta;
1688 {
1689   char buffer[250];
1690   tree thunk_fndecl, thunk_id;
1691   tree thunk;
1692   char *func_name;
1693   static int thunk_number = 0;
1694   tree func_decl;
1695   if (TREE_CODE (function) != ADDR_EXPR)
1696     abort ();
1697   func_decl = TREE_OPERAND (function, 0);
1698   if (TREE_CODE (func_decl) != FUNCTION_DECL)
1699     abort ();
1700   func_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func_decl));
1701   sprintf (buffer, "__thunk_%d_%s", -delta, func_name);
1702   thunk_id = get_identifier (buffer);
1703   thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id);
1704   if (thunk && TREE_CODE (thunk) != THUNK_DECL)
1705     {
1706       error_with_decl ("implementation-reserved name `%s' used");
1707       IDENTIFIER_GLOBAL_VALUE (thunk_id) = thunk = NULL_TREE;
1708     }
1709   if (thunk == NULL_TREE)
1710     {
1711       thunk = build_decl (THUNK_DECL, thunk_id, TREE_TYPE (func_decl));
1712       DECL_RESULT (thunk)
1713         = build_decl (RESULT_DECL, NULL_TREE, TREE_TYPE (vtable_entry_type));
1714       make_function_rtl (thunk);
1715       DECL_INITIAL (thunk) = function;
1716       THUNK_DELTA (thunk) = delta;
1717       /* So that finish_file can write out any thunks that need to be: */
1718       pushdecl_top_level (thunk);
1719     }
1720   return thunk;
1721 }
1722
1723 void
1724 emit_thunk (thunk_fndecl)
1725   tree thunk_fndecl;
1726 {
1727   rtx insns;
1728   char *fnname;
1729   char buffer[250];
1730   tree argp;
1731   struct args_size stack_args_size;
1732   tree function = TREE_OPERAND (DECL_INITIAL (thunk_fndecl), 0);
1733   int delta = THUNK_DELTA (thunk_fndecl);
1734   int tem;
1735   int failure = 0;
1736   int current_call_is_indirect = 0;     /* needed for HPPA FUNCTION_ARG */
1737
1738   /* Used to remember which regs we need to emit a USE rtx for. */
1739   rtx need_use[FIRST_PSEUDO_REGISTER];
1740   int need_use_count = 0;
1741
1742   /* rtx for the 'this' parameter. */
1743   rtx this_rtx = 0, this_reg_rtx = 0, fixed_this_rtx;
1744
1745   char *(*save_decl_printable_name) () = decl_printable_name;
1746   /* Data on reg parms scanned so far.  */
1747   CUMULATIVE_ARGS args_so_far;
1748
1749   if (TREE_ASM_WRITTEN (thunk_fndecl))
1750     return;
1751
1752   TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1753
1754   if (TREE_PUBLIC (function))
1755     {
1756       TREE_PUBLIC (thunk_fndecl) = 1;
1757       if (DECL_EXTERNAL (function))
1758         {
1759           DECL_EXTERNAL (thunk_fndecl) = 1;
1760           assemble_external (thunk_fndecl);
1761           return;
1762         }
1763     }
1764
1765   decl_printable_name = thunk_printable_name;
1766   if (current_function_decl)
1767     abort ();
1768   current_function_decl = thunk_fndecl;
1769   init_function_start (thunk_fndecl, input_filename, lineno);
1770   pushlevel (0);
1771   expand_start_bindings (1);
1772
1773   /* Start updating where the next arg would go.  */
1774   INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (function), NULL_RTX);
1775   stack_args_size.constant = 0;
1776   stack_args_size.var = 0;
1777   /* SETUP for possible structure return address FIXME */
1778
1779   /* Now look through all the parameters, make sure that we
1780      don't clobber any registers used for parameters.
1781      Also, pick up an rtx for the first "this" parameter. */
1782   for (argp = TYPE_ARG_TYPES (TREE_TYPE (function));
1783        argp != NULL_TREE;
1784        argp = TREE_CHAIN (argp))
1785
1786     {
1787       tree passed_type = TREE_VALUE (argp);
1788       register rtx entry_parm;
1789       int named = 1; /* FIXME */
1790       struct args_size stack_offset;
1791       struct args_size arg_size;
1792
1793       if (passed_type == void_type_node)
1794         break;
1795
1796       if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
1797            && contains_placeholder_p (TYPE_SIZE (passed_type)))
1798 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1799           || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far,
1800                                              TYPE_MODE (passed_type),
1801                                              passed_type, named)
1802 #endif
1803           )
1804         passed_type = build_pointer_type (passed_type);
1805
1806       entry_parm = FUNCTION_ARG (args_so_far,
1807                                  TYPE_MODE (passed_type),
1808                                  passed_type,
1809                                  named);
1810       if (entry_parm != 0)
1811         need_use[need_use_count++] = entry_parm;
1812
1813       locate_and_pad_parm (TYPE_MODE (passed_type), passed_type,
1814 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1815                            1,
1816 #else
1817                            entry_parm != 0,
1818 #endif
1819                            thunk_fndecl,
1820                            &stack_args_size, &stack_offset, &arg_size);
1821
1822 /*    REGNO (entry_parm);*/
1823       if (this_rtx == 0)
1824         {
1825           this_reg_rtx = entry_parm;
1826           if (!entry_parm)
1827             {
1828               rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
1829
1830               rtx internal_arg_pointer, stack_parm;
1831
1832               if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
1833                    || ! (fixed_regs[ARG_POINTER_REGNUM]
1834                          || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
1835                 internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
1836               else
1837                 internal_arg_pointer = virtual_incoming_args_rtx;
1838
1839               if (offset_rtx == const0_rtx)
1840                 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1841                                       internal_arg_pointer);
1842               else
1843                 entry_parm = gen_rtx (MEM, TYPE_MODE (passed_type),
1844                                       gen_rtx (PLUS, Pmode,
1845                                                internal_arg_pointer,
1846                                                offset_rtx));
1847             }
1848
1849           this_rtx = entry_parm;
1850         }
1851
1852       FUNCTION_ARG_ADVANCE (args_so_far,
1853                             TYPE_MODE (passed_type),
1854                             passed_type,
1855                             named);
1856     }
1857
1858   fixed_this_rtx = plus_constant (this_rtx, delta);
1859   if (this_rtx != fixed_this_rtx)
1860     emit_move_insn (this_rtx, fixed_this_rtx);
1861
1862   if (this_reg_rtx)
1863     emit_insn (gen_rtx (USE, VOIDmode, this_reg_rtx));
1864
1865   emit_indirect_jump (XEXP (DECL_RTL (function), 0));
1866
1867   while (need_use_count > 0)
1868     emit_insn (gen_rtx (USE, VOIDmode, need_use[--need_use_count]));
1869
1870   expand_end_bindings (NULL, 1, 0);
1871   poplevel (0, 0, 0);
1872
1873   /* From now on, allocate rtl in current_obstack, not in saveable_obstack.
1874      Note that that may have been done above, in save_for_inline_copying.
1875      The call to resume_temporary_allocation near the end of this function
1876      goes back to the usual state of affairs.  */
1877
1878   rtl_in_current_obstack ();
1879
1880   insns = get_insns ();
1881
1882   /* Copy any shared structure that should not be shared.  */
1883
1884   unshare_all_rtl (insns);
1885
1886   /* We are no longer anticipating cse in this function, at least.  */
1887
1888   cse_not_expected = 1;
1889
1890   /* Now we choose between stupid (pcc-like) register allocation
1891      (if we got the -noreg switch and not -opt)
1892      and smart register allocation.  */
1893
1894   if (optimize > 0)                     /* Stupid allocation probably won't work */
1895     obey_regdecls = 0;          /* if optimizations being done.  */
1896
1897   regclass_init ();
1898
1899   regclass (insns, max_reg_num ());
1900   if (obey_regdecls)
1901     {
1902       stupid_life_analysis (insns, max_reg_num (), NULL);
1903       failure = reload (insns, 0, NULL);
1904     }
1905   else
1906     {
1907       /* Do control and data flow analysis,
1908          and write some of the results to dump file.  */
1909
1910       flow_analysis (insns, max_reg_num (), NULL);
1911       local_alloc ();
1912       failure = global_alloc (NULL);
1913     }
1914
1915   reload_completed = 1;
1916
1917 #ifdef LEAF_REGISTERS
1918   leaf_function = 0;
1919   if (optimize > 0 && only_leaf_regs_used () && leaf_function_p ())
1920     leaf_function = 1;
1921 #endif
1922
1923   /* If a machine dependent reorganization is needed, call it.  */
1924 #ifdef MACHINE_DEPENDENT_REORG
1925    MACHINE_DEPENDENT_REORG (insns);
1926 #endif
1927
1928   /* Now turn the rtl into assembler code.  */
1929
1930     {
1931       char *fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
1932       assemble_start_function (thunk_fndecl, fnname);
1933       final (insns, asm_out_file, optimize, 0);
1934       assemble_end_function (thunk_fndecl, fnname);
1935     };
1936
1937  exit_rest_of_compilation:
1938
1939   reload_completed = 0;
1940
1941   /* Cancel the effect of rtl_in_current_obstack.  */
1942
1943   resume_temporary_allocation ();
1944
1945   decl_printable_name = save_decl_printable_name;
1946   current_function_decl = 0;
1947 }