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