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