OSDN Git Service

PR c++/45822
[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   int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
587
588   compound_stmt = begin_compound_stmt (0);
589   parm = convert_from_reference (parm);
590
591   if (trivial
592       && is_empty_class (current_class_type))
593     /* Don't copy the padding byte; it might not have been allocated
594        if *this is a base subobject.  */;
595   else if (trivial)
596     {
597       tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
598       finish_expr_stmt (t);
599     }
600   else
601     {
602       tree fields;
603       int cvquals = cp_type_quals (TREE_TYPE (parm));
604       int i;
605       tree binfo, base_binfo;
606
607       /* Assign to each of the direct base classes.  */
608       for (binfo = TYPE_BINFO (current_class_type), i = 0;
609            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
610         {
611           tree converted_parm;
612           VEC(tree,gc) *parmvec;
613
614           /* We must convert PARM directly to the base class
615              explicitly since the base class may be ambiguous.  */
616           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
617           if (move_p)
618             converted_parm = move (converted_parm);
619           /* Call the base class assignment operator.  */
620           parmvec = make_tree_vector_single (converted_parm);
621           finish_expr_stmt
622             (build_special_member_call (current_class_ref,
623                                         ansi_assopname (NOP_EXPR),
624                                         &parmvec,
625                                         base_binfo,
626                                         flags,
627                                         tf_warning_or_error));
628           release_tree_vector (parmvec);
629         }
630
631       /* Assign to each of the non-static data members.  */
632       for (fields = TYPE_FIELDS (current_class_type);
633            fields;
634            fields = DECL_CHAIN (fields))
635         {
636           tree comp = current_class_ref;
637           tree init = parm;
638           tree field = fields;
639           tree expr_type;
640           int quals;
641
642           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
643             continue;
644
645           expr_type = TREE_TYPE (field);
646
647           if (CP_TYPE_CONST_P (expr_type))
648             {
649               error ("non-static const member %q#D, can%'t use default "
650                      "assignment operator", field);
651               continue;
652             }
653           else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
654             {
655               error ("non-static reference member %q#D, can%'t use "
656                      "default assignment operator", field);
657               continue;
658             }
659
660           if (DECL_NAME (field))
661             {
662               if (VFIELD_NAME_P (DECL_NAME (field)))
663                 continue;
664             }
665           else if (ANON_AGGR_TYPE_P (expr_type)
666                    && TYPE_FIELDS (expr_type) != NULL_TREE)
667             /* Just use the field; anonymous types can't have
668                nontrivial copy ctors or assignment ops or this
669                function would be deleted.  */;
670           else
671             continue;
672
673           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
674
675           /* Compute the type of init->field  */
676           quals = cvquals;
677           if (DECL_MUTABLE_P (field))
678             quals &= ~TYPE_QUAL_CONST;
679           expr_type = cp_build_qualified_type (expr_type, quals);
680
681           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
682           if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
683             init = move (init);
684
685           if (DECL_NAME (field))
686             init = cp_build_modify_expr (comp, NOP_EXPR, init, 
687                                          tf_warning_or_error);
688           else
689             init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
690           finish_expr_stmt (init);
691         }
692     }
693   finish_return_stmt (current_class_ref);
694   finish_compound_stmt (compound_stmt);
695 }
696
697 /* Synthesize FNDECL, a non-static member function.   */
698
699 void
700 synthesize_method (tree fndecl)
701 {
702   bool nested = (current_function_decl != NULL_TREE);
703   tree context = decl_function_context (fndecl);
704   bool need_body = true;
705   tree stmt;
706   location_t save_input_location = input_location;
707   int error_count = errorcount;
708   int warning_count = warningcount;
709
710   /* Reset the source location, we might have been previously
711      deferred, and thus have saved where we were first needed.  */
712   DECL_SOURCE_LOCATION (fndecl)
713     = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
714
715   /* If we've been asked to synthesize a clone, just synthesize the
716      cloned function instead.  Doing so will automatically fill in the
717      body for the clone.  */
718   if (DECL_CLONED_FUNCTION_P (fndecl))
719     fndecl = DECL_CLONED_FUNCTION (fndecl);
720
721   /* We may be in the middle of deferred access check.  Disable
722      it now.  */
723   push_deferring_access_checks (dk_no_deferred);
724
725   if (! context)
726     push_to_top_level ();
727   else if (nested)
728     push_function_context ();
729
730   input_location = DECL_SOURCE_LOCATION (fndecl);
731
732   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
733   stmt = begin_function_body ();
734
735   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
736     {
737       do_build_copy_assign (fndecl);
738       need_body = false;
739     }
740   else if (DECL_CONSTRUCTOR_P (fndecl))
741     {
742       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
743       if (arg_chain != void_list_node)
744         do_build_copy_constructor (fndecl);
745       else
746         finish_mem_initializers (NULL_TREE);
747     }
748
749   /* If we haven't yet generated the body of the function, just
750      generate an empty compound statement.  */
751   if (need_body)
752     {
753       tree compound_stmt;
754       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
755       finish_compound_stmt (compound_stmt);
756     }
757
758   finish_function_body (stmt);
759   expand_or_defer_fn (finish_function (0));
760
761   input_location = save_input_location;
762
763   if (! context)
764     pop_from_top_level ();
765   else if (nested)
766     pop_function_context ();
767
768   pop_deferring_access_checks ();
769
770   if (error_count != errorcount || warning_count != warningcount)
771     inform (input_location, "synthesized method %qD first required here ",
772             fndecl);
773 }
774
775 /* Build a reference to type TYPE with cv-quals QUALS, which is an
776    rvalue if RVALUE is true.  */
777
778 static tree
779 build_stub_type (tree type, int quals, bool rvalue)
780 {
781   tree argtype = cp_build_qualified_type (type, quals);
782   return cp_build_reference_type (argtype, rvalue);
783 }
784
785 /* Build a dummy glvalue from dereferencing a dummy reference of type
786    REFTYPE.  */
787
788 static tree
789 build_stub_object (tree reftype)
790 {
791   tree stub = build1 (NOP_EXPR, reftype, integer_one_node);
792   return convert_from_reference (stub);
793 }
794
795 /* Determine which function will be called when looking up NAME in TYPE,
796    called with a single ARGTYPE argument, or no argument if ARGTYPE is
797    null.  FLAGS and COMPLAIN are as for build_new_method_call.
798
799    Returns a FUNCTION_DECL if all is well.
800    Returns NULL_TREE if overload resolution failed.
801    Returns error_mark_node if the chosen function cannot be called.  */
802
803 static tree
804 locate_fn_flags (tree type, tree name, tree argtype, int flags,
805                  tsubst_flags_t complain)
806 {
807   tree ob, fn, fns, binfo, rval;
808   VEC(tree,gc) *args;
809
810   if (TYPE_P (type))
811     binfo = TYPE_BINFO (type);
812   else
813     {
814       binfo = type;
815       type = BINFO_TYPE (binfo);
816     }
817
818   ob = build_stub_object (cp_build_reference_type (type, false));
819   args = make_tree_vector ();
820   if (argtype)
821     {
822       tree arg = build_stub_object (argtype);
823       VEC_quick_push (tree, args, arg);
824     }
825
826   fns = lookup_fnfields (binfo, name, 0);
827   rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
828
829   release_tree_vector (args);
830   if (fn && rval == error_mark_node)
831     return rval;
832   else
833     return fn;
834 }
835
836 /* Locate the dtor of TYPE.  */
837
838 tree
839 get_dtor (tree type)
840 {
841   tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
842                              LOOKUP_NORMAL, tf_warning_or_error);
843   if (fn == error_mark_node)
844     return NULL_TREE;
845   return fn;
846 }
847
848 /* Locate the default ctor of TYPE.  */
849
850 tree
851 locate_ctor (tree type)
852 {
853   tree fn;
854
855   push_deferring_access_checks (dk_no_check);
856   fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
857                         LOOKUP_SPECULATIVE, tf_none);
858   pop_deferring_access_checks ();
859   if (fn == error_mark_node)
860     return NULL_TREE;
861   return fn;
862 }
863
864 /* Likewise, but give any appropriate errors.  */
865
866 tree
867 get_default_ctor (tree type)
868 {
869   tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
870                              LOOKUP_NORMAL, tf_warning_or_error);
871   if (fn == error_mark_node)
872     return NULL_TREE;
873   return fn;
874 }
875
876 /* Locate the copy ctor of TYPE.  */
877
878 tree
879 get_copy_ctor (tree type)
880 {
881   int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
882                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
883   tree argtype = build_stub_type (type, quals, false);
884   tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
885                              LOOKUP_NORMAL, tf_warning_or_error);
886   if (fn == error_mark_node)
887     return NULL_TREE;
888   return fn;
889 }
890
891 /* Locate the copy assignment operator of TYPE.  */
892
893 tree
894 get_copy_assign (tree type)
895 {
896   int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
897                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
898   tree argtype = build_stub_type (type, quals, false);
899   tree fn = locate_fn_flags (type, ansi_assopname (NOP_EXPR), argtype,
900                              LOOKUP_NORMAL, tf_warning_or_error);
901   if (fn == error_mark_node)
902     return NULL_TREE;
903   return fn;
904 }
905
906 /* Subroutine of synthesized_method_walk.  Update SPEC_P, TRIVIAL_P and
907    DELETED_P or give an error message MSG with argument ARG.  */
908
909 static void
910 process_subob_fn (tree fn, bool move_p, tree *spec_p, bool *trivial_p,
911                   bool *deleted_p, bool *constexpr_p,
912                   const char *msg, tree arg)
913 {
914   if (!fn || fn == error_mark_node)
915     goto bad;
916
917   if (spec_p)
918     {
919       tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
920       *spec_p = merge_exception_specifiers (*spec_p, raises);
921     }
922
923   if (!trivial_fn_p (fn))
924     {
925       if (trivial_p)
926         *trivial_p = false;
927       if (TREE_CODE (arg) == FIELD_DECL
928           && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
929         {
930           if (deleted_p)
931             *deleted_p = true;
932           if (msg)
933             error ("union member %q+D with non-trivial %qD", arg, fn);
934         }
935     }
936
937   if (move_p && !move_fn_p (fn) && !trivial_fn_p (fn))
938     {
939       if (msg)
940         error (msg, arg);
941       goto bad;
942     }
943
944   if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
945     *constexpr_p = false;
946
947   return;
948
949  bad:
950   if (deleted_p)
951     *deleted_p = true;
952 }
953
954 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
955    aggregates.  */
956
957 static void
958 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
959                    int quals, bool copy_arg_p, bool move_p,
960                    bool assign_p, tree *spec_p, bool *trivial_p,
961                    bool *deleted_p, bool *constexpr_p, const char *msg,
962                    int flags, tsubst_flags_t complain)
963 {
964   tree field;
965   for (field = fields; field; field = DECL_CHAIN (field))
966     {
967       tree mem_type, argtype, rval;
968
969       if (TREE_CODE (field) != FIELD_DECL
970           || DECL_ARTIFICIAL (field))
971         continue;
972
973       mem_type = strip_array_types (TREE_TYPE (field));
974       if (assign_p)
975         {
976           bool bad = true;
977           if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
978             {
979               if (msg)
980                 error ("non-static const member %q#D, can%'t use default "
981                        "assignment operator", field);
982             }
983           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
984             {
985               if (msg)
986                 error ("non-static reference member %q#D, can%'t use "
987                        "default assignment operator", field);
988             }
989           else
990             bad = false;
991
992           if (bad && deleted_p)
993             *deleted_p = true;
994         }
995       else if (sfk == sfk_constructor)
996         {
997           bool bad = true;
998           if (CP_TYPE_CONST_P (mem_type)
999               && (!CLASS_TYPE_P (mem_type)
1000                   || !type_has_user_provided_default_constructor (mem_type)))
1001             {
1002               if (msg)
1003                 error ("uninitialized non-static const member %q#D",
1004                        field);
1005             }
1006           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1007             {
1008               if (msg)
1009                 error ("uninitialized non-static reference member %q#D",
1010                        field);
1011             }
1012           else
1013             bad = false;
1014
1015           if (bad && deleted_p)
1016             *deleted_p = true;
1017
1018           /* For an implicitly-defined default constructor to be constexpr,
1019              every member must have a user-provided default constructor.  */
1020           /* FIXME will need adjustment for non-static data member
1021              initializers.  */
1022           if (constexpr_p && !CLASS_TYPE_P (mem_type))
1023             *constexpr_p = false;
1024         }
1025
1026       if (!CLASS_TYPE_P (mem_type))
1027         continue;
1028
1029       if (ANON_AGGR_TYPE_P (mem_type))
1030         {
1031           walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1032                              copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1033                              deleted_p, constexpr_p, msg, flags, complain);
1034           continue;
1035         }
1036
1037       if (copy_arg_p)
1038         {
1039           int mem_quals = cp_type_quals (mem_type) | quals;
1040           if (DECL_MUTABLE_P (field))
1041             mem_quals &= ~TYPE_QUAL_CONST;
1042           argtype = build_stub_type (mem_type, mem_quals, move_p);
1043         }
1044       else
1045         argtype = NULL_TREE;
1046
1047       rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1048
1049       process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1050                         constexpr_p, msg, field);
1051     }
1052 }
1053
1054 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1055    which is const if relevant and CONST_P is set.  If spec_p, trivial_p and
1056    deleted_p are non-null, set their referent appropriately.  If diag is
1057    true, we're being called from maybe_explain_implicit_delete to give
1058    errors.  */
1059
1060 static void
1061 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1062                          tree *spec_p, bool *trivial_p, bool *deleted_p,
1063                          bool *constexpr_p, bool diag)
1064 {
1065   tree binfo, base_binfo, scope, fnname, rval, argtype;
1066   bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1067   VEC(tree,gc) *vbases;
1068   int i, quals, flags;
1069   tsubst_flags_t complain;
1070   const char *msg;
1071   bool ctor_p;
1072   tree cleanup_spec;
1073   bool cleanup_trivial = true;
1074   bool cleanup_deleted = false;
1075
1076   cleanup_spec
1077     = (cxx_dialect >= cxx0x ? noexcept_true_spec : empty_except_spec);
1078   if (spec_p)
1079     *spec_p = cleanup_spec;
1080
1081   if (deleted_p)
1082     {
1083       /* "The closure type associated with a lambda-expression has a deleted
1084          default constructor and a deleted copy assignment operator."
1085          This is diagnosed in maybe_explain_implicit_delete.  */
1086       if (LAMBDA_TYPE_P (ctype)
1087           && (sfk == sfk_constructor
1088               || sfk == sfk_copy_assignment))
1089         {
1090           *deleted_p = true;
1091           return;
1092         }
1093
1094       *deleted_p = false;
1095     }
1096
1097   ctor_p = false;
1098   assign_p = false;
1099   check_vdtor = false;
1100   switch (sfk)
1101     {
1102     case sfk_move_assignment:
1103     case sfk_copy_assignment:
1104       assign_p = true;
1105       fnname = ansi_assopname (NOP_EXPR);
1106       break;
1107
1108     case sfk_destructor:
1109       check_vdtor = true;
1110       /* The synthesized method will call base dtors, but check complete
1111          here to avoid having to deal with VTT.  */
1112       fnname = complete_dtor_identifier;
1113       break;
1114
1115     case sfk_constructor:
1116     case sfk_move_constructor:
1117     case sfk_copy_constructor:
1118       ctor_p = true;
1119       fnname = complete_ctor_identifier;
1120       break;
1121
1122     default:
1123       gcc_unreachable ();
1124     }
1125
1126   /* If that user-written default constructor would satisfy the
1127      requirements of a constexpr constructor (7.1.5), the
1128      implicitly-defined default constructor is constexpr.  */
1129   if (constexpr_p)
1130     *constexpr_p = ctor_p;
1131
1132   move_p = false;
1133   switch (sfk)
1134     {
1135     case sfk_constructor:
1136     case sfk_destructor:
1137       copy_arg_p = false;
1138       break;
1139
1140     case sfk_move_constructor:
1141     case sfk_move_assignment:
1142       move_p = true;
1143     case sfk_copy_constructor:
1144     case sfk_copy_assignment:
1145       copy_arg_p = true;
1146       break;
1147
1148     default:
1149       gcc_unreachable ();
1150     }
1151
1152   expected_trivial = type_has_trivial_fn (ctype, sfk);
1153   if (trivial_p)
1154     *trivial_p = expected_trivial;
1155
1156 #ifndef ENABLE_CHECKING
1157   /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1158      class versions and other properties of the type.  But a subobject
1159      class can be trivially copyable and yet have overload resolution
1160      choose a template constructor for initialization, depending on
1161      rvalueness and cv-quals.  So we can't exit early for copy/move
1162      methods in C++0x.  */
1163   if (expected_trivial
1164       && (!copy_arg_p || cxx_dialect < cxx0x))
1165     {
1166       if (constexpr_p && sfk == sfk_constructor)
1167         *constexpr_p = synthesized_default_constructor_is_constexpr (ctype);
1168       return;
1169     }
1170 #endif
1171
1172   ++cp_unevaluated_operand;
1173   ++c_inhibit_evaluation_warnings;
1174
1175   scope = push_scope (ctype);
1176
1177   if (diag)
1178     {
1179       flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1180       complain = tf_warning_or_error;
1181     }
1182   else
1183     {
1184       flags = LOOKUP_PROTECT|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1185       complain = tf_none;
1186     }
1187
1188   if (const_p)
1189     quals = TYPE_QUAL_CONST;
1190   else
1191     quals = TYPE_UNQUALIFIED;
1192   argtype = NULL_TREE;
1193
1194   if (!diag)
1195     msg = NULL;
1196   else if (assign_p)
1197     msg = ("base %qT does not have a move assignment operator or trivial "
1198            "copy assignment operator");
1199   else
1200     msg = ("base %qT does not have a move constructor or trivial "
1201            "copy constructor");
1202
1203   for (binfo = TYPE_BINFO (ctype), i = 0;
1204        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1205     {
1206       tree basetype = BINFO_TYPE (base_binfo);
1207       if (copy_arg_p)
1208         argtype = build_stub_type (basetype, quals, move_p);
1209       rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1210
1211       process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1212                         constexpr_p, msg, basetype);
1213       if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1214         {
1215           /* In a constructor we also need to check the subobject
1216              destructors for cleanup of partially constructed objects.  */
1217           rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1218                                   NULL_TREE, flags, complain);
1219           process_subob_fn (rval, false, &cleanup_spec, &cleanup_trivial,
1220                             &cleanup_deleted, NULL, NULL,
1221                             basetype);
1222         }
1223
1224       if (check_vdtor && type_has_virtual_destructor (basetype))
1225         {
1226           rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1227                                   ptr_type_node, flags, complain);
1228           /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1229              to have a null rval (no class-specific op delete).  */
1230           if (rval && rval == error_mark_node && deleted_p)
1231             *deleted_p = true;
1232           check_vdtor = false;
1233         }
1234     }
1235
1236   vbases = CLASSTYPE_VBASECLASSES (ctype);
1237   if (vbases && assign_p && move_p)
1238     {
1239       /* Should the spec be changed to allow vbases that only occur once?  */
1240       if (diag)
1241         error ("%qT has virtual bases, default move assignment operator "
1242                "cannot be generated", ctype);
1243       else if (deleted_p)
1244         *deleted_p = true;
1245     }
1246   else if (!assign_p)
1247     {
1248       if (diag)
1249         msg = ("virtual base %qT does not have a move constructor "
1250                "or trivial copy constructor");
1251       if (vbases && constexpr_p)
1252         *constexpr_p = false;
1253       FOR_EACH_VEC_ELT (tree, vbases, i, base_binfo)
1254         {
1255           tree basetype = BINFO_TYPE (base_binfo);
1256           if (copy_arg_p)
1257             argtype = build_stub_type (basetype, quals, move_p);
1258           rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1259
1260           process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1261                             constexpr_p, msg, basetype);
1262           if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1263             {
1264               rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1265                                       NULL_TREE, flags, complain);
1266               process_subob_fn (rval, false, &cleanup_spec, &cleanup_trivial,
1267                                 &cleanup_deleted, NULL, NULL,
1268                                 basetype);
1269             }
1270         }
1271     }
1272   if (!diag)
1273     /* Leave msg null. */;
1274   else if (assign_p)
1275     msg = ("non-static data member %qD does not have a move "
1276            "assignment operator or trivial copy assignment operator");
1277   else
1278     msg = ("non-static data member %qD does not have a move "
1279            "constructor or trivial copy constructor");
1280   walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1281                      copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1282                      deleted_p, constexpr_p, msg, flags, complain);
1283   if (ctor_p)
1284     walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1285                        sfk_destructor, TYPE_UNQUALIFIED, false,
1286                        false, false, &cleanup_spec, &cleanup_trivial,
1287                        &cleanup_deleted, NULL,
1288                        NULL, flags, complain);
1289
1290   pop_scope (scope);
1291
1292   --cp_unevaluated_operand;
1293   --c_inhibit_evaluation_warnings;
1294
1295   /* If the constructor isn't trivial, consider the subobject cleanups.  */
1296   if (ctor_p && trivial_p && !*trivial_p)
1297     {
1298       if (deleted_p && cleanup_deleted)
1299         *deleted_p = true;
1300       if (spec_p)
1301         *spec_p = merge_exception_specifiers (*spec_p, cleanup_spec);
1302     }
1303
1304 #ifdef ENABLE_CHECKING
1305   /* If we expected this to be trivial but it isn't, then either we're in
1306      C++0x mode and this is a copy/move ctor/op= or there's an error.  */
1307   gcc_assert (!(trivial_p && expected_trivial && !*trivial_p)
1308               || (copy_arg_p && cxx_dialect >= cxx0x)
1309               || errorcount);
1310 #endif
1311 }
1312
1313 /* DECL is a deleted function.  If it's implicitly deleted, explain why and
1314    return true; else return false.  */
1315
1316 bool
1317 maybe_explain_implicit_delete (tree decl)
1318 {
1319   /* If decl is a clone, get the primary variant.  */
1320   decl = DECL_ORIGIN (decl);
1321   gcc_assert (DECL_DELETED_FN (decl));
1322   if (DECL_DEFAULTED_FN (decl))
1323     {
1324       /* Not marked GTY; it doesn't need to be GC'd or written to PCH.  */
1325       static htab_t explained_htab;
1326       void **slot;
1327
1328       special_function_kind sfk;
1329       location_t loc;
1330       bool informed;
1331       tree ctype;
1332
1333       if (!explained_htab)
1334         explained_htab = htab_create (37, htab_hash_pointer,
1335                                       htab_eq_pointer, NULL);
1336       slot = htab_find_slot (explained_htab, decl, INSERT);
1337       if (*slot)
1338         return true;
1339       *slot = decl;
1340
1341       sfk = special_function_p (decl);
1342       ctype = DECL_CONTEXT (decl);
1343       loc = input_location;
1344       input_location = DECL_SOURCE_LOCATION (decl);
1345
1346       informed = false;
1347       if (LAMBDA_TYPE_P (ctype))
1348         {
1349           informed = true;
1350           if (sfk == sfk_constructor)
1351             error ("a lambda closure type has a deleted default constructor");
1352           else if (sfk == sfk_copy_assignment)
1353             error ("a lambda closure type has a deleted copy assignment operator");
1354           else
1355             informed = false;
1356         }
1357       if (!informed)
1358         {
1359           tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1360           bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1361           tree scope = push_scope (ctype);
1362           error ("%qD is implicitly deleted because the default "
1363                  "definition would be ill-formed:", decl);
1364           pop_scope (scope);
1365           synthesized_method_walk (ctype, sfk, const_p,
1366                                    NULL, NULL, NULL, NULL, true);
1367         }
1368
1369       input_location = loc;
1370       return true;
1371     }
1372   return false;
1373 }
1374
1375 /* Implicitly declare the special function indicated by KIND, as a
1376    member of TYPE.  For copy constructors and assignment operators,
1377    CONST_P indicates whether these functions should take a const
1378    reference argument or a non-const reference.  Returns the
1379    FUNCTION_DECL for the implicitly declared function.  */
1380
1381 static tree
1382 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
1383 {
1384   tree fn;
1385   tree parameter_types = void_list_node;
1386   tree return_type;
1387   tree fn_type;
1388   tree raises = empty_except_spec;
1389   tree rhs_parm_type = NULL_TREE;
1390   tree this_parm;
1391   tree name;
1392   HOST_WIDE_INT saved_processing_template_decl;
1393   bool deleted_p;
1394   bool trivial_p;
1395   bool constexpr_p;
1396
1397   /* Because we create declarations for implicitly declared functions
1398      lazily, we may be creating the declaration for a member of TYPE
1399      while in some completely different context.  However, TYPE will
1400      never be a dependent class (because we never want to do lookups
1401      for implicitly defined functions in a dependent class).
1402      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1403      because we only create clones for constructors and destructors
1404      when not in a template.  */
1405   gcc_assert (!dependent_type_p (type));
1406   saved_processing_template_decl = processing_template_decl;
1407   processing_template_decl = 0;
1408
1409   type = TYPE_MAIN_VARIANT (type);
1410
1411   if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1412     {
1413       if (kind == sfk_destructor)
1414         /* See comment in check_special_function_return_type.  */
1415         return_type = build_pointer_type (void_type_node);
1416       else
1417         return_type = build_pointer_type (type);
1418     }
1419   else
1420     return_type = void_type_node;
1421
1422   switch (kind)
1423     {
1424     case sfk_destructor:
1425       /* Destructor.  */
1426       name = constructor_name (type);
1427       break;
1428
1429     case sfk_constructor:
1430       /* Default constructor.  */
1431       name = constructor_name (type);
1432       break;
1433
1434     case sfk_copy_constructor:
1435     case sfk_copy_assignment:
1436     case sfk_move_constructor:
1437     case sfk_move_assignment:
1438     {
1439       bool move_p;
1440       if (kind == sfk_copy_assignment
1441           || kind == sfk_move_assignment)
1442         {
1443           return_type = build_reference_type (type);
1444           name = ansi_assopname (NOP_EXPR);
1445         }
1446       else
1447         name = constructor_name (type);
1448
1449       if (const_p)
1450         rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1451       else
1452         rhs_parm_type = type;
1453       move_p = (kind == sfk_move_assignment
1454                 || kind == sfk_move_constructor);
1455       rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1456
1457       parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1458       break;
1459     }
1460     default:
1461       gcc_unreachable ();
1462     }
1463
1464   synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1465                            &deleted_p, &constexpr_p, false);
1466   /* Don't bother marking a deleted constructor as constexpr.  */
1467   if (deleted_p)
1468     constexpr_p = false;
1469   /* A trivial copy/move constructor is also a constexpr constructor.  */
1470   else if (trivial_p && cxx_dialect >= cxx0x
1471            && (kind == sfk_copy_constructor
1472                || kind == sfk_move_constructor))
1473     gcc_assert (constexpr_p);
1474
1475   if (!trivial_p && type_has_trivial_fn (type, kind))
1476     type_set_nontrivial_flag (type, kind);
1477
1478   /* Create the function.  */
1479   fn_type = build_method_type_directly (type, return_type, parameter_types);
1480   if (raises)
1481     fn_type = build_exception_variant (fn_type, raises);
1482   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1483   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1484   if (kind == sfk_constructor || kind == sfk_copy_constructor
1485       || kind == sfk_move_constructor)
1486     DECL_CONSTRUCTOR_P (fn) = 1;
1487   else if (kind == sfk_destructor)
1488     DECL_DESTRUCTOR_P (fn) = 1;
1489   else
1490     {
1491       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1492       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1493     }
1494   
1495   /* If pointers to member functions use the least significant bit to
1496      indicate whether a function is virtual, ensure a pointer
1497      to this function will have that bit clear.  */
1498   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1499       && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1500     DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1501
1502   /* Create the explicit arguments.  */
1503   if (rhs_parm_type)
1504     {
1505       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1506          want its type to be included in the mangled function
1507          name.  */
1508       DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1509       TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1510     }
1511   /* Add the "this" parameter.  */
1512   this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1513   DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1514   DECL_ARGUMENTS (fn) = this_parm;
1515
1516   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1517   set_linkage_according_to_type (type, fn);
1518   rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1519   DECL_IN_AGGR_P (fn) = 1;
1520   DECL_ARTIFICIAL (fn) = 1;
1521   DECL_DEFAULTED_FN (fn) = 1;
1522   if (cxx_dialect >= cxx0x)
1523     {
1524       DECL_DELETED_FN (fn) = deleted_p;
1525       DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1526     }
1527   DECL_NOT_REALLY_EXTERN (fn) = 1;
1528   DECL_DECLARED_INLINE_P (fn) = 1;
1529   gcc_assert (!TREE_USED (fn));
1530
1531   /* Restore PROCESSING_TEMPLATE_DECL.  */
1532   processing_template_decl = saved_processing_template_decl;
1533
1534   return fn;
1535 }
1536
1537 /* Gives any errors about defaulted functions which need to be deferred
1538    until the containing class is complete.  */
1539
1540 void
1541 defaulted_late_check (tree fn)
1542 {
1543   /* Complain about invalid signature for defaulted fn.  */
1544   tree ctx = DECL_CONTEXT (fn);
1545   special_function_kind kind = special_function_p (fn);
1546   bool fn_const_p = (copy_fn_p (fn) == 2);
1547   tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p);
1548
1549   if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1550                     TREE_TYPE (TREE_TYPE (implicit_fn)))
1551       || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1552                      TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1553     {
1554       error ("defaulted declaration %q+D", fn);
1555       error_at (DECL_SOURCE_LOCATION (fn),
1556                 "does not match expected signature %qD", implicit_fn);
1557     }
1558
1559   /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1560      implicitly considered to have the same exception-specification as if
1561      it had been implicitly declared.  */
1562   if (DECL_DEFAULTED_IN_CLASS_P (fn))
1563     {
1564       tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1565       TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
1566       if (DECL_DECLARED_CONSTEXPR_P (implicit_fn))
1567         /* Hmm...should we do this for out-of-class too? Should it be OK to
1568            add constexpr later like inline, rather than requiring
1569            declarations to match?  */
1570         DECL_DECLARED_CONSTEXPR_P (fn) = true;
1571     }
1572
1573   if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
1574       && DECL_DECLARED_CONSTEXPR_P (fn))
1575     {
1576       if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
1577         error ("%qD cannot be declared as constexpr", fn);
1578       DECL_DECLARED_CONSTEXPR_P (fn) = false;
1579     }
1580
1581   if (DECL_DELETED_FN (implicit_fn))
1582     DECL_DELETED_FN (fn) = 1;
1583 }
1584
1585 /* Returns true iff FN can be explicitly defaulted, and gives any
1586    errors if defaulting FN is ill-formed.  */
1587
1588 bool
1589 defaultable_fn_check (tree fn)
1590 {
1591   special_function_kind kind = sfk_none;
1592
1593   if (DECL_CONSTRUCTOR_P (fn))
1594     {
1595       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
1596         kind = sfk_constructor;
1597       else if (copy_fn_p (fn) > 0
1598                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
1599                    == void_list_node))
1600         kind = sfk_copy_constructor;
1601       else if (move_fn_p (fn))
1602         kind = sfk_move_constructor;
1603     }
1604   else if (DECL_DESTRUCTOR_P (fn))
1605     kind = sfk_destructor;
1606   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1607            && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1608     {
1609       if (copy_fn_p (fn))
1610         kind = sfk_copy_assignment;
1611       else if (move_fn_p (fn))
1612         kind = sfk_move_assignment;
1613     }
1614
1615   if (kind == sfk_none)
1616     {
1617       error ("%qD cannot be defaulted", fn);
1618       return false;
1619     }
1620   else
1621     {
1622       tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
1623       for (; t && t != void_list_node; t = TREE_CHAIN (t))
1624         if (TREE_PURPOSE (t))
1625           {
1626             error ("defaulted function %q+D with default argument", fn);
1627             break;
1628           }
1629       if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
1630         {
1631           if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
1632             error ("function %q+D defaulted on its first declaration "
1633                    "must not have an exception-specification", fn);
1634           if (DECL_VIRTUAL_P (fn))
1635             error ("%qD declared virtual cannot be defaulted in the class "
1636                    "body", fn);
1637         }
1638       else if (!processing_template_decl)
1639         defaulted_late_check (fn);
1640
1641       return true;
1642     }
1643 }
1644
1645 /* Add an implicit declaration to TYPE for the kind of function
1646    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
1647    declaration.  */
1648
1649 tree
1650 lazily_declare_fn (special_function_kind sfk, tree type)
1651 {
1652   tree fn;
1653   /* Whether or not the argument has a const reference type.  */
1654   bool const_p = false;
1655
1656   switch (sfk)
1657     {
1658     case sfk_constructor:
1659       CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1660       break;
1661     case sfk_copy_constructor:
1662       const_p = TYPE_HAS_CONST_COPY_CTOR (type);
1663       CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1664       break;
1665     case sfk_move_constructor:
1666       CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
1667       break;
1668     case sfk_copy_assignment:
1669       const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
1670       CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
1671       break;
1672     case sfk_move_assignment:
1673       CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
1674       break;
1675     case sfk_destructor:
1676       CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1677       break;
1678     default:
1679       gcc_unreachable ();
1680     }
1681
1682   /* Declare the function.  */
1683   fn = implicitly_declare_fn (sfk, type, const_p);
1684
1685   /* For move variants, rather than declare them as deleted we just
1686      don't declare them at all.  */
1687   if (DECL_DELETED_FN (fn)
1688       && (sfk == sfk_move_constructor
1689           || sfk == sfk_move_assignment))
1690     return NULL_TREE;
1691
1692   /* A destructor may be virtual.  */
1693   if (sfk == sfk_destructor
1694       || sfk == sfk_move_assignment
1695       || sfk == sfk_copy_assignment)
1696     check_for_override (fn, type);
1697   /* Add it to CLASSTYPE_METHOD_VEC.  */
1698   add_method (type, fn, NULL_TREE);
1699   /* Add it to TYPE_METHODS.  */
1700   if (sfk == sfk_destructor
1701       && DECL_VIRTUAL_P (fn)
1702       && abi_version_at_least (2))
1703     /* The ABI requires that a virtual destructor go at the end of the
1704        vtable.  */
1705     TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1706   else
1707     {
1708       /* G++ 3.2 put the implicit destructor at the *beginning* of the
1709          TYPE_METHODS list, which cause the destructor to be emitted
1710          in an incorrect location in the vtable.  */
1711       if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn))
1712         warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1713                  "and may change in a future version of GCC due to "
1714                  "implicit virtual destructor",
1715                  type);
1716       DECL_CHAIN (fn) = TYPE_METHODS (type);
1717       TYPE_METHODS (type) = fn;
1718     }
1719   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1720   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
1721       || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
1722     /* Create appropriate clones.  */
1723     clone_function_decl (fn, /*update_method_vec=*/true);
1724
1725   return fn;
1726 }
1727
1728 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1729    as there are artificial parms in FN.  */
1730
1731 tree
1732 skip_artificial_parms_for (const_tree fn, tree list)
1733 {
1734   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1735     list = TREE_CHAIN (list);
1736   else
1737     return list;
1738
1739   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1740     list = TREE_CHAIN (list);
1741   if (DECL_HAS_VTT_PARM_P (fn))
1742     list = TREE_CHAIN (list);
1743   return list;
1744 }
1745
1746 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1747    artificial parms in FN.  */
1748
1749 int
1750 num_artificial_parms_for (const_tree fn)
1751 {
1752   int count = 0;
1753
1754   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1755     count++;
1756   else
1757     return 0;
1758
1759   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1760     count++;
1761   if (DECL_HAS_VTT_PARM_P (fn))
1762     count++;
1763   return count;
1764 }
1765
1766
1767 #include "gt-cp-method.h"