1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
27
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
30
31 #include "config.h"
32 #include "system.h"
33 #include "coretypes.h"
34 #include "tm.h"
35 #include "tree.h"
36 #include "rtl.h"
37 #include "expr.h"
38 #include "flags.h"
39 #include "cp-tree.h"
40 #include "decl.h"
41 #include "lex.h"
42 #include "output.h"
43 #include "except.h"
44 #include "toplev.h"
45 #include "timevar.h"
46 #include "cpplib.h"
47 #include "target.h"
48 #include "c-common.h"
49 #include "cgraph.h"
50 #include "tree-inline.h"
51 extern cpp_reader *parse_in;
52
53 /* This structure contains information about the initializations
54 and/or destructions required for a particular priority level. */
55 typedef struct priority_info_s {
56 /* Nonzero if there have been any initializations at this priority
57 throughout the translation unit. */
58 int initializations_p;
59 /* Nonzero if there have been any destructions at this priority
60 throughout the translation unit. */
61 int destructions_p;
62 } *priority_info;
63
64 static void mark_vtable_entries (tree);
65 static void grok_function_init (tree, tree);
66 static bool maybe_emit_vtables (tree);
67 static tree build_anon_union_vars (tree);
68 static bool acceptable_java_type (tree);
69 static tree start_objects (int, int);
70 static void finish_objects (int, int, tree);
71 static tree start_static_storage_duration_function (unsigned);
72 static void finish_static_storage_duration_function (tree);
73 static priority_info get_priority_info (int);
74 static void do_static_initialization (tree, tree);
75 static void do_static_destruction (tree);
76 static tree start_static_initialization_or_destruction (tree, int);
77 static void finish_static_initialization_or_destruction (tree);
78 static void generate_ctor_or_dtor_function (bool, int, location_t *);
79 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
80 void *);
81 static tree prune_vars_needing_no_initialization (tree *);
82 static void write_out_vars (tree);
83 static void import_export_class (tree);
84 static tree get_guard_bits (tree);
85
86 /* A list of static class variables. This is needed, because a
87 static class variable can be declared inside the class without
88 an initializer, and then initialized, statically, outside the class. */
89 static GTY(()) varray_type pending_statics;
90 #define pending_statics_used \
91 (pending_statics ? pending_statics->elements_used : 0)
92
93 /* A list of functions which were declared inline, but which we
94 may need to emit outline anyway. */
95 static GTY(()) varray_type deferred_fns;
96 #define deferred_fns_used \
97 (deferred_fns ? deferred_fns->elements_used : 0)
98
99 /* Flag used when debugging spew.c */
100
101 extern int spew_debug;
102
103 /* Nonzero if we're done parsing and into end-of-file activities. */
104
105 int at_eof;
106
107 /* Functions called along with real static constructors and destructors. */
108
109 tree static_ctors;
110 tree static_dtors;
111
112
113 /* Incorporate `const' and `volatile' qualifiers for member functions.
114 FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
115 QUALS is a list of qualifiers. Returns any explicit
116 top-level qualifiers of the method's this pointer, anything other than
117 TYPE_UNQUALIFIED will be an extension. */
118
119 int
grok_method_quals(tree ctype,tree function,tree quals)120 grok_method_quals (tree ctype, tree function, tree quals)
121 {
122 tree fntype = TREE_TYPE (function);
123 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
124 int type_quals = TYPE_UNQUALIFIED;
125 int dup_quals = TYPE_UNQUALIFIED;
126 int this_quals = TYPE_UNQUALIFIED;
127
128 do
129 {
130 int tq = cp_type_qual_from_rid (TREE_VALUE (quals));
131
132 if ((type_quals | this_quals) & tq)
133 dup_quals |= tq;
134 else if (tq & TYPE_QUAL_RESTRICT)
135 this_quals |= tq;
136 else
137 type_quals |= tq;
138 quals = TREE_CHAIN (quals);
139 }
140 while (quals);
141
142 if (dup_quals != TYPE_UNQUALIFIED)
143 error ("duplicate type qualifiers in %s declaration",
144 TREE_CODE (function) == FUNCTION_DECL
145 ? "member function" : "type");
146
147 ctype = cp_build_qualified_type (ctype, type_quals);
148 fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),
149 (TREE_CODE (fntype) == METHOD_TYPE
150 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
151 : TYPE_ARG_TYPES (fntype)));
152 if (raises)
153 fntype = build_exception_variant (fntype, raises);
154
155 TREE_TYPE (function) = fntype;
156 return this_quals;
157 }
158
159 /* A subroutine of the parser, to handle a component list. */
160
161 void
grok_x_components(tree specs)162 grok_x_components (tree specs)
163 {
164 tree t;
165
166 specs = strip_attrs (specs);
167
168 check_tag_decl (specs);
169 t = groktypename (build_tree_list (specs, NULL_TREE));
170
171 /* The only case where we need to do anything additional here is an
172 anonymous union field, e.g.: `struct S { union { int i; }; };'. */
173 if (t == NULL_TREE || !ANON_AGGR_TYPE_P (t))
174 return;
175
176 fixup_anonymous_aggr (t);
177 finish_member_declaration (build_decl (FIELD_DECL, NULL_TREE, t));
178 }
179
180 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
181 appropriately. */
182
183 tree
cp_build_parm_decl(tree name,tree type)184 cp_build_parm_decl (tree name, tree type)
185 {
186 tree parm = build_decl (PARM_DECL, name, type);
187 /* DECL_ARG_TYPE is only used by the back end and the back end never
188 sees templates. */
189 if (!processing_template_decl)
190 DECL_ARG_TYPE (parm) = type_passed_as (type);
191 return parm;
192 }
193
194 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
195 indicated NAME. */
196
197 tree
build_artificial_parm(tree name,tree type)198 build_artificial_parm (tree name, tree type)
199 {
200 tree parm = cp_build_parm_decl (name, type);
201 DECL_ARTIFICIAL (parm) = 1;
202 /* All our artificial parms are implicitly `const'; they cannot be
203 assigned to. */
204 TREE_READONLY (parm) = 1;
205 return parm;
206 }
207
208 /* Constructors for types with virtual baseclasses need an "in-charge" flag
209 saying whether this constructor is responsible for initialization of
210 virtual baseclasses or not. All destructors also need this "in-charge"
211 flag, which additionally determines whether or not the destructor should
212 free the memory for the object.
213
214 This function adds the "in-charge" flag to member function FN if
215 appropriate. It is called from grokclassfn and tsubst.
216 FN must be either a constructor or destructor.
217
218 The in-charge flag follows the 'this' parameter, and is followed by the
219 VTT parm (if any), then the user-written parms. */
220
221 void
maybe_retrofit_in_chrg(tree fn)222 maybe_retrofit_in_chrg (tree fn)
223 {
224 tree basetype, arg_types, parms, parm, fntype;
225
226 /* If we've already add the in-charge parameter don't do it again. */
227 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
228 return;
229
230 /* When processing templates we can't know, in general, whether or
231 not we're going to have virtual baseclasses. */
232 if (processing_template_decl)
233 return;
234
235 /* We don't need an in-charge parameter for constructors that don't
236 have virtual bases. */
237 if (DECL_CONSTRUCTOR_P (fn)
238 && !TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
239 return;
240
241 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
242 basetype = TREE_TYPE (TREE_VALUE (arg_types));
243 arg_types = TREE_CHAIN (arg_types);
244
245 parms = TREE_CHAIN (DECL_ARGUMENTS (fn));
246
247 /* If this is a subobject constructor or destructor, our caller will
248 pass us a pointer to our VTT. */
249 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
250 {
251 parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
252
253 /* First add it to DECL_ARGUMENTS between 'this' and the real args... */
254 TREE_CHAIN (parm) = parms;
255 parms = parm;
256
257 /* ...and then to TYPE_ARG_TYPES. */
258 arg_types = hash_tree_chain (vtt_parm_type, arg_types);
259
260 DECL_HAS_VTT_PARM_P (fn) = 1;
261 }
262
263 /* Then add the in-charge parm (before the VTT parm). */
264 parm = build_artificial_parm (in_charge_identifier, integer_type_node);
265 TREE_CHAIN (parm) = parms;
266 parms = parm;
267 arg_types = hash_tree_chain (integer_type_node, arg_types);
268
269 /* Insert our new parameter(s) into the list. */
270 TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms;
271
272 /* And rebuild the function type. */
273 fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
274 arg_types);
275 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
276 fntype = build_exception_variant (fntype,
277 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
278 TREE_TYPE (fn) = fntype;
279
280 /* Now we've got the in-charge parameter. */
281 DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
282 }
283
284 /* Classes overload their constituent function names automatically.
285 When a function name is declared in a record structure,
286 its name is changed to it overloaded name. Since names for
287 constructors and destructors can conflict, we place a leading
288 '$' for destructors.
289
290 CNAME is the name of the class we are grokking for.
291
292 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
293
294 FLAGS contains bits saying what's special about today's
295 arguments. 1 == DESTRUCTOR. 2 == OPERATOR.
296
297 If FUNCTION is a destructor, then we must add the `auto-delete' field
298 as a second parameter. There is some hair associated with the fact
299 that we must "declare" this variable in the manner consistent with the
300 way the rest of the arguments were declared.
301
302 QUALS are the qualifiers for the this pointer. */
303
304 void
grokclassfn(tree ctype,tree function,enum overload_flags flags,tree quals)305 grokclassfn (tree ctype, tree function, enum overload_flags flags, tree quals)
306 {
307 tree fn_name = DECL_NAME (function);
308 int this_quals = TYPE_UNQUALIFIED;
309
310 /* Even within an `extern "C"' block, members get C++ linkage. See
311 [dcl.link] for details. */
312 SET_DECL_LANGUAGE (function, lang_cplusplus);
313
314 if (fn_name == NULL_TREE)
315 {
316 error ("name missing for member function");
317 fn_name = get_identifier ("<anonymous>");
318 DECL_NAME (function) = fn_name;
319 }
320
321 if (quals)
322 this_quals = grok_method_quals (ctype, function, quals);
323
324 if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
325 {
326 /* Must add the class instance variable up front. */
327 /* Right now we just make this a pointer. But later
328 we may wish to make it special. */
329 tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (function)));
330 tree qual_type;
331 tree parm;
332
333 /* The `this' parameter is implicitly `const'; it cannot be
334 assigned to. */
335 this_quals |= TYPE_QUAL_CONST;
336 qual_type = cp_build_qualified_type (type, this_quals);
337 parm = build_artificial_parm (this_identifier, qual_type);
338 c_apply_type_quals_to_decl (this_quals, parm);
339 TREE_CHAIN (parm) = DECL_ARGUMENTS (function);
340 DECL_ARGUMENTS (function) = parm;
341 }
342
343 DECL_CONTEXT (function) = ctype;
344
345 if (flags == DTOR_FLAG)
346 DECL_DESTRUCTOR_P (function) = 1;
347
348 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
349 maybe_retrofit_in_chrg (function);
350 }
351
352 /* Create an ARRAY_REF, checking for the user doing things backwards
353 along the way. */
354
355 tree
grok_array_decl(tree array_expr,tree index_exp)356 grok_array_decl (tree array_expr, tree index_exp)
357 {
358 tree type;
359 tree expr;
360 tree orig_array_expr = array_expr;
361 tree orig_index_exp = index_exp;
362
363 if (error_operand_p (array_expr) || error_operand_p (index_exp))
364 return error_mark_node;
365
366 if (processing_template_decl)
367 {
368 if (type_dependent_expression_p (array_expr)
369 || type_dependent_expression_p (index_exp))
370 return build_min_nt (ARRAY_REF, array_expr, index_exp);
371 array_expr = build_non_dependent_expr (array_expr);
372 index_exp = build_non_dependent_expr (index_exp);
373 }
374
375 type = TREE_TYPE (array_expr);
376 my_friendly_assert (type, 20030626);
377 type = non_reference (type);
378
379 /* If they have an `operator[]', use that. */
380 if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))
381 expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
382 array_expr, index_exp, NULL_TREE,
383 /*overloaded_p=*/NULL);
384 else
385 {
386 tree p1, p2, i1, i2;
387
388 /* Otherwise, create an ARRAY_REF for a pointer or array type.
389 It is a little-known fact that, if `a' is an array and `i' is
390 an int, you can write `i[a]', which means the same thing as
391 `a[i]'. */
392 if (TREE_CODE (type) == ARRAY_TYPE)
393 p1 = array_expr;
394 else
395 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
396
397 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
398 p2 = index_exp;
399 else
400 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
401
402 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
403 false);
404 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
405 false);
406
407 if ((p1 && i2) && (i1 && p2))
408 error ("ambiguous conversion for array subscript");
409
410 if (p1 && i2)
411 array_expr = p1, index_exp = i2;
412 else if (i1 && p2)
413 array_expr = p2, index_exp = i1;
414 else
415 {
416 error ("invalid types `%T[%T]' for array subscript",
417 type, TREE_TYPE (index_exp));
418 return error_mark_node;
419 }
420
421 if (array_expr == error_mark_node || index_exp == error_mark_node)
422 error ("ambiguous conversion for array subscript");
423
424 expr = build_array_ref (array_expr, index_exp);
425 }
426 if (processing_template_decl && expr != error_mark_node)
427 return build_min_non_dep (ARRAY_REF, expr,
428 orig_array_expr, orig_index_exp);
429 return expr;
430 }
431
432 /* Given the cast expression EXP, checking out its validity. Either return
433 an error_mark_node if there was an unavoidable error, return a cast to
434 void for trying to delete a pointer w/ the value 0, or return the
435 call to delete. If DOING_VEC is true, we handle things differently
436 for doing an array delete.
437 Implements ARM $5.3.4. This is called from the parser. */
438
439 tree
delete_sanity(tree exp,tree size,bool doing_vec,int use_global_delete)440 delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete)
441 {
442 tree t, type;
443
444 if (exp == error_mark_node)
445 return exp;
446
447 if (processing_template_decl)
448 {
449 t = build_min (DELETE_EXPR, void_type_node, exp, size);
450 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
451 DELETE_EXPR_USE_VEC (t) = doing_vec;
452 TREE_SIDE_EFFECTS (t) = 1;
453 return t;
454 }
455
456 exp = convert_from_reference (exp);
457
458 /* An array can't have been allocated by new, so complain. */
459 if (TREE_CODE (exp) == VAR_DECL
460 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
461 warning ("deleting array `%#D'", exp);
462
463 t = build_expr_type_conversion (WANT_POINTER, exp, true);
464
465 if (t == NULL_TREE || t == error_mark_node)
466 {
467 error ("type `%#T' argument given to `delete', expected pointer",
468 TREE_TYPE (exp));
469 return error_mark_node;
470 }
471
472 type = TREE_TYPE (t);
473
474 /* As of Valley Forge, you can delete a pointer to const. */
475
476 /* You can't delete functions. */
477 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
478 {
479 error ("cannot delete a function. Only pointer-to-objects are valid arguments to `delete'");
480 return error_mark_node;
481 }
482
483 /* Deleting ptr to void is undefined behavior [expr.delete/3]. */
484 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
485 {
486 warning ("deleting `%T' is undefined", type);
487 doing_vec = 0;
488 }
489
490 /* Deleting a pointer with the value zero is valid and has no effect. */
491 if (integer_zerop (t))
492 return build1 (NOP_EXPR, void_type_node, t);
493
494 if (doing_vec)
495 return build_vec_delete (t, /*maxindex=*/NULL_TREE,
496 sfk_deleting_destructor,
497 use_global_delete);
498 else
499 return build_delete (type, t, sfk_deleting_destructor,
500 LOOKUP_NORMAL, use_global_delete);
501 }
502
503 /* Report an error if the indicated template declaration is not the
504 sort of thing that should be a member template. */
505
506 void
check_member_template(tree tmpl)507 check_member_template (tree tmpl)
508 {
509 tree decl;
510
511 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
512 decl = DECL_TEMPLATE_RESULT (tmpl);
513
514 if (TREE_CODE (decl) == FUNCTION_DECL
515 || (TREE_CODE (decl) == TYPE_DECL
516 && IS_AGGR_TYPE (TREE_TYPE (decl))))
517 {
518 if (current_function_decl)
519 /* 14.5.2.2 [temp.mem]
520
521 A local class shall not have member templates. */
522 error ("invalid declaration of member template `%#D' in local class",
523 decl);
524
525 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
526 {
527 /* 14.5.2.3 [temp.mem]
528
529 A member function template shall not be virtual. */
530 error
531 ("invalid use of `virtual' in template declaration of `%#D'",
532 decl);
533 DECL_VIRTUAL_P (decl) = 0;
534 }
535
536 /* The debug-information generating code doesn't know what to do
537 with member templates. */
538 DECL_IGNORED_P (tmpl) = 1;
539 }
540 else
541 error ("template declaration of `%#D'", decl);
542 }
543
544 /* Return true iff TYPE is a valid Java parameter or return type. */
545
546 static bool
acceptable_java_type(tree type)547 acceptable_java_type (tree type)
548 {
549 if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
550 return 1;
551 if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
552 {
553 type = TREE_TYPE (type);
554 if (TREE_CODE (type) == RECORD_TYPE)
555 {
556 tree args; int i;
557 if (! TYPE_FOR_JAVA (type))
558 return false;
559 if (! CLASSTYPE_TEMPLATE_INFO (type))
560 return true;
561 args = CLASSTYPE_TI_ARGS (type);
562 i = TREE_VEC_LENGTH (args);
563 while (--i >= 0)
564 {
565 type = TREE_VEC_ELT (args, i);
566 if (TREE_CODE (type) == POINTER_TYPE)
567 type = TREE_TYPE (type);
568 if (! TYPE_FOR_JAVA (type))
569 return false;
570 }
571 return true;
572 }
573 }
574 return false;
575 }
576
577 /* For a METHOD in a Java class CTYPE, return true if
578 the parameter and return types are valid Java types.
579 Otherwise, print appropriate error messages, and return false. */
580
581 bool
check_java_method(tree method)582 check_java_method (tree method)
583 {
584 bool jerr = false;
585 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
586 tree ret_type = TREE_TYPE (TREE_TYPE (method));
587
588 if (!acceptable_java_type (ret_type))
589 {
590 error ("Java method '%D' has non-Java return type `%T'",
591 method, ret_type);
592 jerr = true;
593 }
594
595 arg_types = TREE_CHAIN (arg_types);
596 if (DECL_HAS_IN_CHARGE_PARM_P (method))
597 arg_types = TREE_CHAIN (arg_types);
598 if (DECL_HAS_VTT_PARM_P (method))
599 arg_types = TREE_CHAIN (arg_types);
600
601 for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
602 {
603 tree type = TREE_VALUE (arg_types);
604 if (!acceptable_java_type (type))
605 {
606 error ("Java method '%D' has non-Java parameter type `%T'",
607 method, type);
608 jerr = true;
609 }
610 }
611 return !jerr;
612 }
613
614 /* Sanity check: report error if this function FUNCTION is not
615 really a member of the class (CTYPE) it is supposed to belong to.
616 CNAME is the same here as it is for grokclassfn above.
617 TEMPLATE_HEADER_P is true when this declaration comes with a
618 template header. */
619
620 tree
check_classfn(tree ctype,tree function,bool template_header_p)621 check_classfn (tree ctype, tree function, bool template_header_p)
622 {
623 int ix;
624 int is_template;
625
626 if (DECL_USE_TEMPLATE (function)
627 && !(TREE_CODE (function) == TEMPLATE_DECL
628 && DECL_TEMPLATE_SPECIALIZATION (function))
629 && is_member_template (DECL_TI_TEMPLATE (function)))
630 /* Since this is a specialization of a member template,
631 we're not going to find the declaration in the class.
632 For example, in:
633
634 struct S { template <typename T> void f(T); };
635 template <> void S::f(int);
636
637 we're not going to find `S::f(int)', but there's no
638 reason we should, either. We let our callers know we didn't
639 find the method, but we don't complain. */
640 return NULL_TREE;
641
642 /* OK, is this a definition of a member template? */
643 is_template = (TREE_CODE (function) == TEMPLATE_DECL
644 || template_header_p);
645
646 ix = lookup_fnfields_1 (complete_type (ctype),
647 DECL_CONSTRUCTOR_P (function) ? ctor_identifier :
648 DECL_DESTRUCTOR_P (function) ? dtor_identifier :
649 DECL_NAME (function));
650
651 if (ix >= 0)
652 {
653 tree methods = CLASSTYPE_METHOD_VEC (ctype);
654 tree fndecls, fndecl = 0;
655 bool is_conv_op;
656 bool pop_p;
657 const char *format = NULL;
658
659 pop_p = push_scope (ctype);
660 for (fndecls = TREE_VEC_ELT (methods, ix);
661 fndecls; fndecls = OVL_NEXT (fndecls))
662 {
663 tree p1, p2;
664
665 fndecl = OVL_CURRENT (fndecls);
666 p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
667 p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
668
669 /* We cannot simply call decls_match because this doesn't
670 work for static member functions that are pretending to
671 be methods, and because the name may have been changed by
672 asm("new_name"). */
673
674 /* Get rid of the this parameter on functions that become
675 static. */
676 if (DECL_STATIC_FUNCTION_P (fndecl)
677 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
678 p1 = TREE_CHAIN (p1);
679
680 /* A member template definition only matches a member template
681 declaration. */
682 if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
683 continue;
684
685 if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
686 TREE_TYPE (TREE_TYPE (fndecl)))
687 && compparms (p1, p2)
688 && (DECL_TEMPLATE_SPECIALIZATION (function)
689 == DECL_TEMPLATE_SPECIALIZATION (fndecl))
690 && (!DECL_TEMPLATE_SPECIALIZATION (function)
691 || (DECL_TI_TEMPLATE (function)
692 == DECL_TI_TEMPLATE (fndecl))))
693 break;
694 }
695 if (pop_p)
696 pop_scope (ctype);
697 if (fndecls)
698 return OVL_CURRENT (fndecls);
699 error ("prototype for `%#D' does not match any in class `%T'",
700 function, ctype);
701 is_conv_op = DECL_CONV_FN_P (fndecl);
702
703 if (is_conv_op)
704 ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
705 fndecls = TREE_VEC_ELT (methods, ix);
706 while (fndecls)
707 {
708 fndecl = OVL_CURRENT (fndecls);
709 fndecls = OVL_NEXT (fndecls);
710
711 if (!fndecls && is_conv_op)
712 {
713 if (TREE_VEC_LENGTH (methods) > ix)
714 {
715 ix++;
716 fndecls = TREE_VEC_ELT (methods, ix);
717 if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
718 {
719 fndecls = NULL_TREE;
720 is_conv_op = false;
721 }
722 }
723 else
724 is_conv_op = false;
725 }
726 if (format)
727 format = " %#D";
728 else if (fndecls)
729 format = "candidates are: %#D";
730 else
731 format = "candidate is: %#D";
732 cp_error_at (format, fndecl);
733 }
734 }
735 else if (!COMPLETE_TYPE_P (ctype))
736 cxx_incomplete_type_error (function, ctype);
737 else
738 error ("no `%#D' member function declared in class `%T'",
739 function, ctype);
740
741 /* If we did not find the method in the class, add it to avoid
742 spurious errors (unless the CTYPE is not yet defined, in which
743 case we'll only confuse ourselves when the function is declared
744 properly within the class. */
745 if (COMPLETE_TYPE_P (ctype))
746 add_method (ctype, function, /*error_p=*/1);
747 return NULL_TREE;
748 }
749
750 /* We have just processed the DECL, which is a static data member.
751 Its initializer, if present, is INIT. The ASMSPEC_TREE, if
752 present, is the assembly-language name for the data member.
753 FLAGS is as for cp_finish_decl. */
754
755 void
finish_static_data_member_decl(tree decl,tree init,tree asmspec_tree,int flags)756 finish_static_data_member_decl (tree decl, tree init, tree asmspec_tree,
757 int flags)
758 {
759 my_friendly_assert (TREE_PUBLIC (decl), 0);
760
761 DECL_CONTEXT (decl) = current_class_type;
762
763 /* We cannot call pushdecl here, because that would fill in the
764 TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
765 the right thing, namely, to put this decl out straight away. */
766 /* current_class_type can be NULL_TREE in case of error. */
767 if (!asmspec_tree && current_class_type)
768 DECL_INITIAL (decl) = error_mark_node;
769
770 if (! processing_template_decl)
771 {
772 if (!pending_statics)
773 VARRAY_TREE_INIT (pending_statics, 32, "pending_statics");
774 VARRAY_PUSH_TREE (pending_statics, decl);
775 }
776
777 if (LOCAL_CLASS_P (current_class_type))
778 pedwarn ("local class `%#T' shall not have static data member `%#D'",
779 current_class_type, decl);
780
781 /* Static consts need not be initialized in the class definition. */
782 if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
783 {
784 static int explained = 0;
785
786 error ("initializer invalid for static member with constructor");
787 if (!explained)
788 {
789 error ("(an out of class initialization is required)");
790 explained = 1;
791 }
792 init = NULL_TREE;
793 }
794 /* Force the compiler to know when an uninitialized static const
795 member is being used. */
796 if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0)
797 TREE_USED (decl) = 1;
798 DECL_INITIAL (decl) = init;
799 DECL_IN_AGGR_P (decl) = 1;
800
801 cp_finish_decl (decl, init, asmspec_tree, flags);
802 }
803
804 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
805 of a structure component, returning a _DECL node.
806 QUALS is a list of type qualifiers for this decl (such as for declaring
807 const member functions).
808
809 This is done during the parsing of the struct declaration.
810 The _DECL nodes are chained together and the lot of them
811 are ultimately passed to `build_struct' to make the RECORD_TYPE node.
812
813 If class A defines that certain functions in class B are friends, then
814 the way I have set things up, it is B who is interested in permission
815 granted by A. However, it is in A's context that these declarations
816 are parsed. By returning a void_type_node, class A does not attempt
817 to incorporate the declarations of the friends within its structure.
818
819 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
820 CHANGES TO CODE IN `start_method'. */
821
822 tree
grokfield(tree declarator,tree declspecs,tree init,tree asmspec_tree,tree attrlist)823 grokfield (tree declarator, tree declspecs, tree init, tree asmspec_tree,
824 tree attrlist)
825 {
826 tree value;
827 const char *asmspec = 0;
828 int flags = LOOKUP_ONLYCONVERTING;
829
830 if (declspecs == NULL_TREE
831 && TREE_CODE (declarator) == SCOPE_REF
832 && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE)
833 {
834 /* Access declaration */
835 if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0))))
836 ;
837 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
838 pop_nested_class ();
839 return do_class_using_decl (declarator);
840 }
841
842 if (init
843 && TREE_CODE (init) == TREE_LIST
844 && TREE_VALUE (init) == error_mark_node
845 && TREE_CHAIN (init) == NULL_TREE)
846 init = NULL_TREE;
847
848 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
849 if (! value || error_operand_p (value))
850 /* friend or constructor went bad. */
851 return error_mark_node;
852
853 if (TREE_CODE (value) == TYPE_DECL && init)
854 {
855 error ("typedef `%D' is initialized (use __typeof__ instead)", value);
856 init = NULL_TREE;
857 }
858
859 /* Pass friendly classes back. */
860 if (value == void_type_node)
861 return value;
862
863 /* Pass friend decls back. */
864 if ((TREE_CODE (value) == FUNCTION_DECL
865 || TREE_CODE (value) == TEMPLATE_DECL)
866 && DECL_CONTEXT (value) != current_class_type)
867 return value;
868
869 if (DECL_NAME (value) != NULL_TREE
870 && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
871 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
872 error ("member `%D' conflicts with virtual function table field name",
873 value);
874
875 /* Stash away type declarations. */
876 if (TREE_CODE (value) == TYPE_DECL)
877 {
878 DECL_NONLOCAL (value) = 1;
879 DECL_CONTEXT (value) = current_class_type;
880
881 if (processing_template_decl)
882 value = push_template_decl (value);
883
884 return value;
885 }
886
887 if (DECL_IN_AGGR_P (value))
888 {
889 error ("`%D' is already defined in `%T'", value,
890 DECL_CONTEXT (value));
891 return void_type_node;
892 }
893
894 if (asmspec_tree)
895 asmspec = TREE_STRING_POINTER (asmspec_tree);
896
897 if (init)
898 {
899 if (TREE_CODE (value) == FUNCTION_DECL)
900 {
901 grok_function_init (value, init);
902 init = NULL_TREE;
903 }
904 else if (pedantic && TREE_CODE (value) != VAR_DECL)
905 /* Already complained in grokdeclarator. */
906 init = NULL_TREE;
907 else
908 {
909 /* We allow initializers to become parameters to base
910 initializers. */
911 if (TREE_CODE (init) == TREE_LIST)
912 {
913 if (TREE_CHAIN (init) == NULL_TREE)
914 init = TREE_VALUE (init);
915 else
916 init = digest_init (TREE_TYPE (value), init, (tree *)0);
917 }
918
919 if (!processing_template_decl)
920 {
921 if (TREE_CODE (init) == CONST_DECL)
922 init = DECL_INITIAL (init);
923 else if (TREE_READONLY_DECL_P (init))
924 init = decl_constant_value (init);
925 else if (TREE_CODE (init) == CONSTRUCTOR)
926 init = digest_init (TREE_TYPE (value), init, (tree *)0);
927 if (init != error_mark_node && ! TREE_CONSTANT (init))
928 {
929 /* We can allow references to things that are effectively
930 static, since references are initialized with the
931 address. */
932 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
933 || (TREE_STATIC (init) == 0
934 && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
935 {
936 error ("field initializer is not constant");
937 init = error_mark_node;
938 }
939 }
940 }
941 }
942 }
943
944 if (processing_template_decl
945 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
946 {
947 value = push_template_decl (value);
948 if (error_operand_p (value))
949 return error_mark_node;
950 }
951
952 if (attrlist)
953 cplus_decl_attributes (&value, attrlist, 0);
954
955 if (TREE_CODE (value) == VAR_DECL)
956 {
957 finish_static_data_member_decl (value, init, asmspec_tree,
958 flags);
959 return value;
960 }
961 if (TREE_CODE (value) == FIELD_DECL)
962 {
963 if (asmspec)
964 error ("`asm' specifiers are not permitted on non-static data members");
965 if (DECL_INITIAL (value) == error_mark_node)
966 init = error_mark_node;
967 cp_finish_decl (value, init, NULL_TREE, flags);
968 DECL_INITIAL (value) = init;
969 DECL_IN_AGGR_P (value) = 1;
970 return value;
971 }
972 if (TREE_CODE (value) == FUNCTION_DECL)
973 {
974 if (asmspec)
975 {
976 /* This must override the asm specifier which was placed
977 by grokclassfn. Lay this out fresh. */
978 SET_DECL_RTL (value, NULL_RTX);
979 change_decl_assembler_name (value, get_identifier (asmspec));
980 }
981 if (!DECL_FRIEND_P (value))
982 grok_special_member_properties (value);
983
984 cp_finish_decl (value, init, asmspec_tree, flags);
985
986 /* Pass friends back this way. */
987 if (DECL_FRIEND_P (value))
988 return void_type_node;
989
990 DECL_IN_AGGR_P (value) = 1;
991 return value;
992 }
993 abort ();
994 /* NOTREACHED */
995 return NULL_TREE;
996 }
997
998 /* Like `grokfield', but for bitfields.
999 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1000
1001 tree
grokbitfield(tree declarator,tree declspecs,tree width)1002 grokbitfield (tree declarator, tree declspecs, tree width)
1003 {
1004 tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, NULL);
1005
1006 if (! value) return NULL_TREE; /* friends went bad. */
1007
1008 /* Pass friendly classes back. */
1009 if (TREE_CODE (value) == VOID_TYPE)
1010 return void_type_node;
1011
1012 if (TREE_CODE (value) == TYPE_DECL)
1013 {
1014 error ("cannot declare `%D' to be a bit-field type", value);
1015 return NULL_TREE;
1016 }
1017
1018 /* Usually, finish_struct_1 catches bitfields with invalid types.
1019 But, in the case of bitfields with function type, we confuse
1020 ourselves into thinking they are member functions, so we must
1021 check here. */
1022 if (TREE_CODE (value) == FUNCTION_DECL)
1023 {
1024 error ("cannot declare bit-field `%D' with function type",
1025 DECL_NAME (value));
1026 return NULL_TREE;
1027 }
1028
1029 if (DECL_IN_AGGR_P (value))
1030 {
1031 error ("`%D' is already defined in the class %T", value,
1032 DECL_CONTEXT (value));
1033 return void_type_node;
1034 }
1035
1036 if (TREE_STATIC (value))
1037 {
1038 error ("static member `%D' cannot be a bit-field", value);
1039 return NULL_TREE;
1040 }
1041 cp_finish_decl (value, NULL_TREE, NULL_TREE, 0);
1042
1043 if (width != error_mark_node)
1044 {
1045 constant_expression_warning (width);
1046 DECL_INITIAL (value) = width;
1047 SET_DECL_C_BIT_FIELD (value);
1048 }
1049
1050 DECL_IN_AGGR_P (value) = 1;
1051 return value;
1052 }
1053
1054 /* When a function is declared with an initializer,
1055 do the right thing. Currently, there are two possibilities:
1056
1057 class B
1058 {
1059 public:
1060 // initialization possibility #1.
1061 virtual void f () = 0;
1062 int g ();
1063 };
1064
1065 class D1 : B
1066 {
1067 public:
1068 int d1;
1069 // error, no f ();
1070 };
1071
1072 class D2 : B
1073 {
1074 public:
1075 int d2;
1076 void f ();
1077 };
1078
1079 class D3 : B
1080 {
1081 public:
1082 int d3;
1083 // initialization possibility #2
1084 void f () = B::f;
1085 };
1086
1087 */
1088
1089 static void
grok_function_init(tree decl,tree init)1090 grok_function_init (tree decl, tree init)
1091 {
1092 /* An initializer for a function tells how this function should
1093 be inherited. */
1094 tree type = TREE_TYPE (decl);
1095
1096 if (TREE_CODE (type) == FUNCTION_TYPE)
1097 error ("initializer specified for non-member function `%D'", decl);
1098 else if (integer_zerop (init))
1099 DECL_PURE_VIRTUAL_P (decl) = 1;
1100 else
1101 error ("invalid initializer for virtual method `%D'", decl);
1102 }
1103
1104 void
cplus_decl_attributes(tree * decl,tree attributes,int flags)1105 cplus_decl_attributes (tree *decl, tree attributes, int flags)
1106 {
1107 if (*decl == NULL_TREE || *decl == void_type_node)
1108 return;
1109
1110 if (TREE_CODE (*decl) == TEMPLATE_DECL)
1111 decl = &DECL_TEMPLATE_RESULT (*decl);
1112
1113 decl_attributes (decl, attributes, flags);
1114
1115 if (TREE_CODE (*decl) == TYPE_DECL)
1116 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1117 }
1118
1119 /* Defer the compilation of the FN until the end of compilation. */
1120
1121 void
defer_fn(tree fn)1122 defer_fn (tree fn)
1123 {
1124 if (DECL_DEFERRED_FN (fn))
1125 return;
1126 DECL_DEFERRED_FN (fn) = 1;
1127 DECL_DEFER_OUTPUT (fn) = 1;
1128 if (!deferred_fns)
1129 VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
1130
1131 VARRAY_PUSH_TREE (deferred_fns, fn);
1132 }
1133
1134 /* Walks through the namespace- or function-scope anonymous union OBJECT,
1135 building appropriate ALIAS_DECLs. Returns one of the fields for use in
1136 the mangled name. */
1137
1138 static tree
build_anon_union_vars(tree object)1139 build_anon_union_vars (tree object)
1140 {
1141 tree type = TREE_TYPE (object);
1142 tree main_decl = NULL_TREE;
1143 tree field;
1144
1145 /* Rather than write the code to handle the non-union case,
1146 just give an error. */
1147 if (TREE_CODE (type) != UNION_TYPE)
1148 error ("anonymous struct not inside named type");
1149
1150 for (field = TYPE_FIELDS (type);
1151 field != NULL_TREE;
1152 field = TREE_CHAIN (field))
1153 {
1154 tree decl;
1155 tree ref;
1156
1157 if (DECL_ARTIFICIAL (field))
1158 continue;
1159 if (TREE_CODE (field) != FIELD_DECL)
1160 {
1161 cp_pedwarn_at ("\
1162 `%#D' invalid; an anonymous union can only have non-static data members",
1163 field);
1164 continue;
1165 }
1166
1167 if (TREE_PRIVATE (field))
1168 cp_pedwarn_at ("private member `%#D' in anonymous union", field);
1169 else if (TREE_PROTECTED (field))
1170 cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
1171
1172 if (processing_template_decl)
1173 ref = build_min_nt (COMPONENT_REF, object, DECL_NAME (field));
1174 else
1175 ref = build_class_member_access_expr (object, field, NULL_TREE,
1176 false);
1177
1178 if (DECL_NAME (field))
1179 {
1180 decl = build_decl (ALIAS_DECL, DECL_NAME (field), TREE_TYPE (field));
1181 DECL_INITIAL (decl) = ref;
1182 TREE_PUBLIC (decl) = 0;
1183 TREE_STATIC (decl) = 0;
1184 DECL_EXTERNAL (decl) = 1;
1185 decl = pushdecl (decl);
1186 }
1187 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1188 decl = build_anon_union_vars (ref);
1189 else
1190 decl = 0;
1191
1192 if (main_decl == NULL_TREE)
1193 main_decl = decl;
1194 }
1195
1196 return main_decl;
1197 }
1198
1199 /* Finish off the processing of a UNION_TYPE structure. If the union is an
1200 anonymous union, then all members must be laid out together. PUBLIC_P
1201 is nonzero if this union is not declared static. */
1202
1203 void
finish_anon_union(tree anon_union_decl)1204 finish_anon_union (tree anon_union_decl)
1205 {
1206 tree type = TREE_TYPE (anon_union_decl);
1207 tree main_decl;
1208 bool public_p = TREE_PUBLIC (anon_union_decl);
1209
1210 /* The VAR_DECL's context is the same as the TYPE's context. */
1211 DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1212
1213 if (TYPE_FIELDS (type) == NULL_TREE)
1214 return;
1215
1216 if (public_p)
1217 {
1218 error ("namespace-scope anonymous aggregates must be static");
1219 return;
1220 }
1221
1222 main_decl = build_anon_union_vars (anon_union_decl);
1223 if (main_decl == NULL_TREE)
1224 {
1225 warning ("anonymous union with no members");
1226 return;
1227 }
1228
1229 if (!processing_template_decl)
1230 {
1231 /* Use main_decl to set the mangled name. */
1232 DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
1233 mangle_decl (anon_union_decl);
1234 DECL_NAME (anon_union_decl) = NULL_TREE;
1235 }
1236
1237 pushdecl (anon_union_decl);
1238 if (building_stmt_tree ()
1239 && at_function_scope_p ())
1240 add_decl_stmt (anon_union_decl);
1241 else if (!processing_template_decl)
1242 rest_of_decl_compilation (anon_union_decl, NULL,
1243 toplevel_bindings_p (), at_eof);
1244 }
1245
1246 /* Auxiliary functions to make type signatures for
1247 `operator new' and `operator delete' correspond to
1248 what compiler will be expecting. */
1249
1250 tree
coerce_new_type(tree type)1251 coerce_new_type (tree type)
1252 {
1253 int e = 0;
1254 tree args = TYPE_ARG_TYPES (type);
1255
1256 my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
1257
1258 if (!same_type_p (TREE_TYPE (type), ptr_type_node))
1259 e = 1, error ("`operator new' must return type `%T'", ptr_type_node);
1260
1261 if (!args || args == void_list_node
1262 || !same_type_p (TREE_VALUE (args), size_type_node))
1263 {
1264 e = 2;
1265 if (args && args != void_list_node)
1266 args = TREE_CHAIN (args);
1267 pedwarn ("`operator new' takes type `size_t' (`%T') as first parameter", size_type_node);
1268 }
1269 switch (e)
1270 {
1271 case 2:
1272 args = tree_cons (NULL_TREE, size_type_node, args);
1273 /* Fall through. */
1274 case 1:
1275 type = build_exception_variant
1276 (build_function_type (ptr_type_node, args),
1277 TYPE_RAISES_EXCEPTIONS (type));
1278 /* Fall through. */
1279 default:;
1280 }
1281 return type;
1282 }
1283
1284 tree
coerce_delete_type(tree type)1285 coerce_delete_type (tree type)
1286 {
1287 int e = 0;
1288 tree args = TYPE_ARG_TYPES (type);
1289
1290 my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
1291
1292 if (!same_type_p (TREE_TYPE (type), void_type_node))
1293 e = 1, error ("`operator delete' must return type `%T'", void_type_node);
1294
1295 if (!args || args == void_list_node
1296 || !same_type_p (TREE_VALUE (args), ptr_type_node))
1297 {
1298 e = 2;
1299 if (args && args != void_list_node)
1300 args = TREE_CHAIN (args);
1301 error ("`operator delete' takes type `%T' as first parameter", ptr_type_node);
1302 }
1303 switch (e)
1304 {
1305 case 2:
1306 args = tree_cons (NULL_TREE, ptr_type_node, args);
1307 /* Fall through. */
1308 case 1:
1309 type = build_exception_variant
1310 (build_function_type (void_type_node, args),
1311 TYPE_RAISES_EXCEPTIONS (type));
1312 /* Fall through. */
1313 default:;
1314 }
1315
1316 return type;
1317 }
1318
1319 static void
mark_vtable_entries(tree decl)1320 mark_vtable_entries (tree decl)
1321 {
1322 tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
1323
1324 for (; entries; entries = TREE_CHAIN (entries))
1325 {
1326 tree fnaddr = TREE_VALUE (entries);
1327 tree fn;
1328
1329 STRIP_NOPS (fnaddr);
1330
1331 if (TREE_CODE (fnaddr) != ADDR_EXPR
1332 && TREE_CODE (fnaddr) != FDESC_EXPR)
1333 /* This entry is an offset: a virtual base class offset, a
1334 virtual call offset, an RTTI offset, etc. */
1335 continue;
1336
1337 fn = TREE_OPERAND (fnaddr, 0);
1338 TREE_ADDRESSABLE (fn) = 1;
1339 /* When we don't have vcall offsets, we output thunks whenever
1340 we output the vtables that contain them. With vcall offsets,
1341 we know all the thunks we'll need when we emit a virtual
1342 function, so we emit the thunks there instead. */
1343 if (DECL_THUNK_P (fn))
1344 use_thunk (fn, /*emit_p=*/0);
1345 mark_used (fn);
1346 }
1347 }
1348
1349 /* Set DECL up to have the closest approximation of "initialized common"
1350 linkage available. */
1351
1352 void
comdat_linkage(tree decl)1353 comdat_linkage (tree decl)
1354 {
1355 if (flag_weak)
1356 make_decl_one_only (decl);
1357 else if (TREE_CODE (decl) == FUNCTION_DECL
1358 || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1359 /* We can just emit function and compiler-generated variables
1360 statically; having multiple copies is (for the most part) only
1361 a waste of space.
1362
1363 There are two correctness issues, however: the address of a
1364 template instantiation with external linkage should be the
1365 same, independent of what translation unit asks for the
1366 address, and this will not hold when we emit multiple copies of
1367 the function. However, there's little else we can do.
1368
1369 Also, by default, the typeinfo implementation assumes that
1370 there will be only one copy of the string used as the name for
1371 each type. Therefore, if weak symbols are unavailable, the
1372 run-time library should perform a more conservative check; it
1373 should perform a string comparison, rather than an address
1374 comparison. */
1375 TREE_PUBLIC (decl) = 0;
1376 else
1377 {
1378 /* Static data member template instantiations, however, cannot
1379 have multiple copies. */
1380 if (DECL_INITIAL (decl) == 0
1381 || DECL_INITIAL (decl) == error_mark_node)
1382 DECL_COMMON (decl) = 1;
1383 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1384 {
1385 DECL_COMMON (decl) = 1;
1386 DECL_INITIAL (decl) = error_mark_node;
1387 }
1388 else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1389 {
1390 /* We can't do anything useful; leave vars for explicit
1391 instantiation. */
1392 DECL_EXTERNAL (decl) = 1;
1393 DECL_NOT_REALLY_EXTERN (decl) = 0;
1394 }
1395 }
1396
1397 if (DECL_LANG_SPECIFIC (decl))
1398 DECL_COMDAT (decl) = 1;
1399 }
1400
1401 /* For win32 we also want to put explicit instantiations in
1402 linkonce sections, so that they will be merged with implicit
1403 instantiations; otherwise we get duplicate symbol errors. */
1404
1405 void
maybe_make_one_only(tree decl)1406 maybe_make_one_only (tree decl)
1407 {
1408 /* We used to say that this was not necessary on targets that support weak
1409 symbols, because the implicit instantiations will defer to the explicit
1410 one. However, that's not actually the case in SVR4; a strong definition
1411 after a weak one is an error. Also, not making explicit
1412 instantiations one_only means that we can end up with two copies of
1413 some template instantiations. */
1414 if (! flag_weak)
1415 return;
1416
1417 /* We can't set DECL_COMDAT on functions, or finish_file will think
1418 we can get away with not emitting them if they aren't used. We need
1419 to for variables so that cp_finish_decl will update their linkage,
1420 because their DECL_INITIAL may not have been set properly yet. */
1421
1422 make_decl_one_only (decl);
1423
1424 if (TREE_CODE (decl) == VAR_DECL)
1425 {
1426 DECL_COMDAT (decl) = 1;
1427 /* Mark it needed so we don't forget to emit it. */
1428 mark_referenced (DECL_ASSEMBLER_NAME (decl));
1429 }
1430 }
1431
1432 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
1433 based on TYPE and other static flags.
1434
1435 Note that anything public is tagged TREE_PUBLIC, whether
1436 it's public in this file or in another one. */
1437
1438 void
import_export_vtable(tree decl,tree type,int final)1439 import_export_vtable (tree decl, tree type, int final)
1440 {
1441 if (DECL_INTERFACE_KNOWN (decl))
1442 return;
1443
1444 if (TYPE_FOR_JAVA (type))
1445 {
1446 TREE_PUBLIC (decl) = 1;
1447 DECL_EXTERNAL (decl) = 1;
1448 DECL_INTERFACE_KNOWN (decl) = 1;
1449 }
1450 else if (CLASSTYPE_INTERFACE_KNOWN (type))
1451 {
1452 TREE_PUBLIC (decl) = 1;
1453 DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type);
1454 DECL_INTERFACE_KNOWN (decl) = 1;
1455 }
1456 else
1457 {
1458 /* We can only wait to decide if we have real non-inline virtual
1459 functions in our class, or if we come from a template. */
1460
1461 int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
1462 || CLASSTYPE_KEY_METHOD (type) != NULL_TREE);
1463
1464 if (final || ! found)
1465 {
1466 comdat_linkage (decl);
1467 DECL_EXTERNAL (decl) = 0;
1468 }
1469 else
1470 {
1471 TREE_PUBLIC (decl) = 1;
1472 DECL_EXTERNAL (decl) = 1;
1473 }
1474 }
1475 }
1476
1477 /* Determine whether or not we want to specifically import or export CTYPE,
1478 using various heuristics. */
1479
1480 static void
import_export_class(tree ctype)1481 import_export_class (tree ctype)
1482 {
1483 /* -1 for imported, 1 for exported. */
1484 int import_export = 0;
1485
1486 /* It only makes sense to call this function at EOF. The reason is
1487 that this function looks at whether or not the first non-inline
1488 non-abstract virtual member function has been defined in this
1489 translation unit. But, we can't possibly know that until we've
1490 seen the entire translation unit. */
1491 my_friendly_assert (at_eof, 20000226);
1492
1493 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1494 return;
1495
1496 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface,
1497 we will have CLASSTYPE_INTERFACE_ONLY set but not
1498 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
1499 heuristic because someone will supply a #pragma implementation
1500 elsewhere, and deducing it here would produce a conflict. */
1501 if (CLASSTYPE_INTERFACE_ONLY (ctype))
1502 return;
1503
1504 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1505 import_export = -1;
1506 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1507 import_export = 1;
1508
1509 /* If we got -fno-implicit-templates, we import template classes that
1510 weren't explicitly instantiated. */
1511 if (import_export == 0
1512 && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1513 && ! flag_implicit_templates)
1514 import_export = -1;
1515
1516 /* Base our import/export status on that of the first non-inline,
1517 non-pure virtual function, if any. */
1518 if (import_export == 0
1519 && TYPE_POLYMORPHIC_P (ctype))
1520 {
1521 tree method = CLASSTYPE_KEY_METHOD (ctype);
1522 if (method)
1523 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1524 }
1525
1526 #ifdef MULTIPLE_SYMBOL_SPACES
1527 if (import_export == -1)
1528 import_export = 0;
1529 #endif
1530
1531 if (import_export)
1532 {
1533 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1534 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1535 }
1536 }
1537
1538 /* Return true if VAR has already been provided to the back end; in that
1539 case VAR should not be modified further by the front end. */
1540 static bool
var_finalized_p(tree var)1541 var_finalized_p (tree var)
1542 {
1543 if (flag_unit_at_a_time)
1544 return cgraph_varpool_node (var)->finalized;
1545 else
1546 return TREE_ASM_WRITTEN (var);
1547 }
1548
1549 /* If necessary, write out the vtables for the dynamic class CTYPE.
1550 Returns true if any vtables were emitted. */
1551
1552 static bool
maybe_emit_vtables(tree ctype)1553 maybe_emit_vtables (tree ctype)
1554 {
1555 tree vtbl;
1556 tree primary_vtbl;
1557 bool needed = false;
1558
1559 /* If the vtables for this class have already been emitted there is
1560 nothing more to do. */
1561 primary_vtbl = CLASSTYPE_VTABLES (ctype);
1562 if (var_finalized_p (primary_vtbl))
1563 return false;
1564 /* Ignore dummy vtables made by get_vtable_decl. */
1565 if (TREE_TYPE (primary_vtbl) == void_type_node)
1566 return false;
1567
1568 import_export_class (ctype);
1569
1570 /* See if any of the vtables are needed. */
1571 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1572 {
1573 import_export_vtable (vtbl, ctype, 1);
1574 if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))
1575 break;
1576 }
1577 if (!vtbl)
1578 {
1579 /* If the references to this class' vtables are optimized away,
1580 still emit the appropriate debugging information. See
1581 dfs_debug_mark. */
1582 if (DECL_COMDAT (primary_vtbl)
1583 && CLASSTYPE_DEBUG_REQUESTED (ctype))
1584 note_debug_info_needed (ctype);
1585 return false;
1586 }
1587 else if (TREE_PUBLIC (vtbl) && !DECL_COMDAT (vtbl))
1588 needed = true;
1589
1590
1591 /* The ABI requires that we emit all of the vtables if we emit any
1592 of them. */
1593 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1594 {
1595 /* Write it out. */
1596 import_export_vtable (vtbl, ctype, 1);
1597 mark_vtable_entries (vtbl);
1598
1599 /* If we know that DECL is needed, mark it as such for the varpool. */
1600 if (needed)
1601 cgraph_varpool_mark_needed_node (cgraph_varpool_node (vtbl));
1602
1603 if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1604 {
1605 /* It had better be all done at compile-time. */
1606 if (store_init_value (vtbl, DECL_INITIAL (vtbl)))
1607 abort ();
1608 }
1609
1610 if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
1611 {
1612 /* Mark the VAR_DECL node representing the vtable itself as a
1613 "gratuitous" one, thereby forcing dwarfout.c to ignore it.
1614 It is rather important that such things be ignored because
1615 any effort to actually generate DWARF for them will run
1616 into trouble when/if we encounter code like:
1617
1618 #pragma interface
1619 struct S { virtual void member (); };
1620
1621 because the artificial declaration of the vtable itself (as
1622 manufactured by the g++ front end) will say that the vtable
1623 is a static member of `S' but only *after* the debug output
1624 for the definition of `S' has already been output. This causes
1625 grief because the DWARF entry for the definition of the vtable
1626 will try to refer back to an earlier *declaration* of the
1627 vtable as a static member of `S' and there won't be one.
1628 We might be able to arrange to have the "vtable static member"
1629 attached to the member list for `S' before the debug info for
1630 `S' get written (which would solve the problem) but that would
1631 require more intrusive changes to the g++ front end. */
1632
1633 DECL_IGNORED_P (vtbl) = 1;
1634 }
1635
1636 /* Always make vtables weak. */
1637 if (flag_weak)
1638 comdat_linkage (vtbl);
1639
1640 rest_of_decl_compilation (vtbl, NULL, 1, 1);
1641
1642 /* Because we're only doing syntax-checking, we'll never end up
1643 actually marking the variable as written. */
1644 if (flag_syntax_only)
1645 TREE_ASM_WRITTEN (vtbl) = 1;
1646 }
1647
1648 /* Since we're writing out the vtable here, also write the debug
1649 info. */
1650 note_debug_info_needed (ctype);
1651
1652 return true;
1653 }
1654
1655 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
1656 inline function or template instantiation at end-of-file. */
1657
1658 void
import_export_decl(tree decl)1659 import_export_decl (tree decl)
1660 {
1661 if (DECL_INTERFACE_KNOWN (decl))
1662 return;
1663
1664 if (DECL_TEMPLATE_INSTANTIATION (decl)
1665 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1666 {
1667 DECL_NOT_REALLY_EXTERN (decl) = 1;
1668 if ((DECL_IMPLICIT_INSTANTIATION (decl)
1669 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1670 && (flag_implicit_templates
1671 || (flag_implicit_inline_templates
1672 && TREE_CODE (decl) == FUNCTION_DECL
1673 && DECL_DECLARED_INLINE_P (decl))))
1674 {
1675 if (!TREE_PUBLIC (decl))
1676 /* Templates are allowed to have internal linkage. See
1677 [basic.link]. */
1678 ;
1679 else
1680 comdat_linkage (decl);
1681 }
1682 else
1683 {
1684 DECL_EXTERNAL (decl) = 1;
1685 DECL_NOT_REALLY_EXTERN (decl) = 0;
1686 }
1687 }
1688 else if (DECL_FUNCTION_MEMBER_P (decl))
1689 {
1690 if (!DECL_DECLARED_INLINE_P (decl))
1691 {
1692 tree ctype = DECL_CONTEXT (decl);
1693 import_export_class (ctype);
1694 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1695 {
1696 DECL_NOT_REALLY_EXTERN (decl)
1697 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
1698 || (DECL_DECLARED_INLINE_P (decl)
1699 && ! flag_implement_inlines
1700 && !DECL_VINDEX (decl)));
1701
1702 if (!DECL_NOT_REALLY_EXTERN (decl))
1703 DECL_EXTERNAL (decl) = 1;
1704
1705 /* Always make artificials weak. */
1706 if (DECL_ARTIFICIAL (decl) && flag_weak)
1707 comdat_linkage (decl);
1708 else
1709 maybe_make_one_only (decl);
1710 }
1711 }
1712 else
1713 comdat_linkage (decl);
1714 }
1715 else
1716 comdat_linkage (decl);
1717
1718 DECL_INTERFACE_KNOWN (decl) = 1;
1719 }
1720
1721 /* Here, we only decide whether or not the tinfo node should be
1722 emitted with the vtable. IS_IN_LIBRARY is nonzero iff the
1723 typeinfo for TYPE should be in the runtime library. */
1724
1725 void
import_export_tinfo(tree decl,tree type,bool is_in_library)1726 import_export_tinfo (tree decl, tree type, bool is_in_library)
1727 {
1728 if (DECL_INTERFACE_KNOWN (decl))
1729 return;
1730
1731 if (IS_AGGR_TYPE (type))
1732 import_export_class (type);
1733
1734 if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type)
1735 && TYPE_POLYMORPHIC_P (type)
1736 /* If -fno-rtti, we're not necessarily emitting this stuff with
1737 the class, so go ahead and emit it now. This can happen when
1738 a class is used in exception handling. */
1739 && flag_rtti)
1740 {
1741 DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type);
1742 DECL_COMDAT (decl) = 0;
1743 }
1744 else
1745 {
1746 DECL_NOT_REALLY_EXTERN (decl) = 1;
1747 DECL_COMDAT (decl) = 1;
1748 }
1749
1750 /* Now override some cases. */
1751 if (flag_weak)
1752 DECL_COMDAT (decl) = 1;
1753 else if (is_in_library)
1754 DECL_COMDAT (decl) = 0;
1755
1756 DECL_INTERFACE_KNOWN (decl) = 1;
1757 }
1758
1759 /* Return an expression that performs the destruction of DECL, which
1760 must be a VAR_DECL whose type has a non-trivial destructor, or is
1761 an array whose (innermost) elements have a non-trivial destructor. */
1762
1763 tree
build_cleanup(tree decl)1764 build_cleanup (tree decl)
1765 {
1766 tree temp;
1767 tree type = TREE_TYPE (decl);
1768
1769 /* This function should only be called for declarations that really
1770 require cleanups. */
1771 my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106);
1772
1773 /* Treat all objects with destructors as used; the destructor may do
1774 something substantive. */
1775 mark_used (decl);
1776
1777 if (TREE_CODE (type) == ARRAY_TYPE)
1778 temp = decl;
1779 else
1780 {
1781 cxx_mark_addressable (decl);
1782 temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
1783 }
1784 temp = build_delete (TREE_TYPE (temp), temp,
1785 sfk_complete_destructor,
1786 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
1787 return temp;
1788 }
1789
1790 /* Returns the initialization guard variable for the variable DECL,
1791 which has static storage duration. */
1792
1793 tree
get_guard(tree decl)1794 get_guard (tree decl)
1795 {
1796 tree sname;
1797 tree guard;
1798
1799 sname = mangle_guard_variable (decl);
1800 guard = IDENTIFIER_GLOBAL_VALUE (sname);
1801 if (! guard)
1802 {
1803 tree guard_type;
1804
1805 /* We use a type that is big enough to contain a mutex as well
1806 as an integer counter. */
1807 guard_type = long_long_integer_type_node;
1808 guard = build_decl (VAR_DECL, sname, guard_type);
1809
1810 /* The guard should have the same linkage as what it guards. */
1811 TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
1812 TREE_STATIC (guard) = TREE_STATIC (decl);
1813 DECL_COMMON (guard) = DECL_COMMON (decl);
1814 DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl);
1815 if (TREE_PUBLIC (decl))
1816 DECL_WEAK (guard) = DECL_WEAK (decl);
1817
1818 DECL_ARTIFICIAL (guard) = 1;
1819 TREE_USED (guard) = 1;
1820 pushdecl_top_level_and_finish (guard, NULL_TREE);
1821 }
1822 return guard;
1823 }
1824
1825 /* Return those bits of the GUARD variable that should be set when the
1826 guarded entity is actually initialized. */
1827
1828 static tree
get_guard_bits(tree guard)1829 get_guard_bits (tree guard)
1830 {
1831 /* We only set the first byte of the guard, in order to leave room
1832 for a mutex in the high-order bits. */
1833 guard = build1 (ADDR_EXPR,
1834 build_pointer_type (TREE_TYPE (guard)),
1835 guard);
1836 guard = build1 (NOP_EXPR,
1837 build_pointer_type (char_type_node),
1838 guard);
1839 guard = build1 (INDIRECT_REF, char_type_node, guard);
1840
1841 return guard;
1842 }
1843
1844 /* Return an expression which determines whether or not the GUARD
1845 variable has already been initialized. */
1846
1847 tree
get_guard_cond(tree guard)1848 get_guard_cond (tree guard)
1849 {
1850 tree guard_value;
1851
1852 /* Check to see if the GUARD is zero. */
1853 guard = get_guard_bits (guard);
1854 guard_value = integer_zero_node;
1855 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
1856 guard_value = convert (TREE_TYPE (guard), guard_value);
1857 return cp_build_binary_op (EQ_EXPR, guard, guard_value);
1858 }
1859
1860 /* Return an expression which sets the GUARD variable, indicating that
1861 the variable being guarded has been initialized. */
1862
1863 tree
set_guard(tree guard)1864 set_guard (tree guard)
1865 {
1866 tree guard_init;
1867
1868 /* Set the GUARD to one. */
1869 guard = get_guard_bits (guard);
1870 guard_init = integer_one_node;
1871 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
1872 guard_init = convert (TREE_TYPE (guard), guard_init);
1873 return build_modify_expr (guard, NOP_EXPR, guard_init);
1874 }
1875
1876 /* Start the process of running a particular set of global constructors
1877 or destructors. Subroutine of do_[cd]tors. */
1878
1879 static tree
start_objects(int method_type,int initp)1880 start_objects (int method_type, int initp)
1881 {
1882 tree fnname;
1883 tree body;
1884 char type[10];
1885
1886 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
1887
1888 if (initp != DEFAULT_INIT_PRIORITY)
1889 {
1890 char joiner;
1891
1892 #ifdef JOINER
1893 joiner = JOINER;
1894 #else
1895 joiner = '_';
1896 #endif
1897
1898 sprintf (type, "%c%c%.5u", method_type, joiner, initp);
1899 }
1900 else
1901 sprintf (type, "%c", method_type);
1902
1903 fnname = get_file_function_name_long (type);
1904
1905 start_function (void_list_node,
1906 make_call_declarator (fnname, void_list_node, NULL_TREE,
1907 NULL_TREE),
1908 NULL_TREE, SF_DEFAULT);
1909
1910 /* It can be a static function as long as collect2 does not have
1911 to scan the object file to find its ctor/dtor routine. */
1912 TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
1913
1914 /* Mark this declaration as used to avoid spurious warnings. */
1915 TREE_USED (current_function_decl) = 1;
1916
1917 /* Mark this function as a global constructor or destructor. */
1918 if (method_type == 'I')
1919 DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
1920 else
1921 DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
1922 DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1;
1923
1924 body = begin_compound_stmt (/*has_no_scope=*/false);
1925
1926 /* We cannot allow these functions to be elided, even if they do not
1927 have external linkage. And, there's no point in deferring
1928 compilation of thes functions; they're all going to have to be
1929 out anyhow. */
1930 current_function_cannot_inline
1931 = "static constructors and destructors cannot be inlined";
1932
1933 return body;
1934 }
1935
1936 /* Finish the process of running a particular set of global constructors
1937 or destructors. Subroutine of do_[cd]tors. */
1938
1939 static void
finish_objects(int method_type,int initp,tree body)1940 finish_objects (int method_type, int initp, tree body)
1941 {
1942 tree fn;
1943
1944 /* Finish up. */
1945 finish_compound_stmt (body);
1946 fn = finish_function (0);
1947 expand_or_defer_fn (fn);
1948
1949 /* When only doing semantic analysis, and no RTL generation, we
1950 can't call functions that directly emit assembly code; there is
1951 no assembly file in which to put the code. */
1952 if (flag_syntax_only)
1953 return;
1954
1955 if (targetm.have_ctors_dtors)
1956 {
1957 rtx fnsym = XEXP (DECL_RTL (fn), 0);
1958 if (method_type == 'I')
1959 (* targetm.asm_out.constructor) (fnsym, initp);
1960 else
1961 (* targetm.asm_out.destructor) (fnsym, initp);
1962 }
1963 }
1964
1965 /* The names of the parameters to the function created to handle
1966 initializations and destructions for objects with static storage
1967 duration. */
1968 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
1969 #define PRIORITY_IDENTIFIER "__priority"
1970
1971 /* The name of the function we create to handle initializations and
1972 destructions for objects with static storage duration. */
1973 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
1974
1975 /* The declaration for the __INITIALIZE_P argument. */
1976 static GTY(()) tree initialize_p_decl;
1977
1978 /* The declaration for the __PRIORITY argument. */
1979 static GTY(()) tree priority_decl;
1980
1981 /* The declaration for the static storage duration function. */
1982 static GTY(()) tree ssdf_decl;
1983
1984 /* All the static storage duration functions created in this
1985 translation unit. */
1986 static GTY(()) varray_type ssdf_decls;
1987
1988 /* A map from priority levels to information about that priority
1989 level. There may be many such levels, so efficient lookup is
1990 important. */
1991 static splay_tree priority_info_map;
1992
1993 /* Begins the generation of the function that will handle all
1994 initialization and destruction of objects with static storage
1995 duration. The function generated takes two parameters of type
1996 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
1997 nonzero, it performs initializations. Otherwise, it performs
1998 destructions. It only performs those initializations or
1999 destructions with the indicated __PRIORITY. The generated function
2000 returns no value.
2001
2002 It is assumed that this function will only be called once per
2003 translation unit. */
2004
2005 static tree
start_static_storage_duration_function(unsigned count)2006 start_static_storage_duration_function (unsigned count)
2007 {
2008 tree parm_types;
2009 tree type;
2010 tree body;
2011 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2012
2013 /* Create the identifier for this function. It will be of the form
2014 SSDF_IDENTIFIER_<number>. */
2015 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2016
2017 /* Create the parameters. */
2018 parm_types = void_list_node;
2019 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2020 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2021 type = build_function_type (void_type_node, parm_types);
2022
2023 /* Create the FUNCTION_DECL itself. */
2024 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2025 get_identifier (id),
2026 type);
2027 TREE_PUBLIC (ssdf_decl) = 0;
2028 DECL_ARTIFICIAL (ssdf_decl) = 1;
2029
2030 /* Put this function in the list of functions to be called from the
2031 static constructors and destructors. */
2032 if (!ssdf_decls)
2033 {
2034 VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2035
2036 /* Take this opportunity to initialize the map from priority
2037 numbers to information about that priority level. */
2038 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2039 /*delete_key_fn=*/0,
2040 /*delete_value_fn=*/
2041 (splay_tree_delete_value_fn) &free);
2042
2043 /* We always need to generate functions for the
2044 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2045 priorities later, we'll be sure to find the
2046 DEFAULT_INIT_PRIORITY. */
2047 get_priority_info (DEFAULT_INIT_PRIORITY);
2048 }
2049
2050 VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
2051
2052 /* Create the argument list. */
2053 initialize_p_decl = cp_build_parm_decl
2054 (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2055 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2056 TREE_USED (initialize_p_decl) = 1;
2057 priority_decl = cp_build_parm_decl
2058 (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2059 DECL_CONTEXT (priority_decl) = ssdf_decl;
2060 TREE_USED (priority_decl) = 1;
2061
2062 TREE_CHAIN (initialize_p_decl) = priority_decl;
2063 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2064
2065 /* Put the function in the global scope. */
2066 pushdecl (ssdf_decl);
2067
2068 /* Start the function itself. This is equivalent to declaring the
2069 function as:
2070
2071 static void __ssdf (int __initialize_p, init __priority_p);
2072
2073 It is static because we only need to call this function from the
2074 various constructor and destructor functions for this module. */
2075 start_function (/*specs=*/NULL_TREE,
2076 ssdf_decl,
2077 /*attrs=*/NULL_TREE,
2078 SF_PRE_PARSED);
2079
2080 /* Set up the scope of the outermost block in the function. */
2081 body = begin_compound_stmt (/*has_no_scope=*/false);
2082
2083 /* This function must not be deferred because we are depending on
2084 its compilation to tell us what is TREE_SYMBOL_REFERENCED. */
2085 current_function_cannot_inline
2086 = "static storage duration functions cannot be inlined";
2087
2088 return body;
2089 }
2090
2091 /* Finish the generation of the function which performs initialization
2092 and destruction of objects with static storage duration. After
2093 this point, no more such objects can be created. */
2094
2095 static void
finish_static_storage_duration_function(tree body)2096 finish_static_storage_duration_function (tree body)
2097 {
2098 /* Close out the function. */
2099 finish_compound_stmt (body);
2100 expand_or_defer_fn (finish_function (0));
2101 }
2102
2103 /* Return the information about the indicated PRIORITY level. If no
2104 code to handle this level has yet been generated, generate the
2105 appropriate prologue. */
2106
2107 static priority_info
get_priority_info(int priority)2108 get_priority_info (int priority)
2109 {
2110 priority_info pi;
2111 splay_tree_node n;
2112
2113 n = splay_tree_lookup (priority_info_map,
2114 (splay_tree_key) priority);
2115 if (!n)
2116 {
2117 /* Create a new priority information structure, and insert it
2118 into the map. */
2119 pi = xmalloc (sizeof (struct priority_info_s));
2120 pi->initializations_p = 0;
2121 pi->destructions_p = 0;
2122 splay_tree_insert (priority_info_map,
2123 (splay_tree_key) priority,
2124 (splay_tree_value) pi);
2125 }
2126 else
2127 pi = (priority_info) n->value;
2128
2129 return pi;
2130 }
2131
2132 /* Set up to handle the initialization or destruction of DECL. If
2133 INITP is nonzero, we are initializing the variable. Otherwise, we
2134 are destroying it. */
2135
2136 static tree
start_static_initialization_or_destruction(tree decl,int initp)2137 start_static_initialization_or_destruction (tree decl, int initp)
2138 {
2139 tree guard_if_stmt = NULL_TREE;
2140 int priority;
2141 tree cond;
2142 tree guard;
2143 tree init_cond;
2144 priority_info pi;
2145
2146 /* Figure out the priority for this declaration. */
2147 priority = DECL_INIT_PRIORITY (decl);
2148 if (!priority)
2149 priority = DEFAULT_INIT_PRIORITY;
2150
2151 /* Remember that we had an initialization or finalization at this
2152 priority. */
2153 pi = get_priority_info (priority);
2154 if (initp)
2155 pi->initializations_p = 1;
2156 else
2157 pi->destructions_p = 1;
2158
2159 /* Trick the compiler into thinking we are at the file and line
2160 where DECL was declared so that error-messages make sense, and so
2161 that the debugger will show somewhat sensible file and line
2162 information. */
2163 input_location = DECL_SOURCE_LOCATION (decl);
2164
2165 /* Because of:
2166
2167 [class.access.spec]
2168
2169 Access control for implicit calls to the constructors,
2170 the conversion functions, or the destructor called to
2171 create and destroy a static data member is performed as
2172 if these calls appeared in the scope of the member's
2173 class.
2174
2175 we pretend we are in a static member function of the class of
2176 which the DECL is a member. */
2177 if (member_p (decl))
2178 {
2179 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
2180 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
2181 }
2182
2183 /* Conditionalize this initialization on being in the right priority
2184 and being initializing/finalizing appropriately. */
2185 guard_if_stmt = begin_if_stmt ();
2186 cond = cp_build_binary_op (EQ_EXPR,
2187 priority_decl,
2188 build_int_2 (priority, 0));
2189 init_cond = initp ? integer_one_node : integer_zero_node;
2190 init_cond = cp_build_binary_op (EQ_EXPR,
2191 initialize_p_decl,
2192 init_cond);
2193 cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
2194
2195 /* Assume we don't need a guard. */
2196 guard = NULL_TREE;
2197 /* We need a guard if this is an object with external linkage that
2198 might be initialized in more than one place. (For example, a
2199 static data member of a template, when the data member requires
2200 construction.) */
2201 if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
2202 || DECL_ONE_ONLY (decl)
2203 || DECL_WEAK (decl)))
2204 {
2205 tree guard_cond;
2206
2207 guard = get_guard (decl);
2208
2209 /* When using __cxa_atexit, we just check the GUARD as we would
2210 for a local static. */
2211 if (flag_use_cxa_atexit)
2212 {
2213 /* When using __cxa_atexit, we never try to destroy
2214 anything from a static destructor. */
2215 my_friendly_assert (initp, 20000629);
2216 guard_cond = get_guard_cond (guard);
2217 }
2218 /* If we don't have __cxa_atexit, then we will be running
2219 destructors from .fini sections, or their equivalents. So,
2220 we need to know how many times we've tried to initialize this
2221 object. We do initializations only if the GUARD is zero,
2222 i.e., if we are the first to initialize the variable. We do
2223 destructions only if the GUARD is one, i.e., if we are the
2224 last to destroy the variable. */
2225 else if (initp)
2226 guard_cond
2227 = cp_build_binary_op (EQ_EXPR,
2228 build_unary_op (PREINCREMENT_EXPR,
2229 guard,
2230 /*noconvert=*/1),
2231 integer_one_node);
2232 else
2233 guard_cond
2234 = cp_build_binary_op (EQ_EXPR,
2235 build_unary_op (PREDECREMENT_EXPR,
2236 guard,
2237 /*noconvert=*/1),
2238 integer_zero_node);
2239
2240 cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
2241 }
2242
2243 finish_if_stmt_cond (cond, guard_if_stmt);
2244
2245 /* If we're using __cxa_atexit, we have not already set the GUARD,
2246 so we must do so now. */
2247 if (guard && initp && flag_use_cxa_atexit)
2248 finish_expr_stmt (set_guard (guard));
2249
2250 return guard_if_stmt;
2251 }
2252
2253 /* We've just finished generating code to do an initialization or
2254 finalization. GUARD_IF_STMT is the if-statement we used to guard
2255 the initialization. */
2256
2257 static void
finish_static_initialization_or_destruction(tree guard_if_stmt)2258 finish_static_initialization_or_destruction (tree guard_if_stmt)
2259 {
2260 finish_then_clause (guard_if_stmt);
2261 finish_if_stmt ();
2262
2263 /* Now that we're done with DECL we don't need to pretend to be a
2264 member of its class any longer. */
2265 DECL_CONTEXT (current_function_decl) = NULL_TREE;
2266 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
2267 }
2268
2269 /* Generate code to do the initialization of DECL, a VAR_DECL with
2270 static storage duration. The initialization is INIT. */
2271
2272 static void
do_static_initialization(tree decl,tree init)2273 do_static_initialization (tree decl, tree init)
2274 {
2275 tree guard_if_stmt;
2276
2277 /* Set up for the initialization. */
2278 guard_if_stmt
2279 = start_static_initialization_or_destruction (decl,
2280 /*initp=*/1);
2281
2282 /* Perform the initialization. */
2283 if (init)
2284 finish_expr_stmt (init);
2285
2286 /* If we're using __cxa_atexit, register a a function that calls the
2287 destructor for the object. */
2288 if (flag_use_cxa_atexit)
2289 register_dtor_fn (decl);
2290
2291 /* Finsh up. */
2292 finish_static_initialization_or_destruction (guard_if_stmt);
2293 }
2294
2295 /* Generate code to do the static destruction of DECL. If DECL may be
2296 initialized more than once in different object files, GUARD is the
2297 guard variable to check. PRIORITY is the priority for the
2298 destruction. */
2299
2300 static void
do_static_destruction(tree decl)2301 do_static_destruction (tree decl)
2302 {
2303 tree guard_if_stmt;
2304
2305 /* If we're using __cxa_atexit, then destructors are registered
2306 immediately after objects are initialized. */
2307 my_friendly_assert (!flag_use_cxa_atexit, 20000121);
2308
2309 /* If we don't need a destructor, there's nothing to do. */
2310 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2311 return;
2312
2313 /* Actually do the destruction. */
2314 guard_if_stmt = start_static_initialization_or_destruction (decl,
2315 /*initp=*/0);
2316 finish_expr_stmt (build_cleanup (decl));
2317 finish_static_initialization_or_destruction (guard_if_stmt);
2318 }
2319
2320 /* VARS is a list of variables with static storage duration which may
2321 need initialization and/or finalization. Remove those variables
2322 that don't really need to be initialized or finalized, and return
2323 the resulting list. The order in which the variables appear in
2324 VARS is in reverse order of the order in which they should actually
2325 be initialized. The list we return is in the unreversed order;
2326 i.e., the first variable should be initialized first. */
2327
2328 static tree
prune_vars_needing_no_initialization(tree * vars)2329 prune_vars_needing_no_initialization (tree *vars)
2330 {
2331 tree *var = vars;
2332 tree result = NULL_TREE;
2333
2334 while (*var)
2335 {
2336 tree t = *var;
2337 tree decl = TREE_VALUE (t);
2338 tree init = TREE_PURPOSE (t);
2339
2340 /* Deal gracefully with error. */
2341 if (decl == error_mark_node)
2342 {
2343 var = &TREE_CHAIN (t);
2344 continue;
2345 }
2346
2347 /* The only things that can be initialized are variables. */
2348 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
2349
2350 /* If this object is not defined, we don't need to do anything
2351 here. */
2352 if (DECL_EXTERNAL (decl))
2353 {
2354 var = &TREE_CHAIN (t);
2355 continue;
2356 }
2357
2358 /* Also, if the initializer already contains errors, we can bail
2359 out now. */
2360 if (init && TREE_CODE (init) == TREE_LIST
2361 && value_member (error_mark_node, init))
2362 {
2363 var = &TREE_CHAIN (t);
2364 continue;
2365 }
2366
2367 /* This variable is going to need initialization and/or
2368 finalization, so we add it to the list. */
2369 *var = TREE_CHAIN (t);
2370 TREE_CHAIN (t) = result;
2371 result = t;
2372 }
2373
2374 return result;
2375 }
2376
2377 /* Make sure we have told the back end about all the variables in
2378 VARS. */
2379
2380 static void
write_out_vars(tree vars)2381 write_out_vars (tree vars)
2382 {
2383 tree v;
2384
2385 for (v = vars; v; v = TREE_CHAIN (v))
2386 if (!var_finalized_p (TREE_VALUE (v)))
2387 rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
2388 }
2389
2390 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
2391 (otherwise) that will initialize all gobal objects with static
2392 storage duration having the indicated PRIORITY. */
2393
2394 static void
generate_ctor_or_dtor_function(bool constructor_p,int priority,location_t * locus)2395 generate_ctor_or_dtor_function (bool constructor_p, int priority,
2396 location_t *locus)
2397 {
2398 char function_key;
2399 tree arguments;
2400 tree fndecl;
2401 tree body;
2402 size_t i;
2403
2404 input_location = *locus;
2405 locus->line++;
2406
2407 /* We use `I' to indicate initialization and `D' to indicate
2408 destruction. */
2409 function_key = constructor_p ? 'I' : 'D';
2410
2411 /* We emit the function lazily, to avoid generating empty
2412 global constructors and destructors. */
2413 body = NULL_TREE;
2414
2415 /* Call the static storage duration function with appropriate
2416 arguments. */
2417 if (ssdf_decls)
2418 for (i = 0; i < ssdf_decls->elements_used; ++i)
2419 {
2420 fndecl = VARRAY_TREE (ssdf_decls, i);
2421
2422 /* Calls to pure or const functions will expand to nothing. */
2423 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2424 {
2425 if (! body)
2426 body = start_objects (function_key, priority);
2427
2428 arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
2429 NULL_TREE);
2430 arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
2431 arguments);
2432 finish_expr_stmt (build_function_call (fndecl, arguments));
2433 }
2434 }
2435
2436 /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
2437 calls to any functions marked with attributes indicating that
2438 they should be called at initialization- or destruction-time. */
2439 if (priority == DEFAULT_INIT_PRIORITY)
2440 {
2441 tree fns;
2442
2443 for (fns = constructor_p ? static_ctors : static_dtors;
2444 fns;
2445 fns = TREE_CHAIN (fns))
2446 {
2447 fndecl = TREE_VALUE (fns);
2448
2449 /* Calls to pure/const functions will expand to nothing. */
2450 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2451 {
2452 if (! body)
2453 body = start_objects (function_key, priority);
2454 finish_expr_stmt (build_function_call (fndecl, NULL_TREE));
2455 }
2456 }
2457 }
2458
2459 /* Close out the function. */
2460 if (body)
2461 finish_objects (function_key, priority, body);
2462 }
2463
2464 /* Generate constructor and destructor functions for the priority
2465 indicated by N. */
2466
2467 static int
generate_ctor_and_dtor_functions_for_priority(splay_tree_node n,void * data)2468 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
2469 {
2470 location_t *locus = data;
2471 int priority = (int) n->key;
2472 priority_info pi = (priority_info) n->value;
2473
2474 /* Generate the functions themselves, but only if they are really
2475 needed. */
2476 if (pi->initializations_p
2477 || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
2478 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
2479 if (pi->destructions_p
2480 || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
2481 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
2482
2483 /* Keep iterating. */
2484 return 0;
2485 }
2486
2487 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
2488 decls referenced from frontend specific constructs; it will be called
2489 only for language-specific tree nodes.
2490
2491 Here we must deal with member pointers. */
2492
2493 tree
cxx_callgraph_analyze_expr(tree * tp,int * walk_subtrees ATTRIBUTE_UNUSED,tree from ATTRIBUTE_UNUSED)2494 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2495 tree from ATTRIBUTE_UNUSED)
2496 {
2497 tree t = *tp;
2498
2499 if (flag_unit_at_a_time)
2500 switch (TREE_CODE (t))
2501 {
2502 case PTRMEM_CST:
2503 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2504 cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
2505 break;
2506 case BASELINK:
2507 if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
2508 cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t)));
2509 break;
2510
2511 default:
2512 break;
2513 }
2514
2515 return NULL;
2516 }
2517
2518 /* This routine is called from the last rule in yyparse ().
2519 Its job is to create all the code needed to initialize and
2520 destroy the global aggregates. We do the destruction
2521 first, since that way we only need to reverse the decls once. */
2522
2523 void
finish_file(void)2524 finish_file (void)
2525 {
2526 tree vars;
2527 bool reconsider;
2528 size_t i;
2529 location_t locus;
2530 unsigned ssdf_count = 0;
2531
2532 locus = input_location;
2533 at_eof = 1;
2534
2535 /* Bad parse errors. Just forget about it. */
2536 if (! global_bindings_p () || current_class_type || decl_namespace_list)
2537 return;
2538
2539 if (pch_file)
2540 c_common_write_pch ();
2541
2542 /* Otherwise, GDB can get confused, because in only knows
2543 about source for LINENO-1 lines. */
2544 input_line -= 1;
2545
2546 interface_unknown = 1;
2547 interface_only = 0;
2548
2549 /* We now have to write out all the stuff we put off writing out.
2550 These include:
2551
2552 o Template specializations that we have not yet instantiated,
2553 but which are needed.
2554 o Initialization and destruction for non-local objects with
2555 static storage duration. (Local objects with static storage
2556 duration are initialized when their scope is first entered,
2557 and are cleaned up via atexit.)
2558 o Virtual function tables.
2559
2560 All of these may cause others to be needed. For example,
2561 instantiating one function may cause another to be needed, and
2562 generating the initializer for an object may cause templates to be
2563 instantiated, etc., etc. */
2564
2565 timevar_push (TV_VARCONST);
2566
2567 emit_support_tinfos ();
2568
2569 do
2570 {
2571 tree t;
2572 size_t n_old, n_new;
2573
2574 reconsider = false;
2575
2576 /* If there are templates that we've put off instantiating, do
2577 them now. */
2578 instantiate_pending_templates ();
2579 ggc_collect ();
2580
2581 /* Write out virtual tables as required. Note that writing out
2582 the virtual table for a template class may cause the
2583 instantiation of members of that class. If we write out
2584 vtables then we remove the class from our list so we don't
2585 have to look at it again. */
2586
2587 while (keyed_classes != NULL_TREE
2588 && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
2589 {
2590 reconsider = true;
2591 keyed_classes = TREE_CHAIN (keyed_classes);
2592 }
2593
2594 t = keyed_classes;
2595 if (t != NULL_TREE)
2596 {
2597 tree next = TREE_CHAIN (t);
2598
2599 while (next)
2600 {
2601 if (maybe_emit_vtables (TREE_VALUE (next)))
2602 {
2603 reconsider = true;
2604 TREE_CHAIN (t) = TREE_CHAIN (next);
2605 }
2606 else
2607 t = next;
2608
2609 next = TREE_CHAIN (t);
2610 }
2611 }
2612
2613 /* Write out needed type info variables. We have to be careful
2614 looping through unemitted decls, because emit_tinfo_decl may
2615 cause other variables to be needed. We stick new elements
2616 (and old elements that we may need to reconsider) at the end
2617 of the array, then shift them back to the beginning once we're
2618 done. */
2619
2620 n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
2621 for (i = 0; i < n_old; ++i)
2622 {
2623 tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
2624 if (emit_tinfo_decl (tinfo_decl))
2625 reconsider = true;
2626 else
2627 VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
2628 }
2629
2630 /* The only elements we want to keep are the new ones. Copy
2631 them to the beginning of the array, then get rid of the
2632 leftovers. */
2633 n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
2634 if (n_new)
2635 memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
2636 &VARRAY_TREE (unemitted_tinfo_decls, n_old),
2637 n_new * sizeof (tree));
2638 memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
2639 0, n_old * sizeof (tree));
2640 VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
2641
2642 /* The list of objects with static storage duration is built up
2643 in reverse order. We clear STATIC_AGGREGATES so that any new
2644 aggregates added during the initialization of these will be
2645 initialized in the correct order when we next come around the
2646 loop. */
2647 vars = prune_vars_needing_no_initialization (&static_aggregates);
2648
2649 if (vars)
2650 {
2651 tree v;
2652
2653 /* We need to start a new initialization function each time
2654 through the loop. That's because we need to know which
2655 vtables have been referenced, and TREE_SYMBOL_REFERENCED
2656 isn't computed until a function is finished, and written
2657 out. That's a deficiency in the back-end. When this is
2658 fixed, these initialization functions could all become
2659 inline, with resulting performance improvements. */
2660 tree ssdf_body;
2661
2662 /* Set the line and file, so that it is obviously not from
2663 the source file. */
2664 input_location = locus;
2665 ssdf_body = start_static_storage_duration_function (ssdf_count);
2666
2667 /* Make sure the back end knows about all the variables. */
2668 write_out_vars (vars);
2669
2670 /* First generate code to do all the initializations. */
2671 for (v = vars; v; v = TREE_CHAIN (v))
2672 do_static_initialization (TREE_VALUE (v),
2673 TREE_PURPOSE (v));
2674
2675 /* Then, generate code to do all the destructions. Do these
2676 in reverse order so that the most recently constructed
2677 variable is the first destroyed. If we're using
2678 __cxa_atexit, then we don't need to do this; functions
2679 were registered at initialization time to destroy the
2680 local statics. */
2681 if (!flag_use_cxa_atexit)
2682 {
2683 vars = nreverse (vars);
2684 for (v = vars; v; v = TREE_CHAIN (v))
2685 do_static_destruction (TREE_VALUE (v));
2686 }
2687 else
2688 vars = NULL_TREE;
2689
2690 /* Finish up the static storage duration function for this
2691 round. */
2692 input_location = locus;
2693 finish_static_storage_duration_function (ssdf_body);
2694
2695 /* All those initializations and finalizations might cause
2696 us to need more inline functions, more template
2697 instantiations, etc. */
2698 reconsider = true;
2699 ssdf_count++;
2700 locus.line++;
2701 }
2702
2703 for (i = 0; i < deferred_fns_used; ++i)
2704 {
2705 tree decl = VARRAY_TREE (deferred_fns, i);
2706
2707 /* Does it need synthesizing? */
2708 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
2709 && TREE_USED (decl)
2710 && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
2711 {
2712 /* Even though we're already at the top-level, we push
2713 there again. That way, when we pop back a few lines
2714 hence, all of our state is restored. Otherwise,
2715 finish_function doesn't clean things up, and we end
2716 up with CURRENT_FUNCTION_DECL set. */
2717 push_to_top_level ();
2718 synthesize_method (decl);
2719 pop_from_top_level ();
2720 reconsider = true;
2721 }
2722
2723 /* If the function has no body, avoid calling
2724 import_export_decl. On a system without weak symbols,
2725 calling import_export_decl will make an inline template
2726 instantiation "static", which will result in errors about
2727 the use of undefined functions if there is no body for
2728 the function. */
2729 if (!DECL_SAVED_TREE (decl))
2730 continue;
2731
2732 import_export_decl (decl);
2733
2734 /* We lie to the back-end, pretending that some functions
2735 are not defined when they really are. This keeps these
2736 functions from being put out unnecessarily. But, we must
2737 stop lying when the functions are referenced, or if they
2738 are not comdat since they need to be put out now. This
2739 is done in a separate for cycle, because if some deferred
2740 function is contained in another deferred function later
2741 in deferred_fns varray, rest_of_compilation would skip
2742 this function and we really cannot expand the same
2743 function twice. */
2744 if (DECL_NOT_REALLY_EXTERN (decl)
2745 && DECL_INITIAL (decl)
2746 && DECL_NEEDED_P (decl))
2747 DECL_EXTERNAL (decl) = 0;
2748
2749 /* If we're going to need to write this function out, and
2750 there's already a body for it, create RTL for it now.
2751 (There might be no body if this is a method we haven't
2752 gotten around to synthesizing yet.) */
2753 if (!DECL_EXTERNAL (decl)
2754 && DECL_NEEDED_P (decl)
2755 && DECL_SAVED_TREE (decl)
2756 && !TREE_ASM_WRITTEN (decl)
2757 && (!flag_unit_at_a_time
2758 || !cgraph_node (decl)->local.finalized))
2759 {
2760 /* We will output the function; no longer consider it in this
2761 loop. */
2762 DECL_DEFER_OUTPUT (decl) = 0;
2763 /* Generate RTL for this function now that we know we
2764 need it. */
2765 expand_or_defer_fn (decl);
2766 /* If we're compiling -fsyntax-only pretend that this
2767 function has been written out so that we don't try to
2768 expand it again. */
2769 if (flag_syntax_only)
2770 TREE_ASM_WRITTEN (decl) = 1;
2771 reconsider = true;
2772 }
2773 }
2774
2775 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
2776 reconsider = true;
2777
2778 /* Static data members are just like namespace-scope globals. */
2779 for (i = 0; i < pending_statics_used; ++i)
2780 {
2781 tree decl = VARRAY_TREE (pending_statics, i);
2782 if (var_finalized_p (decl))
2783 continue;
2784 import_export_decl (decl);
2785 if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
2786 DECL_EXTERNAL (decl) = 0;
2787 }
2788 if (pending_statics
2789 && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
2790 pending_statics_used))
2791 reconsider = true;
2792
2793 if (cgraph_assemble_pending_functions ())
2794 reconsider = true;
2795 }
2796 while (reconsider);
2797
2798 /* All used inline functions must have a definition at this point. */
2799 for (i = 0; i < deferred_fns_used; ++i)
2800 {
2801 tree decl = VARRAY_TREE (deferred_fns, i);
2802
2803 if (TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
2804 && !(TREE_ASM_WRITTEN (decl) || DECL_SAVED_TREE (decl)
2805 /* An explicit instantiation can be used to specify
2806 that the body is in another unit. It will have
2807 already verified there was a definition. */
2808 || DECL_EXPLICIT_INSTANTIATION (decl)))
2809 {
2810 cp_warning_at ("inline function `%D' used but never defined", decl);
2811 /* This symbol is effectively an "extern" declaration now.
2812 This is not strictly necessary, but removes a duplicate
2813 warning. */
2814 TREE_PUBLIC (decl) = 1;
2815 }
2816
2817 }
2818
2819 /* We give C linkage to static constructors and destructors. */
2820 push_lang_context (lang_name_c);
2821
2822 /* Generate initialization and destruction functions for all
2823 priorities for which they are required. */
2824 if (priority_info_map)
2825 splay_tree_foreach (priority_info_map,
2826 generate_ctor_and_dtor_functions_for_priority,
2827 /*data=*/&locus);
2828 else
2829 {
2830
2831 if (static_ctors)
2832 generate_ctor_or_dtor_function (/*constructor_p=*/true,
2833 DEFAULT_INIT_PRIORITY, &locus);
2834 if (static_dtors)
2835 generate_ctor_or_dtor_function (/*constructor_p=*/false,
2836 DEFAULT_INIT_PRIORITY, &locus);
2837 }
2838
2839 /* We're done with the splay-tree now. */
2840 if (priority_info_map)
2841 splay_tree_delete (priority_info_map);
2842
2843 /* We're done with static constructors, so we can go back to "C++"
2844 linkage now. */
2845 pop_lang_context ();
2846
2847 if (flag_unit_at_a_time)
2848 {
2849 cgraph_finalize_compilation_unit ();
2850 cgraph_optimize ();
2851 }
2852
2853 /* Now, issue warnings about static, but not defined, functions,
2854 etc., and emit debugging information. */
2855 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
2856 if (pending_statics)
2857 check_global_declarations (&VARRAY_TREE (pending_statics, 0),
2858 pending_statics_used);
2859
2860 finish_repo ();
2861
2862 /* The entire file is now complete. If requested, dump everything
2863 to a file. */
2864 {
2865 int flags;
2866 FILE *stream = dump_begin (TDI_all, &flags);
2867
2868 if (stream)
2869 {
2870 dump_node (global_namespace, flags & ~TDF_SLIM, stream);
2871 dump_end (TDI_all, stream);
2872 }
2873 }
2874
2875 timevar_pop (TV_VARCONST);
2876
2877 if (flag_detailed_statistics)
2878 {
2879 dump_tree_statistics ();
2880 dump_time_statistics ();
2881 }
2882 input_location = locus;
2883 }
2884
2885 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
2886 function to call in parse-tree form; it has not yet been
2887 semantically analyzed. ARGS are the arguments to the function.
2888 They have already been semantically analyzed. */
2889
2890 tree
build_offset_ref_call_from_tree(tree fn,tree args)2891 build_offset_ref_call_from_tree (tree fn, tree args)
2892 {
2893 tree orig_fn;
2894 tree orig_args;
2895 tree expr;
2896 tree object;
2897
2898 orig_fn = fn;
2899 orig_args = args;
2900 object = TREE_OPERAND (fn, 0);
2901
2902 if (processing_template_decl)
2903 {
2904 my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR
2905 || TREE_CODE (fn) == MEMBER_REF,
2906 20030708);
2907 if (type_dependent_expression_p (fn)
2908 || any_type_dependent_arguments_p (args))
2909 return build_min_nt (CALL_EXPR, fn, args);
2910
2911 /* Transform the arguments and add the implicit "this"
2912 parameter. That must be done before the FN is transformed
2913 because we depend on the form of FN. */
2914 args = build_non_dependent_args (args);
2915 if (TREE_CODE (fn) == DOTSTAR_EXPR)
2916 object = build_unary_op (ADDR_EXPR, object, 0);
2917 object = build_non_dependent_expr (object);
2918 args = tree_cons (NULL_TREE, object, args);
2919 /* Now that the arguments are done, transform FN. */
2920 fn = build_non_dependent_expr (fn);
2921 }
2922
2923 /* A qualified name corresponding to a bound pointer-to-member is
2924 represented as an OFFSET_REF:
2925
2926 struct B { void g(); };
2927 void (B::*p)();
2928 void B::g() { (this->*p)(); } */
2929 if (TREE_CODE (fn) == OFFSET_REF)
2930 {
2931 tree object_addr = build_unary_op (ADDR_EXPR, object, 0);
2932 fn = TREE_OPERAND (fn, 1);
2933 fn = get_member_function_from_ptrfunc (&object_addr, fn);
2934 args = tree_cons (NULL_TREE, object_addr, args);
2935 }
2936
2937 expr = build_function_call (fn, args);
2938 if (processing_template_decl && expr != error_mark_node)
2939 return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args);
2940 return expr;
2941 }
2942
2943
2944 void
check_default_args(tree x)2945 check_default_args (tree x)
2946 {
2947 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
2948 bool saw_def = false;
2949 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
2950 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
2951 {
2952 if (TREE_PURPOSE (arg))
2953 saw_def = true;
2954 else if (saw_def)
2955 {
2956 cp_error_at ("default argument missing for parameter %P of `%+#D'",
2957 i, x);
2958 break;
2959 }
2960 }
2961 }
2962
2963 void
mark_used(tree decl)2964 mark_used (tree decl)
2965 {
2966 TREE_USED (decl) = 1;
2967 if (processing_template_decl || skip_evaluation)
2968 return;
2969
2970 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
2971 && !TREE_ASM_WRITTEN (decl))
2972 /* Remember it, so we can check it was defined. */
2973 defer_fn (decl);
2974
2975 assemble_external (decl);
2976
2977 /* Is it a synthesized method that needs to be synthesized? */
2978 if (TREE_CODE (decl) == FUNCTION_DECL
2979 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
2980 && DECL_ARTIFICIAL (decl)
2981 && !DECL_THUNK_P (decl)
2982 && ! DECL_INITIAL (decl)
2983 /* Kludge: don't synthesize for default args. */
2984 && current_function_decl)
2985 {
2986 synthesize_method (decl);
2987 /* If we've already synthesized the method we don't need to
2988 instantiate it, so we can return right away. */
2989 return;
2990 }
2991
2992 /* If this is a function or variable that is an instance of some
2993 template, we now know that we will need to actually do the
2994 instantiation. We check that DECL is not an explicit
2995 instantiation because that is not checked in instantiate_decl. */
2996 if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
2997 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
2998 && (!DECL_EXPLICIT_INSTANTIATION (decl)
2999 || (TREE_CODE (decl) == FUNCTION_DECL
3000 && DECL_INLINE (DECL_TEMPLATE_RESULT
3001 (template_for_substitution (decl))))))
3002 {
3003 bool defer;
3004
3005 /* Normally, we put off instantiating functions in order to
3006 improve compile times. Maintaining a stack of active
3007 functions is expensive, and the inliner knows to
3008 instantiate any functions it might need.
3009
3010 However, if instantiating this function might help us mark
3011 the current function TREE_NOTHROW, we go ahead and
3012 instantiate it now.
3013
3014 This is not needed for unit-at-a-time since we reorder the functions
3015 in topological order anyway.
3016 */
3017 defer = (!flag_exceptions
3018 || flag_unit_at_a_time
3019 || !optimize
3020 || TREE_CODE (decl) != FUNCTION_DECL
3021 /* If the called function can't throw, we don't need to
3022 generate its body to find that out. */
3023 || TREE_NOTHROW (decl)
3024 || !cfun
3025 || !current_function_decl
3026 /* If we already know the current function can't throw,
3027 then we don't need to work hard to prove it. */
3028 || TREE_NOTHROW (current_function_decl)
3029 /* If we already know that the current function *can*
3030 throw, there's no point in gathering more
3031 information. */
3032 || cp_function_chain->can_throw);
3033
3034 instantiate_decl (decl, defer);
3035 }
3036 }
3037
3038 #include "gt-cp-decl2.h"
3039