binutils221: Fix missing section start/end label generation
[dragonfly.git] / contrib / gcc-4.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, 2005, 2007, 2008
5    Free Software Foundation, Inc.
6    Contributed by Michael Tiemann (tiemann@cygnus.com)
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
14
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3.  If not see
22 <http://www.gnu.org/licenses/>.  */
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 #include "tree-pass.h"
40 #include "diagnostic.h"
41 #include "cgraph.h"
42
43 /* Various flags to control the mangling process.  */
44
45 enum mangling_flags
46 {
47   /* No flags.  */
48   mf_none = 0,
49   /* The thing we are presently mangling is part of a template type,
50      rather than a fully instantiated type.  Therefore, we may see
51      complex expressions where we would normally expect to see a
52      simple integer constant.  */
53   mf_maybe_uninstantiated = 1,
54   /* When mangling a numeric value, use the form `_XX_' (instead of
55      just `XX') if the value has more than one digit.  */
56   mf_use_underscores_around_value = 2
57 };
58
59 typedef enum mangling_flags mangling_flags;
60
61 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
62 static void do_build_assign_ref (tree);
63 static void do_build_copy_constructor (tree);
64 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
65 static tree make_alias_for_thunk (tree);
66
67 /* Called once to initialize method.c.  */
68
69 void
70 init_method (void)
71 {
72   init_mangle ();
73 }
74 \f
75 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
76    indicates whether it is a this or result adjusting thunk.
77    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
78    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
79    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
80    adjusting thunks, we scale it to a byte offset. For covariant
81    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
82    the returned thunk with finish_thunk.  */
83
84 tree
85 make_thunk (tree function, bool this_adjusting,
86             tree fixed_offset, tree virtual_offset)
87 {
88   HOST_WIDE_INT d;
89   tree thunk;
90
91   gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
92   /* We can have this thunks to covariant thunks, but not vice versa.  */
93   gcc_assert (!DECL_THIS_THUNK_P (function));
94   gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
95
96   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
97   if (this_adjusting && virtual_offset)
98     virtual_offset
99       = size_binop (MULT_EXPR,
100                     virtual_offset,
101                     convert (ssizetype,
102                              TYPE_SIZE_UNIT (vtable_entry_type)));
103
104   d = tree_low_cst (fixed_offset, 0);
105
106   /* See if we already have the thunk in question.  For this_adjusting
107      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
108      will be a BINFO.  */
109   for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
110     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
111         && THUNK_FIXED_OFFSET (thunk) == d
112         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
113         && (!virtual_offset
114             || (this_adjusting
115                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
116                                       virtual_offset)
117                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
118       return thunk;
119
120   /* All thunks must be created before FUNCTION is actually emitted;
121      the ABI requires that all thunks be emitted together with the
122      function to which they transfer control.  */
123   gcc_assert (!TREE_ASM_WRITTEN (function));
124   /* Likewise, we can only be adding thunks to a function declared in
125      the class currently being laid out.  */
126   gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
127               && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
128
129   thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
130   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
131   cxx_dup_lang_specific_decl (thunk);
132   DECL_THUNKS (thunk) = NULL_TREE;
133
134   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
135   TREE_READONLY (thunk) = TREE_READONLY (function);
136   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
137   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
138   SET_DECL_THUNK_P (thunk, this_adjusting);
139   THUNK_TARGET (thunk) = function;
140   THUNK_FIXED_OFFSET (thunk) = d;
141   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
142   THUNK_ALIAS (thunk) = NULL_TREE;
143
144   /* The thunk itself is not a constructor or destructor, even if
145      the thing it is thunking to is.  */
146   DECL_INTERFACE_KNOWN (thunk) = 1;
147   DECL_NOT_REALLY_EXTERN (thunk) = 1;
148   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
149   DECL_DESTRUCTOR_P (thunk) = 0;
150   DECL_CONSTRUCTOR_P (thunk) = 0;
151   DECL_EXTERNAL (thunk) = 1;
152   DECL_ARTIFICIAL (thunk) = 1;
153   /* Even if this thunk is a member of a local class, we don't
154      need a static chain.  */
155   DECL_NO_STATIC_CHAIN (thunk) = 1;
156   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
157   DECL_PENDING_INLINE_P (thunk) = 0;
158   DECL_DECLARED_INLINE_P (thunk) = 0;
159   /* Nor has it been deferred.  */
160   DECL_DEFERRED_FN (thunk) = 0;
161   /* Nor is it a template instantiation.  */
162   DECL_USE_TEMPLATE (thunk) = 0;
163   DECL_TEMPLATE_INFO (thunk) = NULL;
164
165   /* Add it to the list of thunks associated with FUNCTION.  */
166   TREE_CHAIN (thunk) = DECL_THUNKS (function);
167   DECL_THUNKS (function) = thunk;
168
169   return thunk;
170 }
171
172 /* Finish THUNK, a thunk decl.  */
173
174 void
175 finish_thunk (tree thunk)
176 {
177   tree function, name;
178   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
179   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
180
181   gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
182   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
183     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
184   function = THUNK_TARGET (thunk);
185   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
186                        fixed_offset, virtual_offset);
187
188   /* We can end up with declarations of (logically) different
189      covariant thunks, that do identical adjustments.  The two thunks
190      will be adjusting between within different hierarchies, which
191      happen to have the same layout.  We must nullify one of them to
192      refer to the other.  */
193   if (DECL_RESULT_THUNK_P (thunk))
194     {
195       tree cov_probe;
196
197       for (cov_probe = DECL_THUNKS (function);
198            cov_probe; cov_probe = TREE_CHAIN (cov_probe))
199         if (DECL_NAME (cov_probe) == name)
200           {
201             gcc_assert (!DECL_THUNKS (thunk));
202             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
203                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
204             break;
205           }
206     }
207
208   DECL_NAME (thunk) = name;
209   SET_DECL_ASSEMBLER_NAME (thunk, name);
210 }
211
212 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
213    offset indicated by VIRTUAL_OFFSET, if that is
214    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
215    zero for a result adjusting thunk.  */
216
217 static tree
218 thunk_adjust (tree ptr, bool this_adjusting,
219               HOST_WIDE_INT fixed_offset, tree virtual_offset)
220 {
221   if (this_adjusting)
222     /* Adjust the pointer by the constant.  */
223     ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
224                        size_int (fixed_offset));
225
226   /* If there's a virtual offset, look up that value in the vtable and
227      adjust the pointer again.  */
228   if (virtual_offset)
229     {
230       tree vtable;
231
232       ptr = save_expr (ptr);
233       /* The vptr is always at offset zero in the object.  */
234       vtable = build1 (NOP_EXPR,
235                        build_pointer_type (build_pointer_type
236                                            (vtable_entry_type)),
237                        ptr);
238       /* Form the vtable address.  */
239       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
240       /* Find the entry with the vcall offset.  */
241       vtable = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtable), vtable,
242                        fold_convert (sizetype, virtual_offset));
243       /* Get the offset itself.  */
244       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
245       /* Adjust the `this' pointer.  */
246       ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
247                          fold_convert (sizetype, vtable));
248     }
249
250   if (!this_adjusting)
251     /* Adjust the pointer by the constant.  */
252     ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
253                        size_int (fixed_offset));
254
255   return ptr;
256 }
257
258 static GTY (()) int thunk_labelno;
259
260 /* Create a static alias to function.  */
261
262 tree
263 make_alias_for (tree function, tree newid)
264 {
265   tree alias = build_decl (FUNCTION_DECL, newid, TREE_TYPE (function));
266   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
267   cxx_dup_lang_specific_decl (alias);
268   DECL_CONTEXT (alias) = NULL;
269   TREE_READONLY (alias) = TREE_READONLY (function);
270   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
271   TREE_PUBLIC (alias) = 0;
272   DECL_INTERFACE_KNOWN (alias) = 1;
273   DECL_NOT_REALLY_EXTERN (alias) = 1;
274   DECL_THIS_STATIC (alias) = 1;
275   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
276   DECL_DESTRUCTOR_P (alias) = 0;
277   DECL_CONSTRUCTOR_P (alias) = 0;
278   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
279   DECL_EXTERNAL (alias) = 0;
280   DECL_ARTIFICIAL (alias) = 1;
281   DECL_NO_STATIC_CHAIN (alias) = 1;
282   DECL_PENDING_INLINE_P (alias) = 0;
283   DECL_DECLARED_INLINE_P (alias) = 0;
284   DECL_DEFERRED_FN (alias) = 0;
285   DECL_USE_TEMPLATE (alias) = 0;
286   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
287   DECL_TEMPLATE_INFO (alias) = NULL;
288   DECL_INITIAL (alias) = error_mark_node;
289   TREE_ADDRESSABLE (alias) = 1;
290   TREE_USED (alias) = 1;
291   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
292   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
293   return alias;
294 }
295
296 static tree
297 make_alias_for_thunk (tree function)
298 {
299   tree alias;
300   char buf[256];
301
302   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
303   thunk_labelno++;
304
305   alias = make_alias_for (function, get_identifier (buf));
306
307   if (!flag_syntax_only)
308     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
309
310   return alias;
311 }
312
313 /* Emit the definition of a C++ multiple inheritance or covariant
314    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
315    immediately.  */
316
317 void
318 use_thunk (tree thunk_fndecl, bool emit_p)
319 {
320   tree a, t, function, alias;
321   tree virtual_offset;
322   HOST_WIDE_INT fixed_offset, virtual_value;
323   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
324
325   /* We should have called finish_thunk to give it a name.  */
326   gcc_assert (DECL_NAME (thunk_fndecl));
327
328   /* We should never be using an alias, always refer to the
329      aliased thunk.  */
330   gcc_assert (!THUNK_ALIAS (thunk_fndecl));
331
332   if (TREE_ASM_WRITTEN (thunk_fndecl))
333     return;
334
335   function = THUNK_TARGET (thunk_fndecl);
336   if (DECL_RESULT (thunk_fndecl))
337     /* We already turned this thunk into an ordinary function.
338        There's no need to process this thunk again.  */
339     return;
340
341   if (DECL_THUNK_P (function))
342     /* The target is itself a thunk, process it now.  */
343     use_thunk (function, emit_p);
344
345   /* Thunks are always addressable; they only appear in vtables.  */
346   TREE_ADDRESSABLE (thunk_fndecl) = 1;
347
348   /* Figure out what function is being thunked to.  It's referenced in
349      this translation unit.  */
350   TREE_ADDRESSABLE (function) = 1;
351   mark_used (function);
352   if (!emit_p)
353     return;
354
355   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
356    alias = make_alias_for_thunk (function);
357   else
358    alias = function;
359
360   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
361   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
362
363   if (virtual_offset)
364     {
365       if (!this_adjusting)
366         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
367       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
368       gcc_assert (virtual_value);
369     }
370   else
371     virtual_value = 0;
372
373   /* And, if we need to emit the thunk, it's used.  */
374   mark_used (thunk_fndecl);
375   /* This thunk is actually defined.  */
376   DECL_EXTERNAL (thunk_fndecl) = 0;
377   /* The linkage of the function may have changed.  FIXME in linkage
378      rewrite.  */
379   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
380   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
381   DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
382     = DECL_VISIBILITY_SPECIFIED (function);
383   if (DECL_ONE_ONLY (function))
384     make_decl_one_only (thunk_fndecl);
385
386   if (flag_syntax_only)
387     {
388       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
389       return;
390     }
391
392   push_to_top_level ();
393
394   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
395       && targetm.have_named_sections)
396     {
397       resolve_unique_section (function, 0, flag_function_sections);
398
399       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
400         {
401           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
402
403           /* Output the thunk into the same section as function.  */
404           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
405         }
406     }
407
408   /* Set up cloned argument trees for the thunk.  */
409   t = NULL_TREE;
410   for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
411     {
412       tree x = copy_node (a);
413       TREE_CHAIN (x) = t;
414       DECL_CONTEXT (x) = thunk_fndecl;
415       SET_DECL_RTL (x, NULL_RTX);
416       DECL_HAS_VALUE_EXPR_P (x) = 0;
417       t = x;
418     }
419   a = nreverse (t);
420   DECL_ARGUMENTS (thunk_fndecl) = a;
421
422   if (this_adjusting
423       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
424                                               virtual_value, alias))
425     {
426       const char *fnname;
427       tree fn_block;
428       
429       current_function_decl = thunk_fndecl;
430       DECL_RESULT (thunk_fndecl)
431         = build_decl (RESULT_DECL, 0, integer_type_node);
432       fnname = IDENTIFIER_POINTER (DECL_NAME (thunk_fndecl));
433       /* The back end expects DECL_INITIAL to contain a BLOCK, so we
434          create one.  */
435       fn_block = make_node (BLOCK);
436       BLOCK_VARS (fn_block) = a;
437       DECL_INITIAL (thunk_fndecl) = fn_block;
438       init_function_start (thunk_fndecl);
439       cfun->is_thunk = 1;
440       assemble_start_function (thunk_fndecl, fnname);
441
442       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
443                                        fixed_offset, virtual_value, alias);
444
445       assemble_end_function (thunk_fndecl, fnname);
446       init_insn_lengths ();
447       current_function_decl = 0;
448       set_cfun (NULL);
449       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
450     }
451   else
452     {
453       int i;
454       tree *argarray = (tree *) alloca (list_length (a) * sizeof (tree));
455       /* If this is a covariant thunk, or we don't have the necessary
456          code for efficient thunks, generate a thunk function that
457          just makes a call to the real function.  Unfortunately, this
458          doesn't work for varargs.  */
459
460       if (varargs_function_p (function))
461         error ("generic thunk code fails for method %q#D which uses %<...%>",
462                function);
463
464       DECL_RESULT (thunk_fndecl) = NULL_TREE;
465
466       start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
467       /* We don't bother with a body block for thunks.  */
468
469       /* There's no need to check accessibility inside the thunk body.  */
470       push_deferring_access_checks (dk_no_check);
471
472       t = a;
473       if (this_adjusting)
474         t = thunk_adjust (t, /*this_adjusting=*/1,
475                           fixed_offset, virtual_offset);
476
477       /* Build up the call to the real function.  */
478       argarray[0] = t;
479       for (i = 1, a = TREE_CHAIN (a); a; a = TREE_CHAIN (a), i++)
480         argarray[i] = a;
481       t = build_call_a (alias, i, argarray);
482       CALL_FROM_THUNK_P (t) = 1;
483       CALL_CANNOT_INLINE_P (t) = 1;
484
485       if (VOID_TYPE_P (TREE_TYPE (t)))
486         finish_expr_stmt (t);
487       else
488         {
489           if (!this_adjusting)
490             {
491               tree cond = NULL_TREE;
492
493               if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
494                 {
495                   /* If the return type is a pointer, we need to
496                      protect against NULL.  We know there will be an
497                      adjustment, because that's why we're emitting a
498                      thunk.  */
499                   t = save_expr (t);
500                   cond = cp_convert (boolean_type_node, t);
501                 }
502
503               t = thunk_adjust (t, /*this_adjusting=*/0,
504                                 fixed_offset, virtual_offset);
505               if (cond)
506                 t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
507                             cp_convert (TREE_TYPE (t), integer_zero_node));
508             }
509           if (MAYBE_CLASS_TYPE_P (TREE_TYPE (t)))
510             t = build_cplus_new (TREE_TYPE (t), t);
511           finish_return_stmt (t);
512         }
513
514       /* Since we want to emit the thunk, we explicitly mark its name as
515          referenced.  */
516       mark_decl_referenced (thunk_fndecl);
517
518       /* But we don't want debugging information about it.  */
519       DECL_IGNORED_P (thunk_fndecl) = 1;
520
521       /* Re-enable access control.  */
522       pop_deferring_access_checks ();
523
524       thunk_fndecl = finish_function (0);
525       cgraph_add_new_function (thunk_fndecl, false);
526     }
527
528   pop_from_top_level ();
529 }
530 \f
531 /* Code for synthesizing methods which have default semantics defined.  */
532
533 /* Generate code for default X(X&) constructor.  */
534
535 static void
536 do_build_copy_constructor (tree fndecl)
537 {
538   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
539
540   parm = convert_from_reference (parm);
541
542   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
543       && is_empty_class (current_class_type))
544     /* Don't copy the padding byte; it might not have been allocated
545        if *this is a base subobject.  */;
546   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
547     {
548       tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
549       finish_expr_stmt (t);
550     }
551   else
552     {
553       tree fields = TYPE_FIELDS (current_class_type);
554       tree member_init_list = NULL_TREE;
555       int cvquals = cp_type_quals (TREE_TYPE (parm));
556       int i;
557       tree binfo, base_binfo;
558       VEC(tree,gc) *vbases;
559
560       /* Initialize all the base-classes with the parameter converted
561          to their type so that we get their copy constructor and not
562          another constructor that takes current_class_type.  We must
563          deal with the binfo's directly as a direct base might be
564          inaccessible due to ambiguity.  */
565       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
566            VEC_iterate (tree, vbases, i, binfo); i++)
567         {
568           member_init_list
569             = tree_cons (binfo,
570                          build_tree_list (NULL_TREE,
571                                           build_base_path (PLUS_EXPR, parm,
572                                                            binfo, 1)),
573                          member_init_list);
574         }
575
576       for (binfo = TYPE_BINFO (current_class_type), i = 0;
577            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
578         {
579           if (BINFO_VIRTUAL_P (base_binfo))
580             continue;
581
582           member_init_list
583             = tree_cons (base_binfo,
584                          build_tree_list (NULL_TREE,
585                                           build_base_path (PLUS_EXPR, parm,
586                                                            base_binfo, 1)),
587                          member_init_list);
588         }
589
590       for (; fields; fields = TREE_CHAIN (fields))
591         {
592           tree init = parm;
593           tree field = fields;
594           tree expr_type;
595
596           if (TREE_CODE (field) != FIELD_DECL)
597             continue;
598
599           expr_type = TREE_TYPE (field);
600           if (DECL_NAME (field))
601             {
602               if (VFIELD_NAME_P (DECL_NAME (field)))
603                 continue;
604             }
605           else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
606             /* Just use the field; anonymous types can't have
607                nontrivial copy ctors or assignment ops.  */;
608           else
609             continue;
610
611           /* Compute the type of "init->field".  If the copy-constructor
612              parameter is, for example, "const S&", and the type of
613              the field is "T", then the type will usually be "const
614              T".  (There are no cv-qualified variants of reference
615              types.)  */
616           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
617             {
618               int quals = cvquals;
619
620               if (DECL_MUTABLE_P (field))
621                 quals &= ~TYPE_QUAL_CONST;
622               expr_type = cp_build_qualified_type (expr_type, quals);
623             }
624
625           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
626           init = build_tree_list (NULL_TREE, init);
627
628           member_init_list = tree_cons (field, init, member_init_list);
629         }
630       finish_mem_initializers (member_init_list);
631     }
632 }
633
634 static void
635 do_build_assign_ref (tree fndecl)
636 {
637   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
638   tree compound_stmt;
639
640   compound_stmt = begin_compound_stmt (0);
641   parm = convert_from_reference (parm);
642
643   if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
644       && is_empty_class (current_class_type))
645     /* Don't copy the padding byte; it might not have been allocated
646        if *this is a base subobject.  */;
647   else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
648     {
649       tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
650       finish_expr_stmt (t);
651     }
652   else
653     {
654       tree fields;
655       int cvquals = cp_type_quals (TREE_TYPE (parm));
656       int i;
657       tree binfo, base_binfo;
658
659       /* Assign to each of the direct base classes.  */
660       for (binfo = TYPE_BINFO (current_class_type), i = 0;
661            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
662         {
663           tree converted_parm;
664
665           /* We must convert PARM directly to the base class
666              explicitly since the base class may be ambiguous.  */
667           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
668           /* Call the base class assignment operator.  */
669           finish_expr_stmt
670             (build_special_member_call (current_class_ref,
671                                         ansi_assopname (NOP_EXPR),
672                                         build_tree_list (NULL_TREE,
673                                                          converted_parm),
674                                         base_binfo,
675                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
676                                         tf_warning_or_error));
677         }
678
679       /* Assign to each of the non-static data members.  */
680       for (fields = TYPE_FIELDS (current_class_type);
681            fields;
682            fields = TREE_CHAIN (fields))
683         {
684           tree comp = current_class_ref;
685           tree init = parm;
686           tree field = fields;
687           tree expr_type;
688           int quals;
689
690           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
691             continue;
692
693           expr_type = TREE_TYPE (field);
694
695           if (CP_TYPE_CONST_P (expr_type))
696             {
697               error ("non-static const member %q#D, can't use default "
698                      "assignment operator", field);
699               continue;
700             }
701           else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
702             {
703               error ("non-static reference member %q#D, can't use "
704                      "default assignment operator", field);
705               continue;
706             }
707
708           if (DECL_NAME (field))
709             {
710               if (VFIELD_NAME_P (DECL_NAME (field)))
711                 continue;
712             }
713           else if (ANON_AGGR_TYPE_P (expr_type)
714                    && TYPE_FIELDS (expr_type) != NULL_TREE)
715             /* Just use the field; anonymous types can't have
716                nontrivial copy ctors or assignment ops.  */;
717           else
718             continue;
719
720           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
721
722           /* Compute the type of init->field  */
723           quals = cvquals;
724           if (DECL_MUTABLE_P (field))
725             quals &= ~TYPE_QUAL_CONST;
726           expr_type = cp_build_qualified_type (expr_type, quals);
727
728           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
729
730           if (DECL_NAME (field))
731             init = cp_build_modify_expr (comp, NOP_EXPR, init, 
732                                          tf_warning_or_error);
733           else
734             init = build2 (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 /* Synthesize FNDECL, a non-static member function.   */
743
744 void
745 synthesize_method (tree fndecl)
746 {
747   bool nested = (current_function_decl != NULL_TREE);
748   tree context = decl_function_context (fndecl);
749   bool need_body = true;
750   tree stmt;
751   location_t save_input_location = input_location;
752   int error_count = errorcount;
753   int warning_count = warningcount;
754
755   /* Reset the source location, we might have been previously
756      deferred, and thus have saved where we were first needed.  */
757   DECL_SOURCE_LOCATION (fndecl)
758     = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
759
760   /* If we've been asked to synthesize a clone, just synthesize the
761      cloned function instead.  Doing so will automatically fill in the
762      body for the clone.  */
763   if (DECL_CLONED_FUNCTION_P (fndecl))
764     fndecl = DECL_CLONED_FUNCTION (fndecl);
765
766   /* We may be in the middle of deferred access check.  Disable
767      it now.  */
768   push_deferring_access_checks (dk_no_deferred);
769
770   if (! context)
771     push_to_top_level ();
772   else if (nested)
773     push_function_context ();
774
775   input_location = DECL_SOURCE_LOCATION (fndecl);
776
777   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
778   stmt = begin_function_body ();
779
780   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
781     {
782       do_build_assign_ref (fndecl);
783       need_body = false;
784     }
785   else if (DECL_CONSTRUCTOR_P (fndecl))
786     {
787       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
788       if (arg_chain != void_list_node)
789         do_build_copy_constructor (fndecl);
790       else
791         finish_mem_initializers (NULL_TREE);
792     }
793
794   /* If we haven't yet generated the body of the function, just
795      generate an empty compound statement.  */
796   if (need_body)
797     {
798       tree compound_stmt;
799       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
800       finish_compound_stmt (compound_stmt);
801     }
802
803   finish_function_body (stmt);
804   expand_or_defer_fn (finish_function (0));
805
806   input_location = save_input_location;
807
808   if (! context)
809     pop_from_top_level ();
810   else if (nested)
811     pop_function_context ();
812
813   pop_deferring_access_checks ();
814
815   if (error_count != errorcount || warning_count != warningcount)
816     inform (input_location, "synthesized method %qD first required here ",
817             fndecl);
818 }
819
820 /* Use EXTRACTOR to locate the relevant function called for each base &
821    class field of TYPE. CLIENT allows additional information to be passed
822    to EXTRACTOR.  Generates the union of all exceptions generated by those
823    functions.  Note that we haven't updated TYPE_FIELDS and such of any
824    variants yet, so we need to look at the main one.  */
825
826 static tree
827 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
828                            void *client)
829 {
830   tree raises = empty_except_spec;
831   tree fields = TYPE_FIELDS (type);
832   tree binfo, base_binfo;
833   int i;
834
835   for (binfo = TYPE_BINFO (type), i = 0;
836        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
837     {
838       tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
839       if (fn)
840         {
841           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
842
843           raises = merge_exception_specifiers (raises, fn_raises);
844         }
845     }
846   for (; fields; fields = TREE_CHAIN (fields))
847     {
848       tree type = TREE_TYPE (fields);
849       tree fn;
850
851       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
852         continue;
853       while (TREE_CODE (type) == ARRAY_TYPE)
854         type = TREE_TYPE (type);
855       if (!CLASS_TYPE_P (type))
856         continue;
857
858       fn = (*extractor) (type, client);
859       if (fn)
860         {
861           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
862
863           raises = merge_exception_specifiers (raises, fn_raises);
864         }
865     }
866   return raises;
867 }
868
869 /* Locate the dtor of TYPE.  */
870
871 tree
872 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
873 {
874   return CLASSTYPE_DESTRUCTORS (type);
875 }
876
877 /* Locate the default ctor of TYPE.  */
878
879 tree
880 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
881 {
882   tree fns;
883
884   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
885     return NULL_TREE;
886
887   /* Call lookup_fnfields_1 to create the constructor declarations, if
888      necessary.  */
889   if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
890     return lazily_declare_fn (sfk_constructor, type);
891
892   for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
893     {
894       tree fn = OVL_CURRENT (fns);
895       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
896
897       parms = skip_artificial_parms_for (fn, parms);
898
899       if (sufficient_parms_p (parms))
900         return fn;
901     }
902   gcc_unreachable ();
903 }
904
905 struct copy_data
906 {
907   tree name;
908   int quals;
909 };
910
911 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
912    points to a COPY_DATA holding the name (NULL for the ctor)
913    and desired qualifiers of the source operand.  */
914
915 tree
916 locate_copy (tree type, void *client_)
917 {
918   struct copy_data *client = (struct copy_data *)client_;
919   tree fns;
920   tree best = NULL_TREE;
921   bool excess_p = false;
922
923   if (client->name)
924     {
925       int ix;
926       ix = lookup_fnfields_1 (type, client->name);
927       if (ix < 0)
928         return NULL_TREE;
929       fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
930     }
931   else if (TYPE_HAS_INIT_REF (type))
932     {
933       /* If construction of the copy constructor was postponed, create
934          it now.  */
935       if (CLASSTYPE_LAZY_COPY_CTOR (type))
936         lazily_declare_fn (sfk_copy_constructor, type);
937       fns = CLASSTYPE_CONSTRUCTORS (type);
938     }
939   else
940     return NULL_TREE;
941   for (; fns; fns = OVL_NEXT (fns))
942     {
943       tree fn = OVL_CURRENT (fns);
944       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
945       tree src_type;
946       int excess;
947       int quals;
948
949       parms = skip_artificial_parms_for (fn, parms);
950       if (!parms)
951         continue;
952       src_type = non_reference (TREE_VALUE (parms));
953
954       if (src_type == error_mark_node)
955         return NULL_TREE;
956
957       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
958         continue;
959       if (!sufficient_parms_p (TREE_CHAIN (parms)))
960         continue;
961       quals = cp_type_quals (src_type);
962       if (client->quals & ~quals)
963         continue;
964       excess = quals & ~client->quals;
965       if (!best || (excess_p && !excess))
966         {
967           best = fn;
968           excess_p = excess;
969         }
970       else
971         /* Ambiguous */
972         return NULL_TREE;
973     }
974   return best;
975 }
976
977 /* Implicitly declare the special function indicated by KIND, as a
978    member of TYPE.  For copy constructors and assignment operators,
979    CONST_P indicates whether these functions should take a const
980    reference argument or a non-const reference.  Returns the
981    FUNCTION_DECL for the implicitly declared function.  */
982
983 static tree
984 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
985 {
986   tree fn;
987   tree parameter_types = void_list_node;
988   tree return_type;
989   tree fn_type;
990   tree raises = empty_except_spec;
991   tree rhs_parm_type = NULL_TREE;
992   tree this_parm;
993   tree name;
994   HOST_WIDE_INT saved_processing_template_decl;
995
996   /* Because we create declarations for implicitly declared functions
997      lazily, we may be creating the declaration for a member of TYPE
998      while in some completely different context.  However, TYPE will
999      never be a dependent class (because we never want to do lookups
1000      for implicitly defined functions in a dependent class).
1001      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1002      because we only create clones for constructors and destructors
1003      when not in a template.  */
1004   gcc_assert (!dependent_type_p (type));
1005   saved_processing_template_decl = processing_template_decl;
1006   processing_template_decl = 0;
1007
1008   type = TYPE_MAIN_VARIANT (type);
1009
1010   if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1011     {
1012       if (kind == sfk_destructor)
1013         /* See comment in check_special_function_return_type.  */
1014         return_type = build_pointer_type (void_type_node);
1015       else
1016         return_type = build_pointer_type (type);
1017     }
1018   else
1019     return_type = void_type_node;
1020
1021   switch (kind)
1022     {
1023     case sfk_destructor:
1024       /* Destructor.  */
1025       name = constructor_name (type);
1026       raises = synthesize_exception_spec (type, &locate_dtor, 0);
1027       break;
1028
1029     case sfk_constructor:
1030       /* Default constructor.  */
1031       name = constructor_name (type);
1032       raises = synthesize_exception_spec (type, &locate_ctor, 0);
1033       break;
1034
1035     case sfk_copy_constructor:
1036     case sfk_assignment_operator:
1037     {
1038       struct copy_data data;
1039
1040       data.name = NULL;
1041       data.quals = 0;
1042       if (kind == sfk_assignment_operator)
1043         {
1044           return_type = build_reference_type (type);
1045           name = ansi_assopname (NOP_EXPR);
1046           data.name = name;
1047         }
1048       else
1049         name = constructor_name (type);
1050
1051       if (const_p)
1052         {
1053           data.quals = TYPE_QUAL_CONST;
1054           rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1055         }
1056       else
1057         rhs_parm_type = type;
1058       rhs_parm_type = build_reference_type (rhs_parm_type);
1059       parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1060       raises = synthesize_exception_spec (type, &locate_copy, &data);
1061       break;
1062     }
1063     default:
1064       gcc_unreachable ();
1065     }
1066
1067   /* Create the function.  */
1068   fn_type = build_method_type_directly (type, return_type, parameter_types);
1069   if (raises)
1070     fn_type = build_exception_variant (fn_type, raises);
1071   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1072   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1073   if (kind == sfk_constructor || kind == sfk_copy_constructor)
1074     DECL_CONSTRUCTOR_P (fn) = 1;
1075   else if (kind == sfk_destructor)
1076     DECL_DESTRUCTOR_P (fn) = 1;
1077   else
1078     {
1079       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1080       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1081     }
1082   
1083   /* If pointers to member functions use the least significant bit to
1084      indicate whether a function is virtual, ensure a pointer
1085      to this function will have that bit clear.  */
1086   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1087       && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1088     DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1089
1090   /* Create the explicit arguments.  */
1091   if (rhs_parm_type)
1092     {
1093       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1094          want its type to be included in the mangled function
1095          name.  */
1096       DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1097       TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1098     }
1099   /* Add the "this" parameter.  */
1100   this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1101   TREE_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1102   DECL_ARGUMENTS (fn) = this_parm;
1103
1104   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1105   set_linkage_according_to_type (type, fn);
1106   rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1107   DECL_IN_AGGR_P (fn) = 1;
1108   DECL_ARTIFICIAL (fn) = 1;
1109   DECL_DEFAULTED_FN (fn) = 1;
1110   DECL_NOT_REALLY_EXTERN (fn) = 1;
1111   DECL_DECLARED_INLINE_P (fn) = 1;
1112   gcc_assert (!TREE_USED (fn));
1113
1114   /* Restore PROCESSING_TEMPLATE_DECL.  */
1115   processing_template_decl = saved_processing_template_decl;
1116
1117   return fn;
1118 }
1119
1120 /* Add an implicit declaration to TYPE for the kind of function
1121    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
1122    declaration.  */
1123
1124 tree
1125 lazily_declare_fn (special_function_kind sfk, tree type)
1126 {
1127   tree fn;
1128   bool const_p;
1129
1130   /* Figure out whether or not the argument has a const reference
1131      type.  */
1132   if (sfk == sfk_copy_constructor)
1133     const_p = TYPE_HAS_CONST_INIT_REF (type);
1134   else if (sfk == sfk_assignment_operator)
1135     const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1136   else
1137     /* In this case, CONST_P will be ignored.  */
1138     const_p = false;
1139   /* Declare the function.  */
1140   fn = implicitly_declare_fn (sfk, type, const_p);
1141   /* A destructor may be virtual.  */
1142   if (sfk == sfk_destructor)
1143     check_for_override (fn, type);
1144   /* Add it to CLASSTYPE_METHOD_VEC.  */
1145   add_method (type, fn, NULL_TREE);
1146   /* Add it to TYPE_METHODS.  */
1147   if (sfk == sfk_destructor
1148       && DECL_VIRTUAL_P (fn)
1149       && abi_version_at_least (2))
1150     /* The ABI requires that a virtual destructor go at the end of the
1151        vtable.  */
1152     TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1153   else
1154     {
1155       /* G++ 3.2 put the implicit destructor at the *beginning* of the
1156          TYPE_METHODS list, which cause the destructor to be emitted
1157          in an incorrect location in the vtable.  */
1158       if (warn_abi && DECL_VIRTUAL_P (fn))
1159         warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1160                  "and may change in a future version of GCC due to "
1161                  "implicit virtual destructor",
1162                  type);
1163       TREE_CHAIN (fn) = TYPE_METHODS (type);
1164       TYPE_METHODS (type) = fn;
1165     }
1166   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1167   if (sfk == sfk_assignment_operator)
1168     CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1169   else
1170     {
1171       /* Remember that the function has been created.  */
1172       if (sfk == sfk_constructor)
1173         CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1174       else if (sfk == sfk_copy_constructor)
1175         CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1176       else if (sfk == sfk_destructor)
1177         CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1178       /* Create appropriate clones.  */
1179       clone_function_decl (fn, /*update_method_vec=*/true);
1180     }
1181
1182   return fn;
1183 }
1184
1185 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1186    as there are artificial parms in FN.  */
1187
1188 tree
1189 skip_artificial_parms_for (const_tree fn, tree list)
1190 {
1191   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1192     list = TREE_CHAIN (list);
1193   else
1194     return list;
1195
1196   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1197     list = TREE_CHAIN (list);
1198   if (DECL_HAS_VTT_PARM_P (fn))
1199     list = TREE_CHAIN (list);
1200   return list;
1201 }
1202
1203 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1204    artificial parms in FN.  */
1205
1206 int
1207 num_artificial_parms_for (const_tree fn)
1208 {
1209   int count = 0;
1210
1211   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1212     count++;
1213   else
1214     return 0;
1215
1216   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1217     count++;
1218   if (DECL_HAS_VTT_PARM_P (fn))
1219     count++;
1220   return count;
1221 }
1222
1223
1224 #include "gt-cp-method.h"