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