OSDN Git Service

dc723553cbb053e0f3d834569045aab84ab159bd
[pf3gnuchains/gcc-fork.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, 1994, 1995, 1996, 1997, 1998,
4    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
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 "output.h"
33 #include "flags.h"
34 #include "toplev.h"
35 #include "tm_p.h"
36 #include "target.h"
37 #include "tree-pass.h"
38 #include "diagnostic.h"
39 #include "cgraph.h"
40 #include "gimple.h"
41
42 /* Various flags to control the mangling process.  */
43
44 enum mangling_flags
45 {
46   /* No flags.  */
47   mf_none = 0,
48   /* The thing we are presently mangling is part of a template type,
49      rather than a fully instantiated type.  Therefore, we may see
50      complex expressions where we would normally expect to see a
51      simple integer constant.  */
52   mf_maybe_uninstantiated = 1,
53   /* When mangling a numeric value, use the form `_XX_' (instead of
54      just `XX') if the value has more than one digit.  */
55   mf_use_underscores_around_value = 2
56 };
57
58 typedef enum mangling_flags mangling_flags;
59
60 static void do_build_copy_assign (tree);
61 static void do_build_copy_constructor (tree);
62 static tree make_alias_for_thunk (tree);
63
64 /* Called once to initialize method.c.  */
65
66 void
67 init_method (void)
68 {
69   init_mangle ();
70 }
71 \f
72 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
73    indicates whether it is a this or result adjusting thunk.
74    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
75    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
76    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
77    adjusting thunks, we scale it to a byte offset. For covariant
78    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
79    the returned thunk with finish_thunk.  */
80
81 tree
82 make_thunk (tree function, bool this_adjusting,
83             tree fixed_offset, tree virtual_offset)
84 {
85   HOST_WIDE_INT d;
86   tree thunk;
87
88   gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
89   /* We can have this thunks to covariant thunks, but not vice versa.  */
90   gcc_assert (!DECL_THIS_THUNK_P (function));
91   gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
92
93   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
94   if (this_adjusting && virtual_offset)
95     virtual_offset
96       = size_binop (MULT_EXPR,
97                     virtual_offset,
98                     convert (ssizetype,
99                              TYPE_SIZE_UNIT (vtable_entry_type)));
100
101   d = tree_low_cst (fixed_offset, 0);
102
103   /* See if we already have the thunk in question.  For this_adjusting
104      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
105      will be a BINFO.  */
106   for (thunk = DECL_THUNKS (function); thunk; thunk = DECL_CHAIN (thunk))
107     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
108         && THUNK_FIXED_OFFSET (thunk) == d
109         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
110         && (!virtual_offset
111             || (this_adjusting
112                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
113                                       virtual_offset)
114                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
115       return thunk;
116
117   /* All thunks must be created before FUNCTION is actually emitted;
118      the ABI requires that all thunks be emitted together with the
119      function to which they transfer control.  */
120   gcc_assert (!TREE_ASM_WRITTEN (function));
121   /* Likewise, we can only be adding thunks to a function declared in
122      the class currently being laid out.  */
123   gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
124               && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
125
126   thunk = build_decl (DECL_SOURCE_LOCATION (function),
127                       FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
128   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
129   cxx_dup_lang_specific_decl (thunk);
130   DECL_THUNKS (thunk) = NULL_TREE;
131
132   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
133   TREE_READONLY (thunk) = TREE_READONLY (function);
134   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
135   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
136   SET_DECL_THUNK_P (thunk, this_adjusting);
137   THUNK_TARGET (thunk) = function;
138   THUNK_FIXED_OFFSET (thunk) = d;
139   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
140   THUNK_ALIAS (thunk) = NULL_TREE;
141
142   /* The thunk itself is not a constructor or destructor, even if
143      the thing it is thunking to is.  */
144   DECL_INTERFACE_KNOWN (thunk) = 1;
145   DECL_NOT_REALLY_EXTERN (thunk) = 1;
146   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
147   DECL_DESTRUCTOR_P (thunk) = 0;
148   DECL_CONSTRUCTOR_P (thunk) = 0;
149   DECL_EXTERNAL (thunk) = 1;
150   DECL_ARTIFICIAL (thunk) = 1;
151   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
152   DECL_PENDING_INLINE_P (thunk) = 0;
153   DECL_DECLARED_INLINE_P (thunk) = 0;
154   /* Nor is it a template instantiation.  */
155   DECL_USE_TEMPLATE (thunk) = 0;
156   DECL_TEMPLATE_INFO (thunk) = NULL;
157
158   /* Add it to the list of thunks associated with FUNCTION.  */
159   DECL_CHAIN (thunk) = DECL_THUNKS (function);
160   DECL_THUNKS (function) = thunk;
161
162   return thunk;
163 }
164
165 /* Finish THUNK, a thunk decl.  */
166
167 void
168 finish_thunk (tree thunk)
169 {
170   tree function, name;
171   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
172   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
173
174   gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
175   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
176     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
177   function = THUNK_TARGET (thunk);
178   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
179                        fixed_offset, virtual_offset);
180
181   /* We can end up with declarations of (logically) different
182      covariant thunks, that do identical adjustments.  The two thunks
183      will be adjusting between within different hierarchies, which
184      happen to have the same layout.  We must nullify one of them to
185      refer to the other.  */
186   if (DECL_RESULT_THUNK_P (thunk))
187     {
188       tree cov_probe;
189
190       for (cov_probe = DECL_THUNKS (function);
191            cov_probe; cov_probe = DECL_CHAIN (cov_probe))
192         if (DECL_NAME (cov_probe) == name)
193           {
194             gcc_assert (!DECL_THUNKS (thunk));
195             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
196                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
197             break;
198           }
199     }
200
201   DECL_NAME (thunk) = name;
202   SET_DECL_ASSEMBLER_NAME (thunk, name);
203 }
204
205 static GTY (()) int thunk_labelno;
206
207 /* Create a static alias to target.  */
208
209 tree
210 make_alias_for (tree target, tree newid)
211 {
212   tree alias = build_decl (DECL_SOURCE_LOCATION (target),
213                            TREE_CODE (target), newid, TREE_TYPE (target));
214   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target);
215   cxx_dup_lang_specific_decl (alias);
216   DECL_CONTEXT (alias) = NULL;
217   TREE_READONLY (alias) = TREE_READONLY (target);
218   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target);
219   TREE_PUBLIC (alias) = 0;
220   DECL_INTERFACE_KNOWN (alias) = 1;
221   if (DECL_LANG_SPECIFIC (alias))
222     {
223       DECL_NOT_REALLY_EXTERN (alias) = 1;
224       DECL_USE_TEMPLATE (alias) = 0;
225       DECL_TEMPLATE_INFO (alias) = NULL;
226     }
227   DECL_EXTERNAL (alias) = 0;
228   DECL_ARTIFICIAL (alias) = 1;
229   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
230   if (TREE_CODE (alias) == FUNCTION_DECL)
231     {
232       DECL_SAVED_FUNCTION_DATA (alias) = NULL;
233       DECL_DESTRUCTOR_P (alias) = 0;
234       DECL_CONSTRUCTOR_P (alias) = 0;
235       DECL_PENDING_INLINE_P (alias) = 0;
236       DECL_DECLARED_INLINE_P (alias) = 0;
237       DECL_INITIAL (alias) = error_mark_node;
238       DECL_ARGUMENTS (alias) = copy_list (DECL_ARGUMENTS (target));
239     }
240   else
241     TREE_STATIC (alias) = 1;
242   TREE_ADDRESSABLE (alias) = 1;
243   TREE_USED (alias) = 1;
244   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
245   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
246   return alias;
247 }
248
249 static tree
250 make_alias_for_thunk (tree function)
251 {
252   tree alias;
253   char buf[256];
254
255   targetm.asm_out.generate_internal_label (buf, "LTHUNK", thunk_labelno);
256   thunk_labelno++;
257
258   alias = make_alias_for (function, get_identifier (buf));
259
260   if (!flag_syntax_only)
261     {
262       struct cgraph_node *aliasn = cgraph_same_body_alias (alias, function);
263       DECL_ASSEMBLER_NAME (function);
264       gcc_assert (aliasn != NULL);
265     }
266
267   return alias;
268 }
269
270 /* Emit the definition of a C++ multiple inheritance or covariant
271    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
272    immediately.  */
273
274 void
275 use_thunk (tree thunk_fndecl, bool emit_p)
276 {
277   tree a, t, function, alias;
278   tree virtual_offset;
279   HOST_WIDE_INT fixed_offset, virtual_value;
280   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
281
282   /* We should have called finish_thunk to give it a name.  */
283   gcc_assert (DECL_NAME (thunk_fndecl));
284
285   /* We should never be using an alias, always refer to the
286      aliased thunk.  */
287   gcc_assert (!THUNK_ALIAS (thunk_fndecl));
288
289   if (TREE_ASM_WRITTEN (thunk_fndecl))
290     return;
291
292   function = THUNK_TARGET (thunk_fndecl);
293   if (DECL_RESULT (thunk_fndecl))
294     /* We already turned this thunk into an ordinary function.
295        There's no need to process this thunk again.  */
296     return;
297
298   if (DECL_THUNK_P (function))
299     /* The target is itself a thunk, process it now.  */
300     use_thunk (function, emit_p);
301
302   /* Thunks are always addressable; they only appear in vtables.  */
303   TREE_ADDRESSABLE (thunk_fndecl) = 1;
304
305   /* Figure out what function is being thunked to.  It's referenced in
306      this translation unit.  */
307   TREE_ADDRESSABLE (function) = 1;
308   mark_used (function);
309   if (!emit_p)
310     return;
311
312   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
313    alias = make_alias_for_thunk (function);
314   else
315    alias = function;
316
317   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
318   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
319
320   if (virtual_offset)
321     {
322       if (!this_adjusting)
323         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
324       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
325       gcc_assert (virtual_value);
326     }
327   else
328     virtual_value = 0;
329
330   /* And, if we need to emit the thunk, it's used.  */
331   mark_used (thunk_fndecl);
332   /* This thunk is actually defined.  */
333   DECL_EXTERNAL (thunk_fndecl) = 0;
334   /* The linkage of the function may have changed.  FIXME in linkage
335      rewrite.  */
336   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
337   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
338   DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
339     = DECL_VISIBILITY_SPECIFIED (function);
340   if (DECL_ONE_ONLY (function) || DECL_WEAK (function))
341     make_decl_one_only (thunk_fndecl, cxx_comdat_group (thunk_fndecl));
342
343   if (flag_syntax_only)
344     {
345       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
346       return;
347     }
348
349   push_to_top_level ();
350
351   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
352       && targetm.have_named_sections)
353     {
354       resolve_unique_section (function, 0, flag_function_sections);
355
356       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
357         {
358           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
359
360           /* Output the thunk into the same section as function.  */
361           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
362         }
363     }
364
365   /* Set up cloned argument trees for the thunk.  */
366   t = NULL_TREE;
367   for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
368     {
369       tree x = copy_node (a);
370       DECL_CHAIN (x) = t;
371       DECL_CONTEXT (x) = thunk_fndecl;
372       SET_DECL_RTL (x, NULL);
373       DECL_HAS_VALUE_EXPR_P (x) = 0;
374       t = x;
375     }
376   a = nreverse (t);
377   DECL_ARGUMENTS (thunk_fndecl) = a;
378   TREE_ASM_WRITTEN (thunk_fndecl) = 1;
379   cgraph_add_thunk (thunk_fndecl, function,
380                     this_adjusting, fixed_offset, virtual_value,
381                     virtual_offset, alias);
382
383   if (!this_adjusting
384       || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
385                                                virtual_value, alias))
386     {
387       /* If this is a covariant thunk, or we don't have the necessary
388          code for efficient thunks, generate a thunk function that
389          just makes a call to the real function.  Unfortunately, this
390          doesn't work for varargs.  */
391
392       if (varargs_function_p (function))
393         error ("generic thunk code fails for method %q#D which uses %<...%>",
394                function);
395     }
396
397   pop_from_top_level ();
398 }
399 \f
400 /* Code for synthesizing methods which have default semantics defined.  */
401
402 /* True iff CTYPE has a trivial SFK.  */
403
404 static bool
405 type_has_trivial_fn (tree ctype, special_function_kind sfk)
406 {
407   switch (sfk)
408     {
409     case sfk_constructor:
410       return !TYPE_HAS_COMPLEX_DFLT (ctype);
411     case sfk_copy_constructor:
412       return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
413     case sfk_move_constructor:
414       return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
415     case sfk_copy_assignment:
416       return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
417     case sfk_move_assignment:
418       return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
419     case sfk_destructor:
420       return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
421     default:
422       gcc_unreachable ();
423     }
424 }
425
426 /* Note that CTYPE has a non-trivial SFK even though we previously thought
427    it was trivial.  */
428
429 static void
430 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
431 {
432   switch (sfk)
433     {
434     case sfk_constructor:
435       TYPE_HAS_COMPLEX_DFLT (ctype) = true;
436       return;
437     case sfk_copy_constructor:
438       TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
439       return;
440     case sfk_move_constructor:
441       TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
442       return;
443     case sfk_copy_assignment:
444       TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
445       return;
446     case sfk_move_assignment:
447       TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
448       return;
449     case sfk_destructor:
450       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
451       return;
452     default:
453       gcc_unreachable ();
454     }
455 }
456
457 /* True iff FN is a trivial defaulted member function ([cd]tor, op=).  */
458
459 bool
460 trivial_fn_p (tree fn)
461 {
462   if (!DECL_DEFAULTED_FN (fn))
463     return false;
464
465   /* If fn is a clone, get the primary variant.  */
466   fn = DECL_ORIGIN (fn);
467   return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
468 }
469
470 /* Generate code for default X(X&) or X(X&&) constructor.  */
471
472 static void
473 do_build_copy_constructor (tree fndecl)
474 {
475   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
476   bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
477   bool trivial = trivial_fn_p (fndecl);
478
479   parm = convert_from_reference (parm);
480
481   if (trivial
482       && is_empty_class (current_class_type))
483     /* Don't copy the padding byte; it might not have been allocated
484        if *this is a base subobject.  */;
485   else if (trivial)
486     {
487       tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
488       finish_expr_stmt (t);
489     }
490   else
491     {
492       tree fields = TYPE_FIELDS (current_class_type);
493       tree member_init_list = NULL_TREE;
494       int cvquals = cp_type_quals (TREE_TYPE (parm));
495       int i;
496       tree binfo, base_binfo;
497       tree init;
498       VEC(tree,gc) *vbases;
499
500       /* Initialize all the base-classes with the parameter converted
501          to their type so that we get their copy constructor and not
502          another constructor that takes current_class_type.  We must
503          deal with the binfo's directly as a direct base might be
504          inaccessible due to ambiguity.  */
505       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
506            VEC_iterate (tree, vbases, i, binfo); i++)
507         {
508           init = build_base_path (PLUS_EXPR, parm, binfo, 1);
509           if (move_p)
510             init = move (init);
511           member_init_list
512             = tree_cons (binfo,
513                          build_tree_list (NULL_TREE, init),
514                          member_init_list);
515         }
516
517       for (binfo = TYPE_BINFO (current_class_type), i = 0;
518            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
519         {
520           if (BINFO_VIRTUAL_P (base_binfo))
521             continue;
522
523           init = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
524           if (move_p)
525             init = move (init);
526           member_init_list
527             = tree_cons (base_binfo,
528                          build_tree_list (NULL_TREE, init),
529                          member_init_list);
530         }
531
532       for (; fields; fields = DECL_CHAIN (fields))
533         {
534           tree field = fields;
535           tree expr_type;
536
537           if (TREE_CODE (field) != FIELD_DECL)
538             continue;
539
540           expr_type = TREE_TYPE (field);
541           if (DECL_NAME (field))
542             {
543               if (VFIELD_NAME_P (DECL_NAME (field)))
544                 continue;
545             }
546           else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
547             /* Just use the field; anonymous types can't have
548                nontrivial copy ctors or assignment ops or this
549                function would be deleted.  */;
550           else
551             continue;
552
553           /* Compute the type of "init->field".  If the copy-constructor
554              parameter is, for example, "const S&", and the type of
555              the field is "T", then the type will usually be "const
556              T".  (There are no cv-qualified variants of reference
557              types.)  */
558           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
559             {
560               int quals = cvquals;
561
562               if (DECL_MUTABLE_P (field))
563                 quals &= ~TYPE_QUAL_CONST;
564               quals |= cp_type_quals (expr_type);
565               expr_type = cp_build_qualified_type (expr_type, quals);
566             }
567
568           init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
569           if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
570             init = move (init);
571           init = build_tree_list (NULL_TREE, init);
572
573           member_init_list = tree_cons (field, init, member_init_list);
574         }
575       finish_mem_initializers (member_init_list);
576     }
577 }
578
579 static void
580 do_build_copy_assign (tree fndecl)
581 {
582   tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
583   tree compound_stmt;
584   bool move_p = move_fn_p (fndecl);
585   bool trivial = trivial_fn_p (fndecl);
586
587   compound_stmt = begin_compound_stmt (0);
588   parm = convert_from_reference (parm);
589
590   if (trivial
591       && is_empty_class (current_class_type))
592     /* Don't copy the padding byte; it might not have been allocated
593        if *this is a base subobject.  */;
594   else if (trivial)
595     {
596       tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
597       finish_expr_stmt (t);
598     }
599   else
600     {
601       tree fields;
602       int cvquals = cp_type_quals (TREE_TYPE (parm));
603       int i;
604       tree binfo, base_binfo;
605
606       /* Assign to each of the direct base classes.  */
607       for (binfo = TYPE_BINFO (current_class_type), i = 0;
608            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
609         {
610           tree converted_parm;
611           VEC(tree,gc) *parmvec;
612
613           /* We must convert PARM directly to the base class
614              explicitly since the base class may be ambiguous.  */
615           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
616           if (move_p)
617             converted_parm = move (converted_parm);
618           /* Call the base class assignment operator.  */
619           parmvec = make_tree_vector_single (converted_parm);
620           finish_expr_stmt
621             (build_special_member_call (current_class_ref,
622                                         ansi_assopname (NOP_EXPR),
623                                         &parmvec,
624                                         base_binfo,
625                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
626                                         tf_warning_or_error));
627           release_tree_vector (parmvec);
628         }
629
630       /* Assign to each of the non-static data members.  */
631       for (fields = TYPE_FIELDS (current_class_type);
632            fields;
633            fields = DECL_CHAIN (fields))
634         {
635           tree comp = current_class_ref;
636           tree init = parm;
637           tree field = fields;
638           tree expr_type;
639           int quals;
640
641           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
642             continue;
643
644           expr_type = TREE_TYPE (field);
645
646           if (CP_TYPE_CONST_P (expr_type))
647             {
648               error ("non-static const member %q#D, can%'t use default "
649                      "assignment operator", field);
650               continue;
651             }
652           else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
653             {
654               error ("non-static reference member %q#D, can%'t use "
655                      "default assignment operator", field);
656               continue;
657             }
658
659           if (DECL_NAME (field))
660             {
661               if (VFIELD_NAME_P (DECL_NAME (field)))
662                 continue;
663             }
664           else if (ANON_AGGR_TYPE_P (expr_type)
665                    && TYPE_FIELDS (expr_type) != NULL_TREE)
666             /* Just use the field; anonymous types can't have
667                nontrivial copy ctors or assignment ops or this
668                function would be deleted.  */;
669           else
670             continue;
671
672           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
673
674           /* Compute the type of init->field  */
675           quals = cvquals;
676           if (DECL_MUTABLE_P (field))
677             quals &= ~TYPE_QUAL_CONST;
678           expr_type = cp_build_qualified_type (expr_type, quals);
679
680           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
681           if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
682             init = move (init);
683
684           if (DECL_NAME (field))
685             init = cp_build_modify_expr (comp, NOP_EXPR, init, 
686                                          tf_warning_or_error);
687           else
688             init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
689           finish_expr_stmt (init);
690         }
691     }
692   finish_return_stmt (current_class_ref);
693   finish_compound_stmt (compound_stmt);
694 }
695
696 /* Synthesize FNDECL, a non-static member function.   */
697
698 void
699 synthesize_method (tree fndecl)
700 {
701   bool nested = (current_function_decl != NULL_TREE);
702   tree context = decl_function_context (fndecl);
703   bool need_body = true;
704   tree stmt;
705   location_t save_input_location = input_location;
706   int error_count = errorcount;
707   int warning_count = warningcount;
708
709   /* Reset the source location, we might have been previously
710      deferred, and thus have saved where we were first needed.  */
711   DECL_SOURCE_LOCATION (fndecl)
712     = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
713
714   /* If we've been asked to synthesize a clone, just synthesize the
715      cloned function instead.  Doing so will automatically fill in the
716      body for the clone.  */
717   if (DECL_CLONED_FUNCTION_P (fndecl))
718     fndecl = DECL_CLONED_FUNCTION (fndecl);
719
720   /* We may be in the middle of deferred access check.  Disable
721      it now.  */
722   push_deferring_access_checks (dk_no_deferred);
723
724   if (! context)
725     push_to_top_level ();
726   else if (nested)
727     push_function_context ();
728
729   input_location = DECL_SOURCE_LOCATION (fndecl);
730
731   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
732   stmt = begin_function_body ();
733
734   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
735     {
736       do_build_copy_assign (fndecl);
737       need_body = false;
738     }
739   else if (DECL_CONSTRUCTOR_P (fndecl))
740     {
741       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
742       if (arg_chain != void_list_node)
743         do_build_copy_constructor (fndecl);
744       else
745         finish_mem_initializers (NULL_TREE);
746     }
747
748   /* If we haven't yet generated the body of the function, just
749      generate an empty compound statement.  */
750   if (need_body)
751     {
752       tree compound_stmt;
753       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
754       finish_compound_stmt (compound_stmt);
755     }
756
757   finish_function_body (stmt);
758   expand_or_defer_fn (finish_function (0));
759
760   input_location = save_input_location;
761
762   if (! context)
763     pop_from_top_level ();
764   else if (nested)
765     pop_function_context ();
766
767   pop_deferring_access_checks ();
768
769   if (error_count != errorcount || warning_count != warningcount)
770     inform (input_location, "synthesized method %qD first required here ",
771             fndecl);
772 }
773
774 /* Build a reference to type TYPE with cv-quals QUALS, which is an
775    rvalue if RVALUE is true.  */
776
777 static tree
778 build_stub_type (tree type, int quals, bool rvalue)
779 {
780   tree argtype = cp_build_qualified_type (type, quals);
781   return cp_build_reference_type (argtype, rvalue);
782 }
783
784 /* Build a dummy glvalue from dereferencing a dummy reference of type
785    REFTYPE.  */
786
787 static tree
788 build_stub_object (tree reftype)
789 {
790   tree stub = build1 (NOP_EXPR, reftype, integer_one_node);
791   return convert_from_reference (stub);
792 }
793
794 /* Determine which function will be called when looking up NAME in TYPE,
795    called with a single ARGTYPE argument, or no argument if ARGTYPE is
796    null.  FLAGS and COMPLAIN are as for build_new_method_call.
797
798    Returns a FUNCTION_DECL if all is well.
799    Returns NULL_TREE if overload resolution failed.
800    Returns error_mark_node if the chosen function cannot be called.  */
801
802 static tree
803 locate_fn_flags (tree type, tree name, tree argtype, int flags,
804                  tsubst_flags_t complain)
805 {
806   tree ob, fn, fns, binfo, rval;
807   VEC(tree,gc) *args;
808
809   if (TYPE_P (type))
810     binfo = TYPE_BINFO (type);
811   else
812     {
813       binfo = type;
814       type = BINFO_TYPE (binfo);
815     }
816
817   ob = build_stub_object (cp_build_reference_type (type, false));
818   args = make_tree_vector ();
819   if (argtype)
820     {
821       tree arg = build_stub_object (argtype);
822       VEC_quick_push (tree, args, arg);
823     }
824
825   fns = lookup_fnfields (binfo, name, 0);
826   rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
827
828   release_tree_vector (args);
829   if (fn && rval == error_mark_node)
830     return rval;
831   else
832     return fn;
833 }
834
835 /* Locate the dtor of TYPE.  */
836
837 tree
838 get_dtor (tree type)
839 {
840   tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
841                              LOOKUP_NORMAL, tf_warning_or_error);
842   if (fn == error_mark_node)
843     return NULL_TREE;
844   return fn;
845 }
846
847 /* Locate the default ctor of TYPE.  */
848
849 tree
850 locate_ctor (tree type)
851 {
852   tree fn;
853
854   push_deferring_access_checks (dk_no_check);
855   fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
856                         LOOKUP_SPECULATIVE, tf_none);
857   pop_deferring_access_checks ();
858   if (fn == error_mark_node)
859     return NULL_TREE;
860   return fn;
861 }
862
863 /* Likewise, but give any appropriate errors.  */
864
865 tree
866 get_default_ctor (tree type)
867 {
868   tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
869                              LOOKUP_NORMAL, tf_warning_or_error);
870   if (fn == error_mark_node)
871     return NULL_TREE;
872   return fn;
873 }
874
875 /* Locate the copy ctor of TYPE.  */
876
877 tree
878 get_copy_ctor (tree type)
879 {
880   int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
881                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
882   tree argtype = build_stub_type (type, quals, false);
883   tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
884                              LOOKUP_NORMAL, tf_warning_or_error);
885   if (fn == error_mark_node)
886     return NULL_TREE;
887   return fn;
888 }
889
890 /* Locate the copy assignment operator of TYPE.  */
891
892 tree
893 get_copy_assign (tree type)
894 {
895   int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
896                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
897   tree argtype = build_stub_type (type, quals, false);
898   tree fn = locate_fn_flags (type, ansi_assopname (NOP_EXPR), argtype,
899                              LOOKUP_NORMAL, tf_warning_or_error);
900   if (fn == error_mark_node)
901     return NULL_TREE;
902   return fn;
903 }
904
905 /* Subroutine of synthesized_method_walk.  Update SPEC_P, TRIVIAL_P and
906    DELETED_P or give an error message MSG with argument ARG.  */
907
908 static void
909 process_subob_fn (tree fn, bool move_p, tree *spec_p, bool *trivial_p,
910                   bool *deleted_p, bool *constexpr_p,
911                   const char *msg, tree arg)
912 {
913   if (!fn || fn == error_mark_node)
914     goto bad;
915
916   if (spec_p)
917     {
918       tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
919       *spec_p = merge_exception_specifiers (*spec_p, raises);
920     }
921
922   if (!trivial_fn_p (fn))
923     {
924       if (trivial_p)
925         *trivial_p = false;
926       if (TREE_CODE (arg) == FIELD_DECL
927           && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
928         {
929           if (deleted_p)
930             *deleted_p = true;
931           if (msg)
932             error ("union member %q+D with non-trivial %qD", arg, fn);
933         }
934     }
935
936   if (move_p && !move_fn_p (fn) && !trivial_fn_p (fn))
937     {
938       if (msg)
939         error (msg, arg);
940       goto bad;
941     }
942
943   if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
944     *constexpr_p = false;
945
946   return;
947
948  bad:
949   if (deleted_p)
950     *deleted_p = true;
951 }
952
953 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
954    aggregates.  */
955
956 static void
957 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
958                    int quals, bool copy_arg_p, bool move_p,
959                    bool assign_p, tree *spec_p, bool *trivial_p,
960                    bool *deleted_p, bool *constexpr_p, const char *msg,
961                    int flags, tsubst_flags_t complain)
962 {
963   tree field;
964   for (field = fields; field; field = DECL_CHAIN (field))
965     {
966       tree mem_type, argtype, rval;
967
968       if (TREE_CODE (field) != FIELD_DECL
969           || DECL_ARTIFICIAL (field))
970         continue;
971
972       mem_type = strip_array_types (TREE_TYPE (field));
973       if (assign_p)
974         {
975           bool bad = true;
976           if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
977             {
978               if (msg)
979                 error ("non-static const member %q#D, can%'t use default "
980                        "assignment operator", field);
981             }
982           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
983             {
984               if (msg)
985                 error ("non-static reference member %q#D, can%'t use "
986                        "default assignment operator", field);
987             }
988           else
989             bad = false;
990
991           if (bad && deleted_p)
992             *deleted_p = true;
993         }
994       else if (sfk == sfk_constructor)
995         {
996           bool bad = true;
997           if (CP_TYPE_CONST_P (mem_type)
998               && (!CLASS_TYPE_P (mem_type)
999                   || !type_has_user_provided_default_constructor (mem_type)))
1000             {
1001               if (msg)
1002                 error ("uninitialized non-static const member %q#D",
1003                        field);
1004             }
1005           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1006             {
1007               if (msg)
1008                 error ("uninitialized non-static reference member %q#D",
1009                        field);
1010             }
1011           else
1012             bad = false;
1013
1014           if (bad && deleted_p)
1015             *deleted_p = true;
1016
1017           /* For an implicitly-defined default constructor to be constexpr,
1018              every member must have a user-provided default constructor.  */
1019           /* FIXME will need adjustment for non-static data member
1020              initializers.  */
1021           if (constexpr_p && !CLASS_TYPE_P (mem_type))
1022             *constexpr_p = false;
1023         }
1024
1025       if (!CLASS_TYPE_P (mem_type))
1026         continue;
1027
1028       if (ANON_AGGR_TYPE_P (mem_type))
1029         {
1030           walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1031                              copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1032                              deleted_p, constexpr_p, msg, flags, complain);
1033           continue;
1034         }
1035
1036       if (copy_arg_p)
1037         {
1038           int mem_quals = cp_type_quals (mem_type) | quals;
1039           if (DECL_MUTABLE_P (field))
1040             mem_quals &= ~TYPE_QUAL_CONST;
1041           argtype = build_stub_type (mem_type, mem_quals, move_p);
1042         }
1043       else
1044         argtype = NULL_TREE;
1045
1046       rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1047
1048       process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1049                         constexpr_p, msg, field);
1050     }
1051 }
1052
1053 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1054    which is const if relevant and CONST_P is set.  If spec_p, trivial_p and
1055    deleted_p are non-null, set their referent appropriately.  If diag is
1056    true, we're being called from maybe_explain_implicit_delete to give
1057    errors.  */
1058
1059 static void
1060 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1061                          tree *spec_p, bool *trivial_p, bool *deleted_p,
1062                          bool *constexpr_p, bool diag)
1063 {
1064   tree binfo, base_binfo, scope, fnname, rval, argtype;
1065   bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1066   VEC(tree,gc) *vbases;
1067   int i, quals, flags;
1068   tsubst_flags_t complain;
1069   const char *msg;
1070   bool ctor_p;
1071   tree cleanup_spec;
1072   bool cleanup_trivial = true;
1073   bool cleanup_deleted = false;
1074
1075   cleanup_spec
1076     = (cxx_dialect >= cxx0x ? noexcept_true_spec : empty_except_spec);
1077   if (spec_p)
1078     *spec_p = cleanup_spec;
1079
1080   if (deleted_p)
1081     {
1082       /* "The closure type associated with a lambda-expression has a deleted
1083          default constructor and a deleted copy assignment operator."
1084          This is diagnosed in maybe_explain_implicit_delete.  */
1085       if (LAMBDA_TYPE_P (ctype)
1086           && (sfk == sfk_constructor
1087               || sfk == sfk_copy_assignment))
1088         {
1089           *deleted_p = true;
1090           return;
1091         }
1092
1093       *deleted_p = false;
1094     }
1095
1096   ctor_p = false;
1097   assign_p = false;
1098   check_vdtor = false;
1099   switch (sfk)
1100     {
1101     case sfk_move_assignment:
1102     case sfk_copy_assignment:
1103       assign_p = true;
1104       fnname = ansi_assopname (NOP_EXPR);
1105       break;
1106
1107     case sfk_destructor:
1108       check_vdtor = true;
1109       /* The synthesized method will call base dtors, but check complete
1110          here to avoid having to deal with VTT.  */
1111       fnname = complete_dtor_identifier;
1112       break;
1113
1114     case sfk_constructor:
1115     case sfk_move_constructor:
1116     case sfk_copy_constructor:
1117       ctor_p = true;
1118       fnname = complete_ctor_identifier;
1119       break;
1120
1121     default:
1122       gcc_unreachable ();
1123     }
1124
1125   /* If that user-written default constructor would satisfy the
1126      requirements of a constexpr constructor (7.1.5), the
1127      implicitly-defined default constructor is constexpr.  */
1128   if (constexpr_p)
1129     *constexpr_p = ctor_p;
1130
1131   move_p = false;
1132   switch (sfk)
1133     {
1134     case sfk_constructor:
1135     case sfk_destructor:
1136       copy_arg_p = false;
1137       break;
1138
1139     case sfk_move_constructor:
1140     case sfk_move_assignment:
1141       move_p = true;
1142     case sfk_copy_constructor:
1143     case sfk_copy_assignment:
1144       copy_arg_p = true;
1145       break;
1146
1147     default:
1148       gcc_unreachable ();
1149     }
1150
1151   expected_trivial = type_has_trivial_fn (ctype, sfk);
1152   if (trivial_p)
1153     *trivial_p = expected_trivial;
1154
1155 #ifndef ENABLE_CHECKING
1156   /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1157      class versions and other properties of the type.  But a subobject
1158      class can be trivially copyable and yet have overload resolution
1159      choose a template constructor for initialization, depending on
1160      rvalueness and cv-quals.  So we can't exit early for copy/move
1161      methods in C++0x.  */
1162   if (expected_trivial
1163       && (!copy_arg_p || cxx_dialect < cxx0x))
1164     {
1165       if (constexpr_p && sfk == sfk_constructor)
1166         *constexpr_p = synthesized_default_constructor_is_constexpr (ctype);
1167       return;
1168     }
1169 #endif
1170
1171   ++cp_unevaluated_operand;
1172   ++c_inhibit_evaluation_warnings;
1173
1174   scope = push_scope (ctype);
1175
1176   if (diag)
1177     {
1178       flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE;
1179       complain = tf_warning_or_error;
1180     }
1181   else
1182     {
1183       flags = LOOKUP_PROTECT|LOOKUP_SPECULATIVE;
1184       complain = tf_none;
1185     }
1186
1187   if (const_p)
1188     quals = TYPE_QUAL_CONST;
1189   else
1190     quals = TYPE_UNQUALIFIED;
1191   argtype = NULL_TREE;
1192
1193   if (!diag)
1194     msg = NULL;
1195   else if (assign_p)
1196     msg = ("base %qT does not have a move assignment operator or trivial "
1197            "copy assignment operator");
1198   else
1199     msg = ("base %qT does not have a move constructor or trivial "
1200            "copy constructor");
1201
1202   for (binfo = TYPE_BINFO (ctype), i = 0;
1203        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1204     {
1205       tree basetype = BINFO_TYPE (base_binfo);
1206       if (copy_arg_p)
1207         argtype = build_stub_type (basetype, quals, move_p);
1208       rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1209
1210       process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1211                         constexpr_p, msg, basetype);
1212       if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1213         {
1214           /* In a constructor we also need to check the subobject
1215              destructors for cleanup of partially constructed objects.  */
1216           rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1217                                   NULL_TREE, flags, complain);
1218           process_subob_fn (rval, false, &cleanup_spec, &cleanup_trivial,
1219                             &cleanup_deleted, NULL, NULL,
1220                             basetype);
1221         }
1222
1223       if (check_vdtor && type_has_virtual_destructor (basetype))
1224         {
1225           rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1226                                   ptr_type_node, flags, complain);
1227           /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1228              to have a null rval (no class-specific op delete).  */
1229           if (rval && rval == error_mark_node && deleted_p)
1230             *deleted_p = true;
1231           check_vdtor = false;
1232         }
1233     }
1234
1235   vbases = CLASSTYPE_VBASECLASSES (ctype);
1236   if (vbases && assign_p && move_p)
1237     {
1238       /* Should the spec be changed to allow vbases that only occur once?  */
1239       if (diag)
1240         error ("%qT has virtual bases, default move assignment operator "
1241                "cannot be generated", ctype);
1242       else if (deleted_p)
1243         *deleted_p = true;
1244     }
1245   else if (!assign_p)
1246     {
1247       if (diag)
1248         msg = ("virtual base %qT does not have a move constructor "
1249                "or trivial copy constructor");
1250       if (vbases && constexpr_p)
1251         *constexpr_p = false;
1252       FOR_EACH_VEC_ELT (tree, vbases, i, base_binfo)
1253         {
1254           tree basetype = BINFO_TYPE (base_binfo);
1255           if (copy_arg_p)
1256             argtype = build_stub_type (basetype, quals, move_p);
1257           rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1258
1259           process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1260                             constexpr_p, msg, basetype);
1261           if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1262             {
1263               rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1264                                       NULL_TREE, flags, complain);
1265               process_subob_fn (rval, false, &cleanup_spec, &cleanup_trivial,
1266                                 &cleanup_deleted, NULL, NULL,
1267                                 basetype);
1268             }
1269         }
1270     }
1271   if (!diag)
1272     /* Leave msg null. */;
1273   else if (assign_p)
1274     msg = ("non-static data member %qD does not have a move "
1275            "assignment operator or trivial copy assignment operator");
1276   else
1277     msg = ("non-static data member %qD does not have a move "
1278            "constructor or trivial copy constructor");
1279   walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1280                      copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1281                      deleted_p, constexpr_p, msg, flags, complain);
1282   if (ctor_p)
1283     walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1284                        sfk_destructor, TYPE_UNQUALIFIED, false,
1285                        false, false, &cleanup_spec, &cleanup_trivial,
1286                        &cleanup_deleted, NULL,
1287                        NULL, flags, complain);
1288
1289   pop_scope (scope);
1290
1291   --cp_unevaluated_operand;
1292   --c_inhibit_evaluation_warnings;
1293
1294   /* If the constructor isn't trivial, consider the subobject cleanups.  */
1295   if (ctor_p && trivial_p && !*trivial_p)
1296     {
1297       if (deleted_p && cleanup_deleted)
1298         *deleted_p = true;
1299       if (spec_p)
1300         *spec_p = merge_exception_specifiers (*spec_p, cleanup_spec);
1301     }
1302
1303 #ifdef ENABLE_CHECKING
1304   /* If we expected this to be trivial but it isn't, then either we're in
1305      C++0x mode and this is a copy/move ctor/op= or there's an error.  */
1306   gcc_assert (!(trivial_p && expected_trivial && !*trivial_p)
1307               || (copy_arg_p && cxx_dialect >= cxx0x)
1308               || errorcount);
1309 #endif
1310 }
1311
1312 /* DECL is a deleted function.  If it's implicitly deleted, explain why and
1313    return true; else return false.  */
1314
1315 bool
1316 maybe_explain_implicit_delete (tree decl)
1317 {
1318   /* If decl is a clone, get the primary variant.  */
1319   decl = DECL_ORIGIN (decl);
1320   gcc_assert (DECL_DELETED_FN (decl));
1321   if (DECL_DEFAULTED_FN (decl))
1322     {
1323       /* Not marked GTY; it doesn't need to be GC'd or written to PCH.  */
1324       static htab_t explained_htab;
1325       void **slot;
1326
1327       special_function_kind sfk;
1328       location_t loc;
1329       bool informed;
1330       tree ctype;
1331
1332       if (!explained_htab)
1333         explained_htab = htab_create (37, htab_hash_pointer,
1334                                       htab_eq_pointer, NULL);
1335       slot = htab_find_slot (explained_htab, decl, INSERT);
1336       if (*slot)
1337         return true;
1338       *slot = decl;
1339
1340       sfk = special_function_p (decl);
1341       ctype = DECL_CONTEXT (decl);
1342       loc = input_location;
1343       input_location = DECL_SOURCE_LOCATION (decl);
1344
1345       informed = false;
1346       if (LAMBDA_TYPE_P (ctype))
1347         {
1348           informed = true;
1349           if (sfk == sfk_constructor)
1350             error ("a lambda closure type has a deleted default constructor");
1351           else if (sfk == sfk_copy_assignment)
1352             error ("a lambda closure type has a deleted copy assignment operator");
1353           else
1354             informed = false;
1355         }
1356       if (!informed)
1357         {
1358           tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1359           bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1360           tree scope = push_scope (ctype);
1361           error ("%qD is implicitly deleted because the default "
1362                  "definition would be ill-formed:", decl);
1363           pop_scope (scope);
1364           synthesized_method_walk (ctype, sfk, const_p,
1365                                    NULL, NULL, NULL, NULL, true);
1366         }
1367
1368       input_location = loc;
1369       return true;
1370     }
1371   return false;
1372 }
1373
1374 /* Implicitly declare the special function indicated by KIND, as a
1375    member of TYPE.  For copy constructors and assignment operators,
1376    CONST_P indicates whether these functions should take a const
1377    reference argument or a non-const reference.  Returns the
1378    FUNCTION_DECL for the implicitly declared function.  */
1379
1380 static tree
1381 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
1382 {
1383   tree fn;
1384   tree parameter_types = void_list_node;
1385   tree return_type;
1386   tree fn_type;
1387   tree raises = empty_except_spec;
1388   tree rhs_parm_type = NULL_TREE;
1389   tree this_parm;
1390   tree name;
1391   HOST_WIDE_INT saved_processing_template_decl;
1392   bool deleted_p;
1393   bool trivial_p;
1394   bool constexpr_p;
1395
1396   /* Because we create declarations for implicitly declared functions
1397      lazily, we may be creating the declaration for a member of TYPE
1398      while in some completely different context.  However, TYPE will
1399      never be a dependent class (because we never want to do lookups
1400      for implicitly defined functions in a dependent class).
1401      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1402      because we only create clones for constructors and destructors
1403      when not in a template.  */
1404   gcc_assert (!dependent_type_p (type));
1405   saved_processing_template_decl = processing_template_decl;
1406   processing_template_decl = 0;
1407
1408   type = TYPE_MAIN_VARIANT (type);
1409
1410   if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1411     {
1412       if (kind == sfk_destructor)
1413         /* See comment in check_special_function_return_type.  */
1414         return_type = build_pointer_type (void_type_node);
1415       else
1416         return_type = build_pointer_type (type);
1417     }
1418   else
1419     return_type = void_type_node;
1420
1421   switch (kind)
1422     {
1423     case sfk_destructor:
1424       /* Destructor.  */
1425       name = constructor_name (type);
1426       break;
1427
1428     case sfk_constructor:
1429       /* Default constructor.  */
1430       name = constructor_name (type);
1431       break;
1432
1433     case sfk_copy_constructor:
1434     case sfk_copy_assignment:
1435     case sfk_move_constructor:
1436     case sfk_move_assignment:
1437     {
1438       bool move_p;
1439       if (kind == sfk_copy_assignment
1440           || kind == sfk_move_assignment)
1441         {
1442           return_type = build_reference_type (type);
1443           name = ansi_assopname (NOP_EXPR);
1444         }
1445       else
1446         name = constructor_name (type);
1447
1448       if (const_p)
1449         rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1450       else
1451         rhs_parm_type = type;
1452       move_p = (kind == sfk_move_assignment
1453                 || kind == sfk_move_constructor);
1454       rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1455
1456       parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1457       break;
1458     }
1459     default:
1460       gcc_unreachable ();
1461     }
1462
1463   synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1464                            &deleted_p, &constexpr_p, false);
1465   /* Don't bother marking a deleted constructor as constexpr.  */
1466   if (deleted_p)
1467     constexpr_p = false;
1468   /* A trivial copy/move constructor is also a constexpr constructor.  */
1469   else if (trivial_p && cxx_dialect >= cxx0x
1470            && (kind == sfk_copy_constructor
1471                || kind == sfk_move_constructor))
1472     gcc_assert (constexpr_p);
1473
1474   if (!trivial_p && type_has_trivial_fn (type, kind))
1475     type_set_nontrivial_flag (type, kind);
1476
1477   /* Create the function.  */
1478   fn_type = build_method_type_directly (type, return_type, parameter_types);
1479   if (raises)
1480     fn_type = build_exception_variant (fn_type, raises);
1481   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1482   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1483   if (kind == sfk_constructor || kind == sfk_copy_constructor
1484       || kind == sfk_move_constructor)
1485     DECL_CONSTRUCTOR_P (fn) = 1;
1486   else if (kind == sfk_destructor)
1487     DECL_DESTRUCTOR_P (fn) = 1;
1488   else
1489     {
1490       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1491       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1492     }
1493   
1494   /* If pointers to member functions use the least significant bit to
1495      indicate whether a function is virtual, ensure a pointer
1496      to this function will have that bit clear.  */
1497   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1498       && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1499     DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1500
1501   /* Create the explicit arguments.  */
1502   if (rhs_parm_type)
1503     {
1504       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1505          want its type to be included in the mangled function
1506          name.  */
1507       DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1508       TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1509     }
1510   /* Add the "this" parameter.  */
1511   this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1512   DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1513   DECL_ARGUMENTS (fn) = this_parm;
1514
1515   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1516   set_linkage_according_to_type (type, fn);
1517   rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1518   DECL_IN_AGGR_P (fn) = 1;
1519   DECL_ARTIFICIAL (fn) = 1;
1520   DECL_DEFAULTED_FN (fn) = 1;
1521   if (cxx_dialect >= cxx0x)
1522     {
1523       DECL_DELETED_FN (fn) = deleted_p;
1524       DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1525     }
1526   DECL_NOT_REALLY_EXTERN (fn) = 1;
1527   DECL_DECLARED_INLINE_P (fn) = 1;
1528   gcc_assert (!TREE_USED (fn));
1529
1530   /* Restore PROCESSING_TEMPLATE_DECL.  */
1531   processing_template_decl = saved_processing_template_decl;
1532
1533   return fn;
1534 }
1535
1536 /* Gives any errors about defaulted functions which need to be deferred
1537    until the containing class is complete.  */
1538
1539 void
1540 defaulted_late_check (tree fn)
1541 {
1542   /* Complain about invalid signature for defaulted fn.  */
1543   tree ctx = DECL_CONTEXT (fn);
1544   special_function_kind kind = special_function_p (fn);
1545   bool fn_const_p = (copy_fn_p (fn) == 2);
1546   tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p);
1547
1548   if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1549                     TREE_TYPE (TREE_TYPE (implicit_fn)))
1550       || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1551                      TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1552     {
1553       error ("defaulted declaration %q+D", fn);
1554       error_at (DECL_SOURCE_LOCATION (fn),
1555                 "does not match expected signature %qD", implicit_fn);
1556     }
1557
1558   /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1559      implicitly considered to have the same exception-specification as if
1560      it had been implicitly declared.  */
1561   if (DECL_DEFAULTED_IN_CLASS_P (fn))
1562     {
1563       tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1564       TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
1565       if (DECL_DECLARED_CONSTEXPR_P (implicit_fn))
1566         /* Hmm...should we do this for out-of-class too? Should it be OK to
1567            add constexpr later like inline, rather than requiring
1568            declarations to match?  */
1569         DECL_DECLARED_CONSTEXPR_P (fn) = true;
1570     }
1571
1572   if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
1573       && DECL_DECLARED_CONSTEXPR_P (fn))
1574     {
1575       if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
1576         error ("%qD cannot be declared as constexpr", fn);
1577       DECL_DECLARED_CONSTEXPR_P (fn) = false;
1578     }
1579
1580   if (DECL_DELETED_FN (implicit_fn))
1581     DECL_DELETED_FN (fn) = 1;
1582 }
1583
1584 /* Returns true iff FN can be explicitly defaulted, and gives any
1585    errors if defaulting FN is ill-formed.  */
1586
1587 bool
1588 defaultable_fn_check (tree fn)
1589 {
1590   special_function_kind kind = sfk_none;
1591
1592   if (DECL_CONSTRUCTOR_P (fn))
1593     {
1594       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
1595         kind = sfk_constructor;
1596       else if (copy_fn_p (fn) > 0
1597                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
1598                    == void_list_node))
1599         kind = sfk_copy_constructor;
1600       else if (move_fn_p (fn))
1601         kind = sfk_move_constructor;
1602     }
1603   else if (DECL_DESTRUCTOR_P (fn))
1604     kind = sfk_destructor;
1605   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1606            && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1607     {
1608       if (copy_fn_p (fn))
1609         kind = sfk_copy_assignment;
1610       else if (move_fn_p (fn))
1611         kind = sfk_move_assignment;
1612     }
1613
1614   if (kind == sfk_none)
1615     {
1616       error ("%qD cannot be defaulted", fn);
1617       return false;
1618     }
1619   else
1620     {
1621       tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
1622       for (; t && t != void_list_node; t = TREE_CHAIN (t))
1623         if (TREE_PURPOSE (t))
1624           {
1625             error ("defaulted function %q+D with default argument", fn);
1626             break;
1627           }
1628       if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
1629         {
1630           if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
1631             error ("function %q+D defaulted on its first declaration "
1632                    "must not have an exception-specification", fn);
1633           if (DECL_VIRTUAL_P (fn))
1634             error ("%qD declared virtual cannot be defaulted in the class "
1635                    "body", fn);
1636         }
1637       else if (!processing_template_decl)
1638         defaulted_late_check (fn);
1639
1640       return true;
1641     }
1642 }
1643
1644 /* Add an implicit declaration to TYPE for the kind of function
1645    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
1646    declaration.  */
1647
1648 tree
1649 lazily_declare_fn (special_function_kind sfk, tree type)
1650 {
1651   tree fn;
1652   /* Whether or not the argument has a const reference type.  */
1653   bool const_p = false;
1654
1655   switch (sfk)
1656     {
1657     case sfk_constructor:
1658       CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1659       break;
1660     case sfk_copy_constructor:
1661       const_p = TYPE_HAS_CONST_COPY_CTOR (type);
1662       CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1663       break;
1664     case sfk_move_constructor:
1665       CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
1666       break;
1667     case sfk_copy_assignment:
1668       const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
1669       CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
1670       break;
1671     case sfk_move_assignment:
1672       CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
1673       break;
1674     case sfk_destructor:
1675       CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1676       break;
1677     default:
1678       gcc_unreachable ();
1679     }
1680
1681   /* Declare the function.  */
1682   fn = implicitly_declare_fn (sfk, type, const_p);
1683
1684   /* For move variants, rather than declare them as deleted we just
1685      don't declare them at all.  */
1686   if (DECL_DELETED_FN (fn)
1687       && (sfk == sfk_move_constructor
1688           || sfk == sfk_move_assignment))
1689     return NULL_TREE;
1690
1691   /* A destructor may be virtual.  */
1692   if (sfk == sfk_destructor
1693       || sfk == sfk_move_assignment
1694       || sfk == sfk_copy_assignment)
1695     check_for_override (fn, type);
1696   /* Add it to CLASSTYPE_METHOD_VEC.  */
1697   add_method (type, fn, NULL_TREE);
1698   /* Add it to TYPE_METHODS.  */
1699   if (sfk == sfk_destructor
1700       && DECL_VIRTUAL_P (fn)
1701       && abi_version_at_least (2))
1702     /* The ABI requires that a virtual destructor go at the end of the
1703        vtable.  */
1704     TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1705   else
1706     {
1707       /* G++ 3.2 put the implicit destructor at the *beginning* of the
1708          TYPE_METHODS list, which cause the destructor to be emitted
1709          in an incorrect location in the vtable.  */
1710       if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn))
1711         warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1712                  "and may change in a future version of GCC due to "
1713                  "implicit virtual destructor",
1714                  type);
1715       DECL_CHAIN (fn) = TYPE_METHODS (type);
1716       TYPE_METHODS (type) = fn;
1717     }
1718   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1719   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
1720       || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
1721     /* Create appropriate clones.  */
1722     clone_function_decl (fn, /*update_method_vec=*/true);
1723
1724   return fn;
1725 }
1726
1727 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1728    as there are artificial parms in FN.  */
1729
1730 tree
1731 skip_artificial_parms_for (const_tree fn, tree list)
1732 {
1733   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1734     list = TREE_CHAIN (list);
1735   else
1736     return list;
1737
1738   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1739     list = TREE_CHAIN (list);
1740   if (DECL_HAS_VTT_PARM_P (fn))
1741     list = TREE_CHAIN (list);
1742   return list;
1743 }
1744
1745 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1746    artificial parms in FN.  */
1747
1748 int
1749 num_artificial_parms_for (const_tree fn)
1750 {
1751   int count = 0;
1752
1753   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1754     count++;
1755   else
1756     return 0;
1757
1758   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1759     count++;
1760   if (DECL_HAS_VTT_PARM_P (fn))
1761     count++;
1762   return count;
1763 }
1764
1765
1766 #include "gt-cp-method.h"