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)
6 This file is part of GCC.
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)
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.
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. */
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. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
48 #include "tree-mudflap.h"
50 #include "tree-inline.h"
52 extern cpp_reader *parse_in;
54 /* This structure contains information about the initializations
55 and/or destructions required for a particular priority level. */
56 typedef struct priority_info_s {
57 /* Nonzero if there have been any initializations at this priority
58 throughout the translation unit. */
59 int initializations_p;
60 /* Nonzero if there have been any destructions at this priority
61 throughout the translation unit. */
65 static void mark_vtable_entries (tree);
66 static void grok_function_init (tree, tree);
67 static bool maybe_emit_vtables (tree);
68 static tree build_anon_union_vars (tree);
69 static bool acceptable_java_type (tree);
70 static tree start_objects (int, int);
71 static void finish_objects (int, int, tree);
72 static tree start_static_storage_duration_function (unsigned);
73 static void finish_static_storage_duration_function (tree);
74 static priority_info get_priority_info (int);
75 static void do_static_initialization (tree, tree);
76 static void do_static_destruction (tree);
77 static tree start_static_initialization_or_destruction (tree, int);
78 static void finish_static_initialization_or_destruction (tree);
79 static void generate_ctor_or_dtor_function (bool, int, location_t *);
80 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
82 static tree prune_vars_needing_no_initialization (tree *);
83 static void write_out_vars (tree);
84 static void import_export_class (tree);
85 static tree get_guard_bits (tree);
87 /* A list of static class variables. This is needed, because a
88 static class variable can be declared inside the class without
89 an initializer, and then initialized, statically, outside the class. */
90 static GTY(()) varray_type pending_statics;
91 #define pending_statics_used \
92 (pending_statics ? pending_statics->elements_used : 0)
94 /* A list of functions which were declared inline, but which we
95 may need to emit outline anyway. */
96 static GTY(()) varray_type deferred_fns;
97 #define deferred_fns_used \
98 (deferred_fns ? deferred_fns->elements_used : 0)
100 /* Flag used when debugging spew.c */
102 extern int spew_debug;
104 /* Nonzero if we're done parsing and into end-of-file activities. */
108 /* Functions called along with real static constructors and destructors. */
114 /* Incorporate `const' and `volatile' qualifiers for member functions.
115 FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
116 QUALS is a list of qualifiers. Returns any explicit
117 top-level qualifiers of the method's this pointer, anything other than
118 TYPE_UNQUALIFIED will be an extension. */
121 grok_method_quals (tree ctype, tree function, tree quals)
123 tree fntype = TREE_TYPE (function);
124 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
125 int type_quals = TYPE_UNQUALIFIED;
126 int dup_quals = TYPE_UNQUALIFIED;
127 int this_quals = TYPE_UNQUALIFIED;
131 int tq = cp_type_qual_from_rid (TREE_VALUE (quals));
133 if ((type_quals | this_quals) & tq)
135 else if (tq & TYPE_QUAL_RESTRICT)
139 quals = TREE_CHAIN (quals);
142 if (dup_quals != TYPE_UNQUALIFIED)
143 error ("duplicate type qualifiers in %s declaration",
144 TREE_CODE (function) == FUNCTION_DECL
145 ? "member function" : "type");
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)));
153 fntype = build_exception_variant (fntype, raises);
155 TREE_TYPE (function) = fntype;
159 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
163 cp_build_parm_decl (tree name, tree type)
165 tree parm = build_decl (PARM_DECL, name, type);
166 /* DECL_ARG_TYPE is only used by the back end and the back end never
168 if (!processing_template_decl)
169 DECL_ARG_TYPE (parm) = type_passed_as (type);
173 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
177 build_artificial_parm (tree name, tree type)
179 tree parm = cp_build_parm_decl (name, type);
180 DECL_ARTIFICIAL (parm) = 1;
181 /* All our artificial parms are implicitly `const'; they cannot be
183 TREE_READONLY (parm) = 1;
187 /* Constructors for types with virtual baseclasses need an "in-charge" flag
188 saying whether this constructor is responsible for initialization of
189 virtual baseclasses or not. All destructors also need this "in-charge"
190 flag, which additionally determines whether or not the destructor should
191 free the memory for the object.
193 This function adds the "in-charge" flag to member function FN if
194 appropriate. It is called from grokclassfn and tsubst.
195 FN must be either a constructor or destructor.
197 The in-charge flag follows the 'this' parameter, and is followed by the
198 VTT parm (if any), then the user-written parms. */
201 maybe_retrofit_in_chrg (tree fn)
203 tree basetype, arg_types, parms, parm, fntype;
205 /* If we've already add the in-charge parameter don't do it again. */
206 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
209 /* When processing templates we can't know, in general, whether or
210 not we're going to have virtual baseclasses. */
211 if (processing_template_decl)
214 /* We don't need an in-charge parameter for constructors that don't
215 have virtual bases. */
216 if (DECL_CONSTRUCTOR_P (fn)
217 && !TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
220 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
221 basetype = TREE_TYPE (TREE_VALUE (arg_types));
222 arg_types = TREE_CHAIN (arg_types);
224 parms = TREE_CHAIN (DECL_ARGUMENTS (fn));
226 /* If this is a subobject constructor or destructor, our caller will
227 pass us a pointer to our VTT. */
228 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
230 parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
232 /* First add it to DECL_ARGUMENTS between 'this' and the real args... */
233 TREE_CHAIN (parm) = parms;
236 /* ...and then to TYPE_ARG_TYPES. */
237 arg_types = hash_tree_chain (vtt_parm_type, arg_types);
239 DECL_HAS_VTT_PARM_P (fn) = 1;
242 /* Then add the in-charge parm (before the VTT parm). */
243 parm = build_artificial_parm (in_charge_identifier, integer_type_node);
244 TREE_CHAIN (parm) = parms;
246 arg_types = hash_tree_chain (integer_type_node, arg_types);
248 /* Insert our new parameter(s) into the list. */
249 TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms;
251 /* And rebuild the function type. */
252 fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
254 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
255 fntype = build_exception_variant (fntype,
256 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
257 TREE_TYPE (fn) = fntype;
259 /* Now we've got the in-charge parameter. */
260 DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
263 /* Classes overload their constituent function names automatically.
264 When a function name is declared in a record structure,
265 its name is changed to it overloaded name. Since names for
266 constructors and destructors can conflict, we place a leading
269 CNAME is the name of the class we are grokking for.
271 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
273 FLAGS contains bits saying what's special about today's
274 arguments. 1 == DESTRUCTOR. 2 == OPERATOR.
276 If FUNCTION is a destructor, then we must add the `auto-delete' field
277 as a second parameter. There is some hair associated with the fact
278 that we must "declare" this variable in the manner consistent with the
279 way the rest of the arguments were declared.
281 QUALS are the qualifiers for the this pointer. */
284 grokclassfn (tree ctype, tree function, enum overload_flags flags, tree quals)
286 tree fn_name = DECL_NAME (function);
287 int this_quals = TYPE_UNQUALIFIED;
289 /* Even within an `extern "C"' block, members get C++ linkage. See
290 [dcl.link] for details. */
291 SET_DECL_LANGUAGE (function, lang_cplusplus);
293 if (fn_name == NULL_TREE)
295 error ("name missing for member function");
296 fn_name = get_identifier ("<anonymous>");
297 DECL_NAME (function) = fn_name;
301 this_quals = grok_method_quals (ctype, function, quals);
303 if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
305 /* Must add the class instance variable up front. */
306 /* Right now we just make this a pointer. But later
307 we may wish to make it special. */
308 tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (function)));
312 /* The `this' parameter is implicitly `const'; it cannot be
314 this_quals |= TYPE_QUAL_CONST;
315 qual_type = cp_build_qualified_type (type, this_quals);
316 parm = build_artificial_parm (this_identifier, qual_type);
317 c_apply_type_quals_to_decl (this_quals, parm);
318 TREE_CHAIN (parm) = DECL_ARGUMENTS (function);
319 DECL_ARGUMENTS (function) = parm;
322 DECL_CONTEXT (function) = ctype;
324 if (flags == DTOR_FLAG)
325 DECL_DESTRUCTOR_P (function) = 1;
327 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
328 maybe_retrofit_in_chrg (function);
331 /* Create an ARRAY_REF, checking for the user doing things backwards
335 grok_array_decl (tree array_expr, tree index_exp)
339 tree orig_array_expr = array_expr;
340 tree orig_index_exp = index_exp;
342 if (error_operand_p (array_expr) || error_operand_p (index_exp))
343 return error_mark_node;
345 if (processing_template_decl)
347 if (type_dependent_expression_p (array_expr)
348 || type_dependent_expression_p (index_exp))
349 return build_min_nt (ARRAY_REF, array_expr, index_exp,
350 NULL_TREE, NULL_TREE);
351 array_expr = build_non_dependent_expr (array_expr);
352 index_exp = build_non_dependent_expr (index_exp);
355 type = TREE_TYPE (array_expr);
356 my_friendly_assert (type, 20030626);
357 type = non_reference (type);
359 /* If they have an `operator[]', use that. */
360 if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))
361 expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
362 array_expr, index_exp, NULL_TREE,
363 /*overloaded_p=*/NULL);
368 /* Otherwise, create an ARRAY_REF for a pointer or array type.
369 It is a little-known fact that, if `a' is an array and `i' is
370 an int, you can write `i[a]', which means the same thing as
372 if (TREE_CODE (type) == ARRAY_TYPE)
375 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
377 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
380 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
382 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
384 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
387 if ((p1 && i2) && (i1 && p2))
388 error ("ambiguous conversion for array subscript");
391 array_expr = p1, index_exp = i2;
393 array_expr = p2, index_exp = i1;
396 error ("invalid types `%T[%T]' for array subscript",
397 type, TREE_TYPE (index_exp));
398 return error_mark_node;
401 if (array_expr == error_mark_node || index_exp == error_mark_node)
402 error ("ambiguous conversion for array subscript");
404 expr = build_array_ref (array_expr, index_exp);
406 if (processing_template_decl && expr != error_mark_node)
407 return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
408 NULL_TREE, NULL_TREE);
412 /* Given the cast expression EXP, checking out its validity. Either return
413 an error_mark_node if there was an unavoidable error, return a cast to
414 void for trying to delete a pointer w/ the value 0, or return the
415 call to delete. If DOING_VEC is true, we handle things differently
416 for doing an array delete.
417 Implements ARM $5.3.4. This is called from the parser. */
420 delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete)
424 if (exp == error_mark_node)
427 if (processing_template_decl)
429 t = build_min (DELETE_EXPR, void_type_node, exp, size);
430 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
431 DELETE_EXPR_USE_VEC (t) = doing_vec;
432 TREE_SIDE_EFFECTS (t) = 1;
436 exp = convert_from_reference (exp);
438 /* An array can't have been allocated by new, so complain. */
439 if (TREE_CODE (exp) == VAR_DECL
440 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
441 warning ("deleting array `%#D'", exp);
443 t = build_expr_type_conversion (WANT_POINTER, exp, true);
445 if (t == NULL_TREE || t == error_mark_node)
447 error ("type `%#T' argument given to `delete', expected pointer",
449 return error_mark_node;
452 type = TREE_TYPE (t);
454 /* As of Valley Forge, you can delete a pointer to const. */
456 /* You can't delete functions. */
457 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
459 error ("cannot delete a function. Only pointer-to-objects are valid arguments to `delete'");
460 return error_mark_node;
463 /* Deleting ptr to void is undefined behavior [expr.delete/3]. */
464 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
466 warning ("deleting `%T' is undefined", type);
470 /* Deleting a pointer with the value zero is valid and has no effect. */
471 if (integer_zerop (t))
472 return build1 (NOP_EXPR, void_type_node, t);
475 return build_vec_delete (t, /*maxindex=*/NULL_TREE,
476 sfk_deleting_destructor,
479 return build_delete (type, t, sfk_deleting_destructor,
480 LOOKUP_NORMAL, use_global_delete);
483 /* Report an error if the indicated template declaration is not the
484 sort of thing that should be a member template. */
487 check_member_template (tree tmpl)
491 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
492 decl = DECL_TEMPLATE_RESULT (tmpl);
494 if (TREE_CODE (decl) == FUNCTION_DECL
495 || (TREE_CODE (decl) == TYPE_DECL
496 && IS_AGGR_TYPE (TREE_TYPE (decl))))
498 if (current_function_decl)
499 /* 14.5.2.2 [temp.mem]
501 A local class shall not have member templates. */
502 error ("invalid declaration of member template `%#D' in local class",
505 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
507 /* 14.5.2.3 [temp.mem]
509 A member function template shall not be virtual. */
511 ("invalid use of `virtual' in template declaration of `%#D'",
513 DECL_VIRTUAL_P (decl) = 0;
516 /* The debug-information generating code doesn't know what to do
517 with member templates. */
518 DECL_IGNORED_P (tmpl) = 1;
521 error ("template declaration of `%#D'", decl);
524 /* Return true iff TYPE is a valid Java parameter or return type. */
527 acceptable_java_type (tree type)
529 if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
531 if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
533 type = TREE_TYPE (type);
534 if (TREE_CODE (type) == RECORD_TYPE)
537 if (! TYPE_FOR_JAVA (type))
539 if (! CLASSTYPE_TEMPLATE_INFO (type))
541 args = CLASSTYPE_TI_ARGS (type);
542 i = TREE_VEC_LENGTH (args);
545 type = TREE_VEC_ELT (args, i);
546 if (TREE_CODE (type) == POINTER_TYPE)
547 type = TREE_TYPE (type);
548 if (! TYPE_FOR_JAVA (type))
557 /* For a METHOD in a Java class CTYPE, return true if
558 the parameter and return types are valid Java types.
559 Otherwise, print appropriate error messages, and return false. */
562 check_java_method (tree method)
565 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
566 tree ret_type = TREE_TYPE (TREE_TYPE (method));
568 if (!acceptable_java_type (ret_type))
570 error ("Java method '%D' has non-Java return type `%T'",
575 arg_types = TREE_CHAIN (arg_types);
576 if (DECL_HAS_IN_CHARGE_PARM_P (method))
577 arg_types = TREE_CHAIN (arg_types);
578 if (DECL_HAS_VTT_PARM_P (method))
579 arg_types = TREE_CHAIN (arg_types);
581 for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
583 tree type = TREE_VALUE (arg_types);
584 if (!acceptable_java_type (type))
586 error ("Java method '%D' has non-Java parameter type `%T'",
594 /* Sanity check: report error if this function FUNCTION is not
595 really a member of the class (CTYPE) it is supposed to belong to.
596 TEMPLATE_PARMS is used to specifiy the template parameters of a member
597 template passed as FUNCTION_DECL. If the member template is passed as a
598 TEMPLATE_DECL, it can be NULL since the parameters can be extracted
599 from the declaration. If the function is not a function template, it
601 It returns the original declaration for the function, or NULL_TREE
602 if no declaration was found (and an error was emitted). */
605 check_classfn (tree ctype, tree function, tree template_parms)
610 if (DECL_USE_TEMPLATE (function)
611 && !(TREE_CODE (function) == TEMPLATE_DECL
612 && DECL_TEMPLATE_SPECIALIZATION (function))
613 && is_member_template (DECL_TI_TEMPLATE (function)))
614 /* Since this is a specialization of a member template,
615 we're not going to find the declaration in the class.
618 struct S { template <typename T> void f(T); };
619 template <> void S::f(int);
621 we're not going to find `S::f(int)', but there's no
622 reason we should, either. We let our callers know we didn't
623 find the method, but we don't complain. */
626 /* Basic sanity check: for a template function, the template parameters
627 either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */
628 if (TREE_CODE (function) == TEMPLATE_DECL)
630 my_friendly_assert (!template_parms
631 || comp_template_parms
633 DECL_TEMPLATE_PARMS (function)),
635 template_parms = DECL_TEMPLATE_PARMS (function);
638 /* OK, is this a definition of a member template? */
639 is_template = (template_parms != NULL_TREE);
641 ix = lookup_fnfields_1 (complete_type (ctype),
642 DECL_CONSTRUCTOR_P (function) ? ctor_identifier :
643 DECL_DESTRUCTOR_P (function) ? dtor_identifier :
644 DECL_NAME (function));
648 tree methods = CLASSTYPE_METHOD_VEC (ctype);
649 tree fndecls, fndecl = 0;
652 const char *format = NULL;
654 pop_p = push_scope (ctype);
655 for (fndecls = TREE_VEC_ELT (methods, ix);
656 fndecls; fndecls = OVL_NEXT (fndecls))
660 fndecl = OVL_CURRENT (fndecls);
661 p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
662 p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
664 /* We cannot simply call decls_match because this doesn't
665 work for static member functions that are pretending to
666 be methods, and because the name may have been changed by
669 /* Get rid of the this parameter on functions that become
671 if (DECL_STATIC_FUNCTION_P (fndecl)
672 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
673 p1 = TREE_CHAIN (p1);
675 /* A member template definition only matches a member template
677 if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
680 if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
681 TREE_TYPE (TREE_TYPE (fndecl)))
682 && compparms (p1, p2)
684 || comp_template_parms (template_parms,
685 DECL_TEMPLATE_PARMS (fndecl)))
686 && (DECL_TEMPLATE_SPECIALIZATION (function)
687 == DECL_TEMPLATE_SPECIALIZATION (fndecl))
688 && (!DECL_TEMPLATE_SPECIALIZATION (function)
689 || (DECL_TI_TEMPLATE (function)
690 == DECL_TI_TEMPLATE (fndecl))))
696 return OVL_CURRENT (fndecls);
697 error ("prototype for `%#D' does not match any in class `%T'",
699 is_conv_op = DECL_CONV_FN_P (fndecl);
702 ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
703 fndecls = TREE_VEC_ELT (methods, ix);
706 fndecl = OVL_CURRENT (fndecls);
707 fndecls = OVL_NEXT (fndecls);
709 if (!fndecls && is_conv_op)
711 if (TREE_VEC_LENGTH (methods) > ix)
714 fndecls = TREE_VEC_ELT (methods, ix);
715 if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
727 format = "candidates are: %#D";
729 format = "candidate is: %#D";
730 cp_error_at (format, fndecl);
733 else if (!COMPLETE_TYPE_P (ctype))
734 cxx_incomplete_type_error (function, ctype);
736 error ("no `%#D' member function declared in class `%T'",
739 /* If we did not find the method in the class, add it to avoid
740 spurious errors (unless the CTYPE is not yet defined, in which
741 case we'll only confuse ourselves when the function is declared
742 properly within the class. */
743 if (COMPLETE_TYPE_P (ctype))
744 add_method (ctype, function, /*error_p=*/1);
748 /* We have just processed the DECL, which is a static data member.
749 Its initializer, if present, is INIT. The ASMSPEC_TREE, if
750 present, is the assembly-language name for the data member.
751 FLAGS is as for cp_finish_decl. */
754 finish_static_data_member_decl (tree decl, tree init, tree asmspec_tree,
757 my_friendly_assert (TREE_PUBLIC (decl), 0);
759 DECL_CONTEXT (decl) = current_class_type;
761 /* We cannot call pushdecl here, because that would fill in the
762 TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
763 the right thing, namely, to put this decl out straight away. */
764 /* current_class_type can be NULL_TREE in case of error. */
765 if (!asmspec_tree && current_class_type)
766 DECL_INITIAL (decl) = error_mark_node;
768 if (! processing_template_decl)
770 if (!pending_statics)
771 VARRAY_TREE_INIT (pending_statics, 32, "pending_statics");
772 VARRAY_PUSH_TREE (pending_statics, decl);
775 if (LOCAL_CLASS_P (current_class_type))
776 pedwarn ("local class `%#T' shall not have static data member `%#D'",
777 current_class_type, decl);
779 /* Static consts need not be initialized in the class definition. */
780 if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
782 static int explained = 0;
784 error ("initializer invalid for static member with constructor");
787 error ("(an out of class initialization is required)");
792 /* Force the compiler to know when an uninitialized static const
793 member is being used. */
794 if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0)
795 TREE_USED (decl) = 1;
796 DECL_INITIAL (decl) = init;
797 DECL_IN_AGGR_P (decl) = 1;
799 cp_finish_decl (decl, init, asmspec_tree, flags);
802 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
803 of a structure component, returning a _DECL node.
804 QUALS is a list of type qualifiers for this decl (such as for declaring
805 const member functions).
807 This is done during the parsing of the struct declaration.
808 The _DECL nodes are chained together and the lot of them
809 are ultimately passed to `build_struct' to make the RECORD_TYPE node.
811 If class A defines that certain functions in class B are friends, then
812 the way I have set things up, it is B who is interested in permission
813 granted by A. However, it is in A's context that these declarations
814 are parsed. By returning a void_type_node, class A does not attempt
815 to incorporate the declarations of the friends within its structure.
817 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
818 CHANGES TO CODE IN `start_method'. */
821 grokfield (const cp_declarator *declarator,
822 cp_decl_specifier_seq *declspecs,
823 tree init, tree asmspec_tree,
827 const char *asmspec = 0;
828 int flags = LOOKUP_ONLYCONVERTING;
830 if (!declspecs->any_specifiers_p
831 && declarator->kind == cdk_id
832 && TREE_CODE (declarator->u.id.name) == SCOPE_REF
833 && (TREE_CODE (TREE_OPERAND (declarator->u.id.name, 1))
836 /* Access declaration */
837 if (! IS_AGGR_TYPE_CODE (TREE_CODE
838 (TREE_OPERAND (declarator->u.id.name, 0))))
840 else if (TREE_COMPLEXITY (declarator->u.id.name) == current_class_depth)
842 return do_class_using_decl (declarator->u.id.name);
846 && TREE_CODE (init) == TREE_LIST
847 && TREE_VALUE (init) == error_mark_node
848 && TREE_CHAIN (init) == NULL_TREE)
851 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
852 if (! value || error_operand_p (value))
853 /* friend or constructor went bad. */
854 return error_mark_node;
856 if (TREE_CODE (value) == TYPE_DECL && init)
858 error ("typedef `%D' is initialized (use __typeof__ instead)", value);
862 /* Pass friendly classes back. */
863 if (value == void_type_node)
866 /* Pass friend decls back. */
867 if ((TREE_CODE (value) == FUNCTION_DECL
868 || TREE_CODE (value) == TEMPLATE_DECL)
869 && DECL_CONTEXT (value) != current_class_type)
872 if (DECL_NAME (value) != NULL_TREE
873 && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
874 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
875 error ("member `%D' conflicts with virtual function table field name",
878 /* Stash away type declarations. */
879 if (TREE_CODE (value) == TYPE_DECL)
881 DECL_NONLOCAL (value) = 1;
882 DECL_CONTEXT (value) = current_class_type;
884 if (processing_template_decl)
885 value = push_template_decl (value);
890 if (DECL_IN_AGGR_P (value))
892 error ("`%D' is already defined in `%T'", value,
893 DECL_CONTEXT (value));
894 return void_type_node;
898 asmspec = TREE_STRING_POINTER (asmspec_tree);
902 if (TREE_CODE (value) == FUNCTION_DECL)
904 grok_function_init (value, init);
907 else if (pedantic && TREE_CODE (value) != VAR_DECL)
908 /* Already complained in grokdeclarator. */
912 /* We allow initializers to become parameters to base
914 if (TREE_CODE (init) == TREE_LIST)
916 if (TREE_CHAIN (init) == NULL_TREE)
917 init = TREE_VALUE (init);
919 init = digest_init (TREE_TYPE (value), init, (tree *)0);
922 if (!processing_template_decl)
924 if (TREE_CODE (init) == CONST_DECL)
925 init = DECL_INITIAL (init);
926 else if (TREE_READONLY_DECL_P (init))
927 init = decl_constant_value (init);
928 else if (TREE_CODE (init) == CONSTRUCTOR)
929 init = digest_init (TREE_TYPE (value), init, (tree *)0);
930 if (init != error_mark_node && ! TREE_CONSTANT (init))
932 /* We can allow references to things that are effectively
933 static, since references are initialized with the
935 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
936 || (TREE_STATIC (init) == 0
937 && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
939 error ("field initializer is not constant");
940 init = error_mark_node;
947 if (processing_template_decl
948 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
950 value = push_template_decl (value);
951 if (error_operand_p (value))
952 return error_mark_node;
956 cplus_decl_attributes (&value, attrlist, 0);
958 if (TREE_CODE (value) == VAR_DECL)
960 finish_static_data_member_decl (value, init, asmspec_tree,
964 if (TREE_CODE (value) == FIELD_DECL)
967 error ("`asm' specifiers are not permitted on non-static data members");
968 if (DECL_INITIAL (value) == error_mark_node)
969 init = error_mark_node;
970 cp_finish_decl (value, init, NULL_TREE, flags);
971 DECL_INITIAL (value) = init;
972 DECL_IN_AGGR_P (value) = 1;
975 if (TREE_CODE (value) == FUNCTION_DECL)
979 /* This must override the asm specifier which was placed
980 by grokclassfn. Lay this out fresh. */
981 SET_DECL_RTL (value, NULL_RTX);
982 change_decl_assembler_name (value, get_identifier (asmspec));
984 if (!DECL_FRIEND_P (value))
985 grok_special_member_properties (value);
987 cp_finish_decl (value, init, asmspec_tree, flags);
989 /* Pass friends back this way. */
990 if (DECL_FRIEND_P (value))
991 return void_type_node;
993 DECL_IN_AGGR_P (value) = 1;
1001 /* Like `grokfield', but for bitfields.
1002 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1005 grokbitfield (const cp_declarator *declarator,
1006 cp_decl_specifier_seq *declspecs, tree width)
1008 tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, NULL);
1010 if (! value) return NULL_TREE; /* friends went bad. */
1012 /* Pass friendly classes back. */
1013 if (TREE_CODE (value) == VOID_TYPE)
1014 return void_type_node;
1016 if (TREE_CODE (value) == TYPE_DECL)
1018 error ("cannot declare `%D' to be a bit-field type", value);
1022 /* Usually, finish_struct_1 catches bitfields with invalid types.
1023 But, in the case of bitfields with function type, we confuse
1024 ourselves into thinking they are member functions, so we must
1026 if (TREE_CODE (value) == FUNCTION_DECL)
1028 error ("cannot declare bit-field `%D' with function type",
1033 if (DECL_IN_AGGR_P (value))
1035 error ("`%D' is already defined in the class %T", value,
1036 DECL_CONTEXT (value));
1037 return void_type_node;
1040 if (TREE_STATIC (value))
1042 error ("static member `%D' cannot be a bit-field", value);
1045 cp_finish_decl (value, NULL_TREE, NULL_TREE, 0);
1047 if (width != error_mark_node)
1049 constant_expression_warning (width);
1050 DECL_INITIAL (value) = width;
1051 SET_DECL_C_BIT_FIELD (value);
1054 DECL_IN_AGGR_P (value) = 1;
1058 /* When a function is declared with an initializer,
1059 do the right thing. Currently, there are two possibilities:
1064 // initialization possibility #1.
1065 virtual void f () = 0;
1087 // initialization possibility #2
1094 grok_function_init (tree decl, tree init)
1096 /* An initializer for a function tells how this function should
1098 tree type = TREE_TYPE (decl);
1100 if (TREE_CODE (type) == FUNCTION_TYPE)
1101 error ("initializer specified for non-member function `%D'", decl);
1102 else if (integer_zerop (init))
1103 DECL_PURE_VIRTUAL_P (decl) = 1;
1105 error ("invalid initializer for virtual method `%D'", decl);
1109 cplus_decl_attributes (tree *decl, tree attributes, int flags)
1111 if (*decl == NULL_TREE || *decl == void_type_node)
1114 if (TREE_CODE (*decl) == TEMPLATE_DECL)
1115 decl = &DECL_TEMPLATE_RESULT (*decl);
1117 decl_attributes (decl, attributes, flags);
1119 if (TREE_CODE (*decl) == TYPE_DECL)
1120 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1123 /* Walks through the namespace- or function-scope anonymous union OBJECT,
1124 building appropriate ALIAS_DECLs. Returns one of the fields for use in
1125 the mangled name. */
1128 build_anon_union_vars (tree object)
1130 tree type = TREE_TYPE (object);
1131 tree main_decl = NULL_TREE;
1134 /* Rather than write the code to handle the non-union case,
1135 just give an error. */
1136 if (TREE_CODE (type) != UNION_TYPE)
1137 error ("anonymous struct not inside named type");
1139 for (field = TYPE_FIELDS (type);
1141 field = TREE_CHAIN (field))
1146 if (DECL_ARTIFICIAL (field))
1148 if (TREE_CODE (field) != FIELD_DECL)
1151 `%#D' invalid; an anonymous union can only have non-static data members",
1156 if (TREE_PRIVATE (field))
1157 cp_pedwarn_at ("private member `%#D' in anonymous union", field);
1158 else if (TREE_PROTECTED (field))
1159 cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
1161 if (processing_template_decl)
1162 ref = build_min_nt (COMPONENT_REF, object,
1163 DECL_NAME (field), NULL_TREE);
1165 ref = build_class_member_access_expr (object, field, NULL_TREE,
1168 if (DECL_NAME (field))
1170 decl = build_decl (ALIAS_DECL, DECL_NAME (field), TREE_TYPE (field));
1171 DECL_INITIAL (decl) = ref;
1172 TREE_PUBLIC (decl) = 0;
1173 TREE_STATIC (decl) = 0;
1174 DECL_EXTERNAL (decl) = 1;
1175 decl = pushdecl (decl);
1177 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1178 decl = build_anon_union_vars (ref);
1182 if (main_decl == NULL_TREE)
1189 /* Finish off the processing of a UNION_TYPE structure. If the union is an
1190 anonymous union, then all members must be laid out together. PUBLIC_P
1191 is nonzero if this union is not declared static. */
1194 finish_anon_union (tree anon_union_decl)
1196 tree type = TREE_TYPE (anon_union_decl);
1198 bool public_p = TREE_PUBLIC (anon_union_decl);
1200 /* The VAR_DECL's context is the same as the TYPE's context. */
1201 DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1203 if (TYPE_FIELDS (type) == NULL_TREE)
1208 error ("namespace-scope anonymous aggregates must be static");
1212 main_decl = build_anon_union_vars (anon_union_decl);
1213 if (main_decl == NULL_TREE)
1215 warning ("anonymous union with no members");
1219 if (!processing_template_decl)
1221 /* Use main_decl to set the mangled name. */
1222 DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
1223 mangle_decl (anon_union_decl);
1224 DECL_NAME (anon_union_decl) = NULL_TREE;
1227 pushdecl (anon_union_decl);
1228 if (building_stmt_tree ()
1229 && at_function_scope_p ())
1230 add_decl_stmt (anon_union_decl);
1231 else if (!processing_template_decl)
1232 rest_of_decl_compilation (anon_union_decl, NULL,
1233 toplevel_bindings_p (), at_eof);
1236 /* Auxiliary functions to make type signatures for
1237 `operator new' and `operator delete' correspond to
1238 what compiler will be expecting. */
1241 coerce_new_type (tree type)
1244 tree args = TYPE_ARG_TYPES (type);
1246 my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
1248 if (!same_type_p (TREE_TYPE (type), ptr_type_node))
1249 e = 1, error ("`operator new' must return type `%T'", ptr_type_node);
1251 if (!args || args == void_list_node
1252 || !same_type_p (TREE_VALUE (args), size_type_node))
1255 if (args && args != void_list_node)
1256 args = TREE_CHAIN (args);
1257 pedwarn ("`operator new' takes type `size_t' (`%T') as first parameter", size_type_node);
1262 args = tree_cons (NULL_TREE, size_type_node, args);
1265 type = build_exception_variant
1266 (build_function_type (ptr_type_node, args),
1267 TYPE_RAISES_EXCEPTIONS (type));
1275 coerce_delete_type (tree type)
1278 tree args = TYPE_ARG_TYPES (type);
1280 my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
1282 if (!same_type_p (TREE_TYPE (type), void_type_node))
1283 e = 1, error ("`operator delete' must return type `%T'", void_type_node);
1285 if (!args || args == void_list_node
1286 || !same_type_p (TREE_VALUE (args), ptr_type_node))
1289 if (args && args != void_list_node)
1290 args = TREE_CHAIN (args);
1291 error ("`operator delete' takes type `%T' as first parameter", ptr_type_node);
1296 args = tree_cons (NULL_TREE, ptr_type_node, args);
1299 type = build_exception_variant
1300 (build_function_type (void_type_node, args),
1301 TYPE_RAISES_EXCEPTIONS (type));
1310 mark_vtable_entries (tree decl)
1312 tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
1314 for (; entries; entries = TREE_CHAIN (entries))
1316 tree fnaddr = TREE_VALUE (entries);
1319 STRIP_NOPS (fnaddr);
1321 if (TREE_CODE (fnaddr) != ADDR_EXPR
1322 && TREE_CODE (fnaddr) != FDESC_EXPR)
1323 /* This entry is an offset: a virtual base class offset, a
1324 virtual call offset, an RTTI offset, etc. */
1327 fn = TREE_OPERAND (fnaddr, 0);
1328 TREE_ADDRESSABLE (fn) = 1;
1329 /* When we don't have vcall offsets, we output thunks whenever
1330 we output the vtables that contain them. With vcall offsets,
1331 we know all the thunks we'll need when we emit a virtual
1332 function, so we emit the thunks there instead. */
1333 if (DECL_THUNK_P (fn))
1334 use_thunk (fn, /*emit_p=*/0);
1339 /* Set DECL up to have the closest approximation of "initialized common"
1340 linkage available. */
1343 comdat_linkage (tree decl)
1346 make_decl_one_only (decl);
1347 else if (TREE_CODE (decl) == FUNCTION_DECL
1348 || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1349 /* We can just emit function and compiler-generated variables
1350 statically; having multiple copies is (for the most part) only
1353 There are two correctness issues, however: the address of a
1354 template instantiation with external linkage should be the
1355 same, independent of what translation unit asks for the
1356 address, and this will not hold when we emit multiple copies of
1357 the function. However, there's little else we can do.
1359 Also, by default, the typeinfo implementation assumes that
1360 there will be only one copy of the string used as the name for
1361 each type. Therefore, if weak symbols are unavailable, the
1362 run-time library should perform a more conservative check; it
1363 should perform a string comparison, rather than an address
1365 TREE_PUBLIC (decl) = 0;
1368 /* Static data member template instantiations, however, cannot
1369 have multiple copies. */
1370 if (DECL_INITIAL (decl) == 0
1371 || DECL_INITIAL (decl) == error_mark_node)
1372 DECL_COMMON (decl) = 1;
1373 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1375 DECL_COMMON (decl) = 1;
1376 DECL_INITIAL (decl) = error_mark_node;
1378 else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1380 /* We can't do anything useful; leave vars for explicit
1382 DECL_EXTERNAL (decl) = 1;
1383 DECL_NOT_REALLY_EXTERN (decl) = 0;
1387 if (DECL_LANG_SPECIFIC (decl))
1388 DECL_COMDAT (decl) = 1;
1391 /* For win32 we also want to put explicit instantiations in
1392 linkonce sections, so that they will be merged with implicit
1393 instantiations; otherwise we get duplicate symbol errors.
1394 For Darwin we do not want explicit instantiations to be
1398 maybe_make_one_only (tree decl)
1400 /* We used to say that this was not necessary on targets that support weak
1401 symbols, because the implicit instantiations will defer to the explicit
1402 one. However, that's not actually the case in SVR4; a strong definition
1403 after a weak one is an error. Also, not making explicit
1404 instantiations one_only means that we can end up with two copies of
1405 some template instantiations. */
1409 /* We can't set DECL_COMDAT on functions, or finish_file will think
1410 we can get away with not emitting them if they aren't used. We need
1411 to for variables so that cp_finish_decl will update their linkage,
1412 because their DECL_INITIAL may not have been set properly yet. */
1414 if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
1415 || (! DECL_EXPLICIT_INSTANTIATION (decl)
1416 && ! DECL_TEMPLATE_SPECIALIZATION (decl)))
1418 make_decl_one_only (decl);
1420 if (TREE_CODE (decl) == VAR_DECL)
1422 DECL_COMDAT (decl) = 1;
1423 /* Mark it needed so we don't forget to emit it. */
1424 mark_decl_referenced (decl);
1429 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
1430 based on TYPE and other static flags.
1432 Note that anything public is tagged TREE_PUBLIC, whether
1433 it's public in this file or in another one. */
1436 import_export_vtable (tree decl, tree type, int final)
1438 if (DECL_INTERFACE_KNOWN (decl))
1441 if (TYPE_FOR_JAVA (type))
1443 TREE_PUBLIC (decl) = 1;
1444 DECL_EXTERNAL (decl) = 1;
1445 DECL_INTERFACE_KNOWN (decl) = 1;
1447 else if (CLASSTYPE_INTERFACE_KNOWN (type))
1449 TREE_PUBLIC (decl) = 1;
1450 DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type);
1451 DECL_INTERFACE_KNOWN (decl) = 1;
1455 /* We can only wait to decide if we have real non-inline virtual
1456 functions in our class, or if we come from a template. */
1458 int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
1459 || CLASSTYPE_KEY_METHOD (type) != NULL_TREE);
1461 if (final || ! found)
1463 comdat_linkage (decl);
1464 DECL_EXTERNAL (decl) = 0;
1468 TREE_PUBLIC (decl) = 1;
1469 DECL_EXTERNAL (decl) = 1;
1474 /* Determine whether or not we want to specifically import or export CTYPE,
1475 using various heuristics. */
1478 import_export_class (tree ctype)
1480 /* -1 for imported, 1 for exported. */
1481 int import_export = 0;
1483 /* It only makes sense to call this function at EOF. The reason is
1484 that this function looks at whether or not the first non-inline
1485 non-abstract virtual member function has been defined in this
1486 translation unit. But, we can't possibly know that until we've
1487 seen the entire translation unit. */
1488 my_friendly_assert (at_eof, 20000226);
1490 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1493 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface,
1494 we will have CLASSTYPE_INTERFACE_ONLY set but not
1495 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
1496 heuristic because someone will supply a #pragma implementation
1497 elsewhere, and deducing it here would produce a conflict. */
1498 if (CLASSTYPE_INTERFACE_ONLY (ctype))
1501 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1503 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1506 /* If we got -fno-implicit-templates, we import template classes that
1507 weren't explicitly instantiated. */
1508 if (import_export == 0
1509 && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1510 && ! flag_implicit_templates)
1513 /* Base our import/export status on that of the first non-inline,
1514 non-pure virtual function, if any. */
1515 if (import_export == 0
1516 && TYPE_POLYMORPHIC_P (ctype))
1518 tree method = CLASSTYPE_KEY_METHOD (ctype);
1520 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1523 #ifdef MULTIPLE_SYMBOL_SPACES
1524 if (import_export == -1)
1530 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1531 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1535 /* Return true if VAR has already been provided to the back end; in that
1536 case VAR should not be modified further by the front end. */
1538 var_finalized_p (tree var)
1540 if (flag_unit_at_a_time)
1541 return cgraph_varpool_node (var)->finalized;
1543 return TREE_ASM_WRITTEN (var);
1546 /* If necessary, write out the vtables for the dynamic class CTYPE.
1547 Returns true if any vtables were emitted. */
1550 maybe_emit_vtables (tree ctype)
1554 bool needed = false;
1555 bool weaken_vtables;
1557 /* If the vtables for this class have already been emitted there is
1558 nothing more to do. */
1559 primary_vtbl = CLASSTYPE_VTABLES (ctype);
1560 if (var_finalized_p (primary_vtbl))
1562 /* Ignore dummy vtables made by get_vtable_decl. */
1563 if (TREE_TYPE (primary_vtbl) == void_type_node)
1566 import_export_class (ctype);
1567 import_export_vtable (primary_vtbl, ctype, 1);
1569 /* See if any of the vtables are needed. */
1570 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1571 if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))
1575 /* If the references to this class' vtables are optimized away,
1576 still emit the appropriate debugging information. See
1578 if (DECL_COMDAT (primary_vtbl)
1579 && CLASSTYPE_DEBUG_REQUESTED (ctype))
1580 note_debug_info_needed (ctype);
1583 else if (TREE_PUBLIC (vtbl) && !DECL_COMDAT (vtbl))
1586 /* Determine whether to make vtables weak. The ABI requires that we
1587 do so. There are two cases in which we have to violate the ABI
1588 specification: targets where we don't have weak symbols
1589 (obviously), and targets where weak symbols don't appear in
1590 static archives' tables of contents. On such targets, avoiding
1591 undefined symbol link errors requires that we only make a symbol
1592 weak if we know that it will be emitted everywhere it's needed.
1593 So on such targets we don't make vtables weak in the common case
1594 where we're emitting a vtable of a nontemplate class in the
1595 translation unit containing the definition of a noninline key
1597 if (flag_weak && !TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
1598 weaken_vtables = true;
1601 if (CLASSTYPE_USE_TEMPLATE (ctype))
1602 weaken_vtables = CLASSTYPE_IMPLICIT_INSTANTIATION (ctype);
1604 weaken_vtables = !CLASSTYPE_KEY_METHOD (ctype)
1605 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (ctype));
1608 weaken_vtables = false;
1610 /* The ABI requires that we emit all of the vtables if we emit any
1612 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1615 import_export_vtable (vtbl, ctype, 1);
1616 mark_vtable_entries (vtbl);
1618 /* If we know that DECL is needed, mark it as such for the varpool. */
1620 cgraph_varpool_mark_needed_node (cgraph_varpool_node (vtbl));
1622 if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1624 /* It had better be all done at compile-time. */
1625 if (store_init_value (vtbl, DECL_INITIAL (vtbl)))
1629 if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
1631 /* Mark the VAR_DECL node representing the vtable itself as a
1632 "gratuitous" one, thereby forcing dwarfout.c to ignore it.
1633 It is rather important that such things be ignored because
1634 any effort to actually generate DWARF for them will run
1635 into trouble when/if we encounter code like:
1638 struct S { virtual void member (); };
1640 because the artificial declaration of the vtable itself (as
1641 manufactured by the g++ front end) will say that the vtable
1642 is a static member of `S' but only *after* the debug output
1643 for the definition of `S' has already been output. This causes
1644 grief because the DWARF entry for the definition of the vtable
1645 will try to refer back to an earlier *declaration* of the
1646 vtable as a static member of `S' and there won't be one.
1647 We might be able to arrange to have the "vtable static member"
1648 attached to the member list for `S' before the debug info for
1649 `S' get written (which would solve the problem) but that would
1650 require more intrusive changes to the g++ front end. */
1652 DECL_IGNORED_P (vtbl) = 1;
1655 /* Always make vtables weak. Or at least almost always; see above. */
1657 comdat_linkage (vtbl);
1659 rest_of_decl_compilation (vtbl, NULL, 1, 1);
1661 /* Because we're only doing syntax-checking, we'll never end up
1662 actually marking the variable as written. */
1663 if (flag_syntax_only)
1664 TREE_ASM_WRITTEN (vtbl) = 1;
1667 /* Since we're writing out the vtable here, also write the debug
1669 note_debug_info_needed (ctype);
1674 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
1675 inline function or template instantiation at end-of-file. */
1678 import_export_decl (tree decl)
1680 if (DECL_INTERFACE_KNOWN (decl))
1683 if (DECL_TEMPLATE_INSTANTIATION (decl)
1684 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1686 DECL_NOT_REALLY_EXTERN (decl) = 1;
1687 if ((DECL_IMPLICIT_INSTANTIATION (decl)
1688 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1689 && (flag_implicit_templates
1690 || (flag_implicit_inline_templates
1691 && TREE_CODE (decl) == FUNCTION_DECL
1692 && DECL_DECLARED_INLINE_P (decl))))
1694 if (!TREE_PUBLIC (decl))
1695 /* Templates are allowed to have internal linkage. See
1699 comdat_linkage (decl);
1703 DECL_EXTERNAL (decl) = 1;
1704 DECL_NOT_REALLY_EXTERN (decl) = 0;
1707 else if (DECL_FUNCTION_MEMBER_P (decl))
1709 if (!DECL_DECLARED_INLINE_P (decl))
1711 tree ctype = DECL_CONTEXT (decl);
1712 import_export_class (ctype);
1713 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1715 DECL_NOT_REALLY_EXTERN (decl)
1716 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
1717 || (DECL_DECLARED_INLINE_P (decl)
1718 && ! flag_implement_inlines
1719 && !DECL_VINDEX (decl)));
1721 if (!DECL_NOT_REALLY_EXTERN (decl))
1722 DECL_EXTERNAL (decl) = 1;
1724 /* Always make artificials weak. */
1725 if (DECL_ARTIFICIAL (decl) && flag_weak)
1726 comdat_linkage (decl);
1728 maybe_make_one_only (decl);
1732 comdat_linkage (decl);
1735 comdat_linkage (decl);
1737 DECL_INTERFACE_KNOWN (decl) = 1;
1740 /* Here, we only decide whether or not the tinfo node should be
1741 emitted with the vtable. IS_IN_LIBRARY is nonzero iff the
1742 typeinfo for TYPE should be in the runtime library. */
1745 import_export_tinfo (tree decl, tree type, bool is_in_library)
1747 if (DECL_INTERFACE_KNOWN (decl))
1750 if (IS_AGGR_TYPE (type))
1751 import_export_class (type);
1753 if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type)
1754 && TYPE_POLYMORPHIC_P (type)
1755 /* If -fno-rtti, we're not necessarily emitting this stuff with
1756 the class, so go ahead and emit it now. This can happen when
1757 a class is used in exception handling. */
1760 DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type);
1761 DECL_COMDAT (decl) = 0;
1765 DECL_NOT_REALLY_EXTERN (decl) = 1;
1766 DECL_COMDAT (decl) = 1;
1769 /* Now override some cases. */
1771 DECL_COMDAT (decl) = 1;
1772 else if (is_in_library)
1773 DECL_COMDAT (decl) = 0;
1775 DECL_INTERFACE_KNOWN (decl) = 1;
1778 /* Return an expression that performs the destruction of DECL, which
1779 must be a VAR_DECL whose type has a non-trivial destructor, or is
1780 an array whose (innermost) elements have a non-trivial destructor. */
1783 build_cleanup (tree decl)
1786 tree type = TREE_TYPE (decl);
1788 /* This function should only be called for declarations that really
1789 require cleanups. */
1790 my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106);
1792 /* Treat all objects with destructors as used; the destructor may do
1793 something substantive. */
1796 if (TREE_CODE (type) == ARRAY_TYPE)
1800 cxx_mark_addressable (decl);
1801 temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
1803 temp = build_delete (TREE_TYPE (temp), temp,
1804 sfk_complete_destructor,
1805 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
1809 /* Returns the initialization guard variable for the variable DECL,
1810 which has static storage duration. */
1813 get_guard (tree decl)
1818 sname = mangle_guard_variable (decl);
1819 guard = IDENTIFIER_GLOBAL_VALUE (sname);
1824 /* We use a type that is big enough to contain a mutex as well
1825 as an integer counter. */
1826 guard_type = long_long_integer_type_node;
1827 guard = build_decl (VAR_DECL, sname, guard_type);
1829 /* The guard should have the same linkage as what it guards. */
1830 TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
1831 TREE_STATIC (guard) = TREE_STATIC (decl);
1832 DECL_COMMON (guard) = DECL_COMMON (decl);
1833 DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl);
1834 if (TREE_PUBLIC (decl))
1835 DECL_WEAK (guard) = DECL_WEAK (decl);
1837 DECL_ARTIFICIAL (guard) = 1;
1838 TREE_USED (guard) = 1;
1839 pushdecl_top_level_and_finish (guard, NULL_TREE);
1844 /* Return those bits of the GUARD variable that should be set when the
1845 guarded entity is actually initialized. */
1848 get_guard_bits (tree guard)
1850 /* We only set the first byte of the guard, in order to leave room
1851 for a mutex in the high-order bits. */
1852 guard = build1 (ADDR_EXPR,
1853 build_pointer_type (TREE_TYPE (guard)),
1855 guard = build1 (NOP_EXPR,
1856 build_pointer_type (char_type_node),
1858 guard = build1 (INDIRECT_REF, char_type_node, guard);
1863 /* Return an expression which determines whether or not the GUARD
1864 variable has already been initialized. */
1867 get_guard_cond (tree guard)
1871 /* Check to see if the GUARD is zero. */
1872 guard = get_guard_bits (guard);
1873 guard_value = integer_zero_node;
1874 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
1875 guard_value = convert (TREE_TYPE (guard), guard_value);
1876 return cp_build_binary_op (EQ_EXPR, guard, guard_value);
1879 /* Return an expression which sets the GUARD variable, indicating that
1880 the variable being guarded has been initialized. */
1883 set_guard (tree guard)
1887 /* Set the GUARD to one. */
1888 guard = get_guard_bits (guard);
1889 guard_init = integer_one_node;
1890 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
1891 guard_init = convert (TREE_TYPE (guard), guard_init);
1892 return build_modify_expr (guard, NOP_EXPR, guard_init);
1895 /* Start the process of running a particular set of global constructors
1896 or destructors. Subroutine of do_[cd]tors. */
1899 start_objects (int method_type, int initp)
1905 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
1907 if (initp != DEFAULT_INIT_PRIORITY)
1917 sprintf (type, "%c%c%.5u", method_type, joiner, initp);
1920 sprintf (type, "%c", method_type);
1922 fndecl = build_lang_decl (FUNCTION_DECL,
1923 get_file_function_name_long (type),
1924 build_function_type (void_type_node,
1926 start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
1928 /* It can be a static function as long as collect2 does not have
1929 to scan the object file to find its ctor/dtor routine. */
1930 TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
1932 /* Mark this declaration as used to avoid spurious warnings. */
1933 TREE_USED (current_function_decl) = 1;
1935 /* Mark this function as a global constructor or destructor. */
1936 if (method_type == 'I')
1937 DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
1939 DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
1940 DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1;
1942 body = begin_compound_stmt (BCS_FN_BODY);
1944 /* We cannot allow these functions to be elided, even if they do not
1945 have external linkage. And, there's no point in deferring
1946 compilation of thes functions; they're all going to have to be
1948 DECL_INLINE (current_function_decl) = 0;
1949 DECL_UNINLINABLE (current_function_decl) = 1;
1954 /* Finish the process of running a particular set of global constructors
1955 or destructors. Subroutine of do_[cd]tors. */
1958 finish_objects (int method_type, int initp, tree body)
1963 finish_compound_stmt (body);
1964 fn = finish_function (0);
1965 expand_or_defer_fn (fn);
1967 /* When only doing semantic analysis, and no RTL generation, we
1968 can't call functions that directly emit assembly code; there is
1969 no assembly file in which to put the code. */
1970 if (flag_syntax_only)
1973 if (targetm.have_ctors_dtors)
1975 rtx fnsym = XEXP (DECL_RTL (fn), 0);
1976 if (method_type == 'I')
1977 (* targetm.asm_out.constructor) (fnsym, initp);
1979 (* targetm.asm_out.destructor) (fnsym, initp);
1983 /* The names of the parameters to the function created to handle
1984 initializations and destructions for objects with static storage
1986 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
1987 #define PRIORITY_IDENTIFIER "__priority"
1989 /* The name of the function we create to handle initializations and
1990 destructions for objects with static storage duration. */
1991 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
1993 /* The declaration for the __INITIALIZE_P argument. */
1994 static GTY(()) tree initialize_p_decl;
1996 /* The declaration for the __PRIORITY argument. */
1997 static GTY(()) tree priority_decl;
1999 /* The declaration for the static storage duration function. */
2000 static GTY(()) tree ssdf_decl;
2002 /* All the static storage duration functions created in this
2003 translation unit. */
2004 static GTY(()) varray_type ssdf_decls;
2006 /* A map from priority levels to information about that priority
2007 level. There may be many such levels, so efficient lookup is
2009 static splay_tree priority_info_map;
2011 /* Begins the generation of the function that will handle all
2012 initialization and destruction of objects with static storage
2013 duration. The function generated takes two parameters of type
2014 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2015 nonzero, it performs initializations. Otherwise, it performs
2016 destructions. It only performs those initializations or
2017 destructions with the indicated __PRIORITY. The generated function
2020 It is assumed that this function will only be called once per
2021 translation unit. */
2024 start_static_storage_duration_function (unsigned count)
2029 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2031 /* Create the identifier for this function. It will be of the form
2032 SSDF_IDENTIFIER_<number>. */
2033 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2035 /* Create the parameters. */
2036 parm_types = void_list_node;
2037 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2038 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2039 type = build_function_type (void_type_node, parm_types);
2041 /* Create the FUNCTION_DECL itself. */
2042 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2043 get_identifier (id),
2045 TREE_PUBLIC (ssdf_decl) = 0;
2046 DECL_ARTIFICIAL (ssdf_decl) = 1;
2048 /* Put this function in the list of functions to be called from the
2049 static constructors and destructors. */
2052 VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2054 /* Take this opportunity to initialize the map from priority
2055 numbers to information about that priority level. */
2056 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2057 /*delete_key_fn=*/0,
2058 /*delete_value_fn=*/
2059 (splay_tree_delete_value_fn) &free);
2061 /* We always need to generate functions for the
2062 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2063 priorities later, we'll be sure to find the
2064 DEFAULT_INIT_PRIORITY. */
2065 get_priority_info (DEFAULT_INIT_PRIORITY);
2068 VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
2070 /* Create the argument list. */
2071 initialize_p_decl = cp_build_parm_decl
2072 (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2073 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2074 TREE_USED (initialize_p_decl) = 1;
2075 priority_decl = cp_build_parm_decl
2076 (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2077 DECL_CONTEXT (priority_decl) = ssdf_decl;
2078 TREE_USED (priority_decl) = 1;
2080 TREE_CHAIN (initialize_p_decl) = priority_decl;
2081 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2083 /* Put the function in the global scope. */
2084 pushdecl (ssdf_decl);
2086 /* Start the function itself. This is equivalent to declaring the
2089 static void __ssdf (int __initialize_p, init __priority_p);
2091 It is static because we only need to call this function from the
2092 various constructor and destructor functions for this module. */
2093 start_preparsed_function (ssdf_decl,
2094 /*attrs=*/NULL_TREE,
2097 /* Set up the scope of the outermost block in the function. */
2098 body = begin_compound_stmt (BCS_FN_BODY);
2100 /* This function must not be deferred because we are depending on
2101 its compilation to tell us what is TREE_SYMBOL_REFERENCED. */
2102 DECL_INLINE (ssdf_decl) = 0;
2103 DECL_UNINLINABLE (ssdf_decl) = 1;
2108 /* Finish the generation of the function which performs initialization
2109 and destruction of objects with static storage duration. After
2110 this point, no more such objects can be created. */
2113 finish_static_storage_duration_function (tree body)
2115 /* Close out the function. */
2116 finish_compound_stmt (body);
2117 expand_or_defer_fn (finish_function (0));
2120 /* Return the information about the indicated PRIORITY level. If no
2121 code to handle this level has yet been generated, generate the
2122 appropriate prologue. */
2124 static priority_info
2125 get_priority_info (int priority)
2130 n = splay_tree_lookup (priority_info_map,
2131 (splay_tree_key) priority);
2134 /* Create a new priority information structure, and insert it
2136 pi = xmalloc (sizeof (struct priority_info_s));
2137 pi->initializations_p = 0;
2138 pi->destructions_p = 0;
2139 splay_tree_insert (priority_info_map,
2140 (splay_tree_key) priority,
2141 (splay_tree_value) pi);
2144 pi = (priority_info) n->value;
2149 /* Set up to handle the initialization or destruction of DECL. If
2150 INITP is nonzero, we are initializing the variable. Otherwise, we
2151 are destroying it. */
2154 start_static_initialization_or_destruction (tree decl, int initp)
2156 tree guard_if_stmt = NULL_TREE;
2163 /* Figure out the priority for this declaration. */
2164 priority = DECL_INIT_PRIORITY (decl);
2166 priority = DEFAULT_INIT_PRIORITY;
2168 /* Remember that we had an initialization or finalization at this
2170 pi = get_priority_info (priority);
2172 pi->initializations_p = 1;
2174 pi->destructions_p = 1;
2176 /* Trick the compiler into thinking we are at the file and line
2177 where DECL was declared so that error-messages make sense, and so
2178 that the debugger will show somewhat sensible file and line
2180 input_location = DECL_SOURCE_LOCATION (decl);
2186 Access control for implicit calls to the constructors,
2187 the conversion functions, or the destructor called to
2188 create and destroy a static data member is performed as
2189 if these calls appeared in the scope of the member's
2192 we pretend we are in a static member function of the class of
2193 which the DECL is a member. */
2194 if (member_p (decl))
2196 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
2197 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
2200 /* Conditionalize this initialization on being in the right priority
2201 and being initializing/finalizing appropriately. */
2202 guard_if_stmt = begin_if_stmt ();
2203 cond = cp_build_binary_op (EQ_EXPR,
2205 build_int_2 (priority, 0));
2206 init_cond = initp ? integer_one_node : integer_zero_node;
2207 init_cond = cp_build_binary_op (EQ_EXPR,
2210 cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
2212 /* Assume we don't need a guard. */
2214 /* We need a guard if this is an object with external linkage that
2215 might be initialized in more than one place. (For example, a
2216 static data member of a template, when the data member requires
2218 if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
2219 || DECL_ONE_ONLY (decl)
2220 || DECL_WEAK (decl)))
2224 guard = get_guard (decl);
2226 /* When using __cxa_atexit, we just check the GUARD as we would
2227 for a local static. */
2228 if (flag_use_cxa_atexit)
2230 /* When using __cxa_atexit, we never try to destroy
2231 anything from a static destructor. */
2232 my_friendly_assert (initp, 20000629);
2233 guard_cond = get_guard_cond (guard);
2235 /* If we don't have __cxa_atexit, then we will be running
2236 destructors from .fini sections, or their equivalents. So,
2237 we need to know how many times we've tried to initialize this
2238 object. We do initializations only if the GUARD is zero,
2239 i.e., if we are the first to initialize the variable. We do
2240 destructions only if the GUARD is one, i.e., if we are the
2241 last to destroy the variable. */
2244 = cp_build_binary_op (EQ_EXPR,
2245 build_unary_op (PREINCREMENT_EXPR,
2251 = cp_build_binary_op (EQ_EXPR,
2252 build_unary_op (PREDECREMENT_EXPR,
2257 cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
2260 finish_if_stmt_cond (cond, guard_if_stmt);
2262 /* If we're using __cxa_atexit, we have not already set the GUARD,
2263 so we must do so now. */
2264 if (guard && initp && flag_use_cxa_atexit)
2265 finish_expr_stmt (set_guard (guard));
2267 return guard_if_stmt;
2270 /* We've just finished generating code to do an initialization or
2271 finalization. GUARD_IF_STMT is the if-statement we used to guard
2272 the initialization. */
2275 finish_static_initialization_or_destruction (tree guard_if_stmt)
2277 finish_then_clause (guard_if_stmt);
2278 finish_if_stmt (guard_if_stmt);
2280 /* Now that we're done with DECL we don't need to pretend to be a
2281 member of its class any longer. */
2282 DECL_CONTEXT (current_function_decl) = NULL_TREE;
2283 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
2286 /* Generate code to do the initialization of DECL, a VAR_DECL with
2287 static storage duration. The initialization is INIT. */
2290 do_static_initialization (tree decl, tree init)
2294 /* Set up for the initialization. */
2296 = start_static_initialization_or_destruction (decl,
2299 /* Perform the initialization. */
2301 finish_expr_stmt (init);
2303 /* If we're using __cxa_atexit, register a a function that calls the
2304 destructor for the object. */
2305 if (flag_use_cxa_atexit)
2306 register_dtor_fn (decl);
2309 finish_static_initialization_or_destruction (guard_if_stmt);
2312 /* Generate code to do the static destruction of DECL. If DECL may be
2313 initialized more than once in different object files, GUARD is the
2314 guard variable to check. PRIORITY is the priority for the
2318 do_static_destruction (tree decl)
2322 /* If we're using __cxa_atexit, then destructors are registered
2323 immediately after objects are initialized. */
2324 my_friendly_assert (!flag_use_cxa_atexit, 20000121);
2326 /* If we don't need a destructor, there's nothing to do. */
2327 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2330 /* Actually do the destruction. */
2331 guard_if_stmt = start_static_initialization_or_destruction (decl,
2333 finish_expr_stmt (build_cleanup (decl));
2334 finish_static_initialization_or_destruction (guard_if_stmt);
2337 /* VARS is a list of variables with static storage duration which may
2338 need initialization and/or finalization. Remove those variables
2339 that don't really need to be initialized or finalized, and return
2340 the resulting list. The order in which the variables appear in
2341 VARS is in reverse order of the order in which they should actually
2342 be initialized. The list we return is in the unreversed order;
2343 i.e., the first variable should be initialized first. */
2346 prune_vars_needing_no_initialization (tree *vars)
2349 tree result = NULL_TREE;
2354 tree decl = TREE_VALUE (t);
2355 tree init = TREE_PURPOSE (t);
2357 /* Deal gracefully with error. */
2358 if (decl == error_mark_node)
2360 var = &TREE_CHAIN (t);
2364 /* The only things that can be initialized are variables. */
2365 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
2367 /* If this object is not defined, we don't need to do anything
2369 if (DECL_EXTERNAL (decl))
2371 var = &TREE_CHAIN (t);
2375 /* Also, if the initializer already contains errors, we can bail
2377 if (init && TREE_CODE (init) == TREE_LIST
2378 && value_member (error_mark_node, init))
2380 var = &TREE_CHAIN (t);
2384 /* This variable is going to need initialization and/or
2385 finalization, so we add it to the list. */
2386 *var = TREE_CHAIN (t);
2387 TREE_CHAIN (t) = result;
2394 /* Make sure we have told the back end about all the variables in
2398 write_out_vars (tree vars)
2402 for (v = vars; v; v = TREE_CHAIN (v))
2403 if (!var_finalized_p (TREE_VALUE (v)))
2404 rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
2407 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
2408 (otherwise) that will initialize all gobal objects with static
2409 storage duration having the indicated PRIORITY. */
2412 generate_ctor_or_dtor_function (bool constructor_p, int priority,
2421 input_location = *locus;
2424 /* We use `I' to indicate initialization and `D' to indicate
2426 function_key = constructor_p ? 'I' : 'D';
2428 /* We emit the function lazily, to avoid generating empty
2429 global constructors and destructors. */
2432 /* Call the static storage duration function with appropriate
2435 for (i = 0; i < ssdf_decls->elements_used; ++i)
2437 fndecl = VARRAY_TREE (ssdf_decls, i);
2439 /* Calls to pure or const functions will expand to nothing. */
2440 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2443 body = start_objects (function_key, priority);
2445 arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
2447 arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
2449 finish_expr_stmt (build_function_call (fndecl, arguments));
2453 /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
2454 calls to any functions marked with attributes indicating that
2455 they should be called at initialization- or destruction-time. */
2456 if (priority == DEFAULT_INIT_PRIORITY)
2460 for (fns = constructor_p ? static_ctors : static_dtors;
2462 fns = TREE_CHAIN (fns))
2464 fndecl = TREE_VALUE (fns);
2466 /* Calls to pure/const functions will expand to nothing. */
2467 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2470 body = start_objects (function_key, priority);
2471 finish_expr_stmt (build_function_call (fndecl, NULL_TREE));
2476 /* Close out the function. */
2478 finish_objects (function_key, priority, body);
2481 /* Generate constructor and destructor functions for the priority
2485 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
2487 location_t *locus = data;
2488 int priority = (int) n->key;
2489 priority_info pi = (priority_info) n->value;
2491 /* Generate the functions themselves, but only if they are really
2493 if (pi->initializations_p
2494 || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
2495 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
2496 if (pi->destructions_p
2497 || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
2498 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
2500 /* Keep iterating. */
2504 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
2505 decls referenced from frontend specific constructs; it will be called
2506 only for language-specific tree nodes.
2508 Here we must deal with member pointers. */
2511 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2512 tree from ATTRIBUTE_UNUSED)
2516 if (flag_unit_at_a_time)
2517 switch (TREE_CODE (t))
2520 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2521 cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
2524 if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
2525 cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t)));
2535 /* This routine is called from the last rule in yyparse ().
2536 Its job is to create all the code needed to initialize and
2537 destroy the global aggregates. We do the destruction
2538 first, since that way we only need to reverse the decls once. */
2547 unsigned ssdf_count = 0;
2549 locus = input_location;
2552 /* Bad parse errors. Just forget about it. */
2553 if (! global_bindings_p () || current_class_type || decl_namespace_list)
2557 c_common_write_pch ();
2559 /* Otherwise, GDB can get confused, because in only knows
2560 about source for LINENO-1 lines. */
2563 interface_unknown = 1;
2566 /* We now have to write out all the stuff we put off writing out.
2569 o Template specializations that we have not yet instantiated,
2570 but which are needed.
2571 o Initialization and destruction for non-local objects with
2572 static storage duration. (Local objects with static storage
2573 duration are initialized when their scope is first entered,
2574 and are cleaned up via atexit.)
2575 o Virtual function tables.
2577 All of these may cause others to be needed. For example,
2578 instantiating one function may cause another to be needed, and
2579 generating the initializer for an object may cause templates to be
2580 instantiated, etc., etc. */
2582 timevar_push (TV_VARCONST);
2584 emit_support_tinfos ();
2589 size_t n_old, n_new;
2593 /* If there are templates that we've put off instantiating, do
2595 instantiate_pending_templates ();
2598 /* Write out virtual tables as required. Note that writing out
2599 the virtual table for a template class may cause the
2600 instantiation of members of that class. If we write out
2601 vtables then we remove the class from our list so we don't
2602 have to look at it again. */
2604 while (keyed_classes != NULL_TREE
2605 && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
2608 keyed_classes = TREE_CHAIN (keyed_classes);
2614 tree next = TREE_CHAIN (t);
2618 if (maybe_emit_vtables (TREE_VALUE (next)))
2621 TREE_CHAIN (t) = TREE_CHAIN (next);
2626 next = TREE_CHAIN (t);
2630 /* Write out needed type info variables. We have to be careful
2631 looping through unemitted decls, because emit_tinfo_decl may
2632 cause other variables to be needed. We stick new elements
2633 (and old elements that we may need to reconsider) at the end
2634 of the array, then shift them back to the beginning once we're
2637 n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
2638 for (i = 0; i < n_old; ++i)
2640 tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
2641 if (emit_tinfo_decl (tinfo_decl))
2644 VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
2647 /* The only elements we want to keep are the new ones. Copy
2648 them to the beginning of the array, then get rid of the
2650 n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
2652 memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
2653 &VARRAY_TREE (unemitted_tinfo_decls, n_old),
2654 n_new * sizeof (tree));
2655 memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
2656 0, n_old * sizeof (tree));
2657 VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
2659 /* The list of objects with static storage duration is built up
2660 in reverse order. We clear STATIC_AGGREGATES so that any new
2661 aggregates added during the initialization of these will be
2662 initialized in the correct order when we next come around the
2664 vars = prune_vars_needing_no_initialization (&static_aggregates);
2670 /* We need to start a new initialization function each time
2671 through the loop. That's because we need to know which
2672 vtables have been referenced, and TREE_SYMBOL_REFERENCED
2673 isn't computed until a function is finished, and written
2674 out. That's a deficiency in the back-end. When this is
2675 fixed, these initialization functions could all become
2676 inline, with resulting performance improvements. */
2679 /* Set the line and file, so that it is obviously not from
2681 input_location = locus;
2682 ssdf_body = start_static_storage_duration_function (ssdf_count);
2684 /* Make sure the back end knows about all the variables. */
2685 write_out_vars (vars);
2687 /* First generate code to do all the initializations. */
2688 for (v = vars; v; v = TREE_CHAIN (v))
2689 do_static_initialization (TREE_VALUE (v),
2692 /* Then, generate code to do all the destructions. Do these
2693 in reverse order so that the most recently constructed
2694 variable is the first destroyed. If we're using
2695 __cxa_atexit, then we don't need to do this; functions
2696 were registered at initialization time to destroy the
2698 if (!flag_use_cxa_atexit)
2700 vars = nreverse (vars);
2701 for (v = vars; v; v = TREE_CHAIN (v))
2702 do_static_destruction (TREE_VALUE (v));
2707 /* Finish up the static storage duration function for this
2709 input_location = locus;
2710 finish_static_storage_duration_function (ssdf_body);
2712 /* All those initializations and finalizations might cause
2713 us to need more inline functions, more template
2714 instantiations, etc. */
2720 for (i = 0; i < deferred_fns_used; ++i)
2722 tree decl = VARRAY_TREE (deferred_fns, i);
2724 if (! DECL_DECLARED_INLINE_P (decl) || ! TREE_USED (decl))
2727 /* Does it need synthesizing? */
2728 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
2730 && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
2732 /* Even though we're already at the top-level, we push
2733 there again. That way, when we pop back a few lines
2734 hence, all of our state is restored. Otherwise,
2735 finish_function doesn't clean things up, and we end
2736 up with CURRENT_FUNCTION_DECL set. */
2737 push_to_top_level ();
2738 synthesize_method (decl);
2739 pop_from_top_level ();
2743 if (!DECL_SAVED_TREE (decl))
2746 import_export_decl (decl);
2748 /* We lie to the back-end, pretending that some functions
2749 are not defined when they really are. This keeps these
2750 functions from being put out unnecessarily. But, we must
2751 stop lying when the functions are referenced, or if they
2752 are not comdat since they need to be put out now. This
2753 is done in a separate for cycle, because if some deferred
2754 function is contained in another deferred function later
2755 in deferred_fns varray, rest_of_compilation would skip
2756 this function and we really cannot expand the same
2758 if (DECL_NOT_REALLY_EXTERN (decl)
2759 && DECL_INITIAL (decl)
2760 && DECL_NEEDED_P (decl))
2761 DECL_EXTERNAL (decl) = 0;
2763 /* If we're going to need to write this function out, and
2764 there's already a body for it, create RTL for it now.
2765 (There might be no body if this is a method we haven't
2766 gotten around to synthesizing yet.) */
2767 if (!DECL_EXTERNAL (decl)
2768 && DECL_NEEDED_P (decl)
2769 && !TREE_ASM_WRITTEN (decl)
2770 && (!flag_unit_at_a_time
2771 || !cgraph_node (decl)->local.finalized))
2773 /* We will output the function; no longer consider it in this
2775 DECL_DEFER_OUTPUT (decl) = 0;
2776 /* Generate RTL for this function now that we know we
2778 expand_or_defer_fn (decl);
2779 /* If we're compiling -fsyntax-only pretend that this
2780 function has been written out so that we don't try to
2782 if (flag_syntax_only)
2783 TREE_ASM_WRITTEN (decl) = 1;
2788 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
2791 /* Static data members are just like namespace-scope globals. */
2792 for (i = 0; i < pending_statics_used; ++i)
2794 tree decl = VARRAY_TREE (pending_statics, i);
2795 if (var_finalized_p (decl))
2797 import_export_decl (decl);
2798 if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
2799 DECL_EXTERNAL (decl) = 0;
2802 && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
2803 pending_statics_used))
2806 if (cgraph_assemble_pending_functions ())
2811 /* All used inline functions must have a definition at this point. */
2812 for (i = 0; i < deferred_fns_used; ++i)
2814 tree decl = VARRAY_TREE (deferred_fns, i);
2816 if (!TREE_ASM_WRITTEN (decl) && !DECL_SAVED_TREE (decl)
2817 /* An explicit instantiation can be used to specify
2818 that the body is in another unit. It will have
2819 already verified there was a definition. */
2820 && !DECL_EXPLICIT_INSTANTIATION (decl))
2822 cp_warning_at ("inline function `%D' used but never defined", decl);
2823 /* This symbol is effectively an "extern" declaration now.
2824 This is not strictly necessary, but removes a duplicate
2826 TREE_PUBLIC (decl) = 1;
2831 /* We give C linkage to static constructors and destructors. */
2832 push_lang_context (lang_name_c);
2834 /* Generate initialization and destruction functions for all
2835 priorities for which they are required. */
2836 if (priority_info_map)
2837 splay_tree_foreach (priority_info_map,
2838 generate_ctor_and_dtor_functions_for_priority,
2844 generate_ctor_or_dtor_function (/*constructor_p=*/true,
2845 DEFAULT_INIT_PRIORITY, &locus);
2847 generate_ctor_or_dtor_function (/*constructor_p=*/false,
2848 DEFAULT_INIT_PRIORITY, &locus);
2851 /* We're done with the splay-tree now. */
2852 if (priority_info_map)
2853 splay_tree_delete (priority_info_map);
2855 /* We're done with static constructors, so we can go back to "C++"
2857 pop_lang_context ();
2859 if (flag_unit_at_a_time)
2861 cgraph_finalize_compilation_unit ();
2865 /* Emit mudflap static registration function. This must be done
2866 after all the user functions have been expanded. */
2868 mudflap_finish_file ();
2870 /* Now, issue warnings about static, but not defined, functions,
2871 etc., and emit debugging information. */
2872 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
2873 if (pending_statics)
2874 check_global_declarations (&VARRAY_TREE (pending_statics, 0),
2875 pending_statics_used);
2879 /* The entire file is now complete. If requested, dump everything
2883 FILE *stream = dump_begin (TDI_tu, &flags);
2887 dump_node (global_namespace, flags & ~TDF_SLIM, stream);
2888 dump_end (TDI_tu, stream);
2892 timevar_pop (TV_VARCONST);
2894 if (flag_detailed_statistics)
2896 dump_tree_statistics ();
2897 dump_time_statistics ();
2899 input_location = locus;
2901 #ifdef ENABLE_CHECKING
2902 validate_conversion_obstack ();
2903 #endif /* ENABLE_CHECKING */
2906 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
2907 function to call in parse-tree form; it has not yet been
2908 semantically analyzed. ARGS are the arguments to the function.
2909 They have already been semantically analyzed. */
2912 build_offset_ref_call_from_tree (tree fn, tree args)
2921 object = TREE_OPERAND (fn, 0);
2923 if (processing_template_decl)
2925 my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR
2926 || TREE_CODE (fn) == MEMBER_REF,
2928 if (type_dependent_expression_p (fn)
2929 || any_type_dependent_arguments_p (args))
2930 return build_min_nt (CALL_EXPR, fn, args, NULL_TREE);
2932 /* Transform the arguments and add the implicit "this"
2933 parameter. That must be done before the FN is transformed
2934 because we depend on the form of FN. */
2935 args = build_non_dependent_args (args);
2936 if (TREE_CODE (fn) == DOTSTAR_EXPR)
2937 object = build_unary_op (ADDR_EXPR, object, 0);
2938 object = build_non_dependent_expr (object);
2939 args = tree_cons (NULL_TREE, object, args);
2940 /* Now that the arguments are done, transform FN. */
2941 fn = build_non_dependent_expr (fn);
2944 /* A qualified name corresponding to a bound pointer-to-member is
2945 represented as an OFFSET_REF:
2947 struct B { void g(); };
2949 void B::g() { (this->*p)(); } */
2950 if (TREE_CODE (fn) == OFFSET_REF)
2952 tree object_addr = build_unary_op (ADDR_EXPR, object, 0);
2953 fn = TREE_OPERAND (fn, 1);
2954 fn = get_member_function_from_ptrfunc (&object_addr, fn);
2955 args = tree_cons (NULL_TREE, object_addr, args);
2958 expr = build_function_call (fn, args);
2959 if (processing_template_decl && expr != error_mark_node)
2960 return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args, NULL_TREE);
2966 check_default_args (tree x)
2968 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
2969 bool saw_def = false;
2970 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
2971 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
2973 if (TREE_PURPOSE (arg))
2977 cp_error_at ("default argument missing for parameter %P of `%+#D'",
2985 mark_used (tree decl)
2987 TREE_USED (decl) = 1;
2988 if (processing_template_decl || skip_evaluation)
2991 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
2992 && !TREE_ASM_WRITTEN (decl))
2993 /* Remember it, so we can check it was defined. */
2995 if (DECL_DEFERRED_FN (decl))
2997 DECL_DEFERRED_FN (decl) = 1;
2998 DECL_DEFER_OUTPUT (decl) = 1;
3000 VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
3002 VARRAY_PUSH_TREE (deferred_fns, decl);
3005 assemble_external (decl);
3007 /* Is it a synthesized method that needs to be synthesized? */
3008 if (TREE_CODE (decl) == FUNCTION_DECL
3009 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
3010 && DECL_ARTIFICIAL (decl)
3011 && !DECL_THUNK_P (decl)
3012 && ! DECL_INITIAL (decl)
3013 /* Kludge: don't synthesize for default args. */
3014 && current_function_decl)
3016 synthesize_method (decl);
3017 /* If we've already synthesized the method we don't need to
3018 instantiate it, so we can return right away. */
3022 /* If this is a function or variable that is an instance of some
3023 template, we now know that we will need to actually do the
3024 instantiation. We check that DECL is not an explicit
3025 instantiation because that is not checked in instantiate_decl. */
3026 if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
3027 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3028 && (!DECL_EXPLICIT_INSTANTIATION (decl)
3029 || (TREE_CODE (decl) == FUNCTION_DECL
3030 && DECL_INLINE (DECL_TEMPLATE_RESULT
3031 (template_for_substitution (decl))))))
3035 /* Normally, we put off instantiating functions in order to
3036 improve compile times. Maintaining a stack of active
3037 functions is expensive, and the inliner knows to
3038 instantiate any functions it might need.
3040 However, if instantiating this function might help us mark
3041 the current function TREE_NOTHROW, we go ahead and
3044 This is not needed for unit-at-a-time since we reorder the functions
3045 in topological order anyway.
3047 defer = (!flag_exceptions
3048 || flag_unit_at_a_time
3050 || TREE_CODE (decl) != FUNCTION_DECL
3051 /* If the called function can't throw, we don't need to
3052 generate its body to find that out. */
3053 || TREE_NOTHROW (decl)
3055 || !current_function_decl
3056 /* If we already know the current function can't throw,
3057 then we don't need to work hard to prove it. */
3058 || TREE_NOTHROW (current_function_decl)
3059 /* If we already know that the current function *can*
3060 throw, there's no point in gathering more
3062 || cp_function_chain->can_throw);
3064 instantiate_decl (decl, defer, /*undefined_ok=*/0);
3068 #include "gt-cp-decl2.h"