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 = targetm.cxx.guard_type ();
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 if (!targetm.cxx.guard_mask_bit ())
1852 /* We only set the first byte of the guard, in order to leave room
1853 for a mutex in the high-order bits. */
1854 guard = build1 (ADDR_EXPR,
1855 build_pointer_type (TREE_TYPE (guard)),
1857 guard = build1 (NOP_EXPR,
1858 build_pointer_type (char_type_node),
1860 guard = build1 (INDIRECT_REF, char_type_node, guard);
1866 /* Return an expression which determines whether or not the GUARD
1867 variable has already been initialized. */
1870 get_guard_cond (tree guard)
1874 /* Check to see if the GUARD is zero. */
1875 guard = get_guard_bits (guard);
1877 /* Mask off all but the low bit. */
1878 if (targetm.cxx.guard_mask_bit ())
1880 guard_value = integer_one_node;
1881 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
1882 guard_value = convert (TREE_TYPE (guard), guard_value);
1883 guard = cp_build_binary_op (BIT_AND_EXPR, guard, guard_value);
1886 guard_value = integer_zero_node;
1887 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
1888 guard_value = convert (TREE_TYPE (guard), guard_value);
1889 return cp_build_binary_op (EQ_EXPR, guard, guard_value);
1892 /* Return an expression which sets the GUARD variable, indicating that
1893 the variable being guarded has been initialized. */
1896 set_guard (tree guard)
1900 /* Set the GUARD to one. */
1901 guard = get_guard_bits (guard);
1902 guard_init = integer_one_node;
1903 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
1904 guard_init = convert (TREE_TYPE (guard), guard_init);
1905 return build_modify_expr (guard, NOP_EXPR, guard_init);
1908 /* Start the process of running a particular set of global constructors
1909 or destructors. Subroutine of do_[cd]tors. */
1912 start_objects (int method_type, int initp)
1918 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
1920 if (initp != DEFAULT_INIT_PRIORITY)
1930 sprintf (type, "%c%c%.5u", method_type, joiner, initp);
1933 sprintf (type, "%c", method_type);
1935 fndecl = build_lang_decl (FUNCTION_DECL,
1936 get_file_function_name_long (type),
1937 build_function_type (void_type_node,
1939 start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
1941 /* It can be a static function as long as collect2 does not have
1942 to scan the object file to find its ctor/dtor routine. */
1943 TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
1945 /* Mark this declaration as used to avoid spurious warnings. */
1946 TREE_USED (current_function_decl) = 1;
1948 /* Mark this function as a global constructor or destructor. */
1949 if (method_type == 'I')
1950 DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
1952 DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
1953 DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1;
1955 body = begin_compound_stmt (BCS_FN_BODY);
1957 /* We cannot allow these functions to be elided, even if they do not
1958 have external linkage. And, there's no point in deferring
1959 compilation of thes functions; they're all going to have to be
1961 DECL_INLINE (current_function_decl) = 0;
1962 DECL_UNINLINABLE (current_function_decl) = 1;
1967 /* Finish the process of running a particular set of global constructors
1968 or destructors. Subroutine of do_[cd]tors. */
1971 finish_objects (int method_type, int initp, tree body)
1976 finish_compound_stmt (body);
1977 fn = finish_function (0);
1978 expand_or_defer_fn (fn);
1980 /* When only doing semantic analysis, and no RTL generation, we
1981 can't call functions that directly emit assembly code; there is
1982 no assembly file in which to put the code. */
1983 if (flag_syntax_only)
1986 if (targetm.have_ctors_dtors)
1988 rtx fnsym = XEXP (DECL_RTL (fn), 0);
1989 if (method_type == 'I')
1990 (* targetm.asm_out.constructor) (fnsym, initp);
1992 (* targetm.asm_out.destructor) (fnsym, initp);
1996 /* The names of the parameters to the function created to handle
1997 initializations and destructions for objects with static storage
1999 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2000 #define PRIORITY_IDENTIFIER "__priority"
2002 /* The name of the function we create to handle initializations and
2003 destructions for objects with static storage duration. */
2004 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2006 /* The declaration for the __INITIALIZE_P argument. */
2007 static GTY(()) tree initialize_p_decl;
2009 /* The declaration for the __PRIORITY argument. */
2010 static GTY(()) tree priority_decl;
2012 /* The declaration for the static storage duration function. */
2013 static GTY(()) tree ssdf_decl;
2015 /* All the static storage duration functions created in this
2016 translation unit. */
2017 static GTY(()) varray_type ssdf_decls;
2019 /* A map from priority levels to information about that priority
2020 level. There may be many such levels, so efficient lookup is
2022 static splay_tree priority_info_map;
2024 /* Begins the generation of the function that will handle all
2025 initialization and destruction of objects with static storage
2026 duration. The function generated takes two parameters of type
2027 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2028 nonzero, it performs initializations. Otherwise, it performs
2029 destructions. It only performs those initializations or
2030 destructions with the indicated __PRIORITY. The generated function
2033 It is assumed that this function will only be called once per
2034 translation unit. */
2037 start_static_storage_duration_function (unsigned count)
2042 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2044 /* Create the identifier for this function. It will be of the form
2045 SSDF_IDENTIFIER_<number>. */
2046 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2048 /* Create the parameters. */
2049 parm_types = void_list_node;
2050 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2051 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2052 type = build_function_type (void_type_node, parm_types);
2054 /* Create the FUNCTION_DECL itself. */
2055 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2056 get_identifier (id),
2058 TREE_PUBLIC (ssdf_decl) = 0;
2059 DECL_ARTIFICIAL (ssdf_decl) = 1;
2061 /* Put this function in the list of functions to be called from the
2062 static constructors and destructors. */
2065 VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2067 /* Take this opportunity to initialize the map from priority
2068 numbers to information about that priority level. */
2069 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2070 /*delete_key_fn=*/0,
2071 /*delete_value_fn=*/
2072 (splay_tree_delete_value_fn) &free);
2074 /* We always need to generate functions for the
2075 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2076 priorities later, we'll be sure to find the
2077 DEFAULT_INIT_PRIORITY. */
2078 get_priority_info (DEFAULT_INIT_PRIORITY);
2081 VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
2083 /* Create the argument list. */
2084 initialize_p_decl = cp_build_parm_decl
2085 (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2086 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2087 TREE_USED (initialize_p_decl) = 1;
2088 priority_decl = cp_build_parm_decl
2089 (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2090 DECL_CONTEXT (priority_decl) = ssdf_decl;
2091 TREE_USED (priority_decl) = 1;
2093 TREE_CHAIN (initialize_p_decl) = priority_decl;
2094 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2096 /* Put the function in the global scope. */
2097 pushdecl (ssdf_decl);
2099 /* Start the function itself. This is equivalent to declaring the
2102 static void __ssdf (int __initialize_p, init __priority_p);
2104 It is static because we only need to call this function from the
2105 various constructor and destructor functions for this module. */
2106 start_preparsed_function (ssdf_decl,
2107 /*attrs=*/NULL_TREE,
2110 /* Set up the scope of the outermost block in the function. */
2111 body = begin_compound_stmt (BCS_FN_BODY);
2113 /* This function must not be deferred because we are depending on
2114 its compilation to tell us what is TREE_SYMBOL_REFERENCED. */
2115 DECL_INLINE (ssdf_decl) = 0;
2116 DECL_UNINLINABLE (ssdf_decl) = 1;
2121 /* Finish the generation of the function which performs initialization
2122 and destruction of objects with static storage duration. After
2123 this point, no more such objects can be created. */
2126 finish_static_storage_duration_function (tree body)
2128 /* Close out the function. */
2129 finish_compound_stmt (body);
2130 expand_or_defer_fn (finish_function (0));
2133 /* Return the information about the indicated PRIORITY level. If no
2134 code to handle this level has yet been generated, generate the
2135 appropriate prologue. */
2137 static priority_info
2138 get_priority_info (int priority)
2143 n = splay_tree_lookup (priority_info_map,
2144 (splay_tree_key) priority);
2147 /* Create a new priority information structure, and insert it
2149 pi = xmalloc (sizeof (struct priority_info_s));
2150 pi->initializations_p = 0;
2151 pi->destructions_p = 0;
2152 splay_tree_insert (priority_info_map,
2153 (splay_tree_key) priority,
2154 (splay_tree_value) pi);
2157 pi = (priority_info) n->value;
2162 /* Set up to handle the initialization or destruction of DECL. If
2163 INITP is nonzero, we are initializing the variable. Otherwise, we
2164 are destroying it. */
2167 start_static_initialization_or_destruction (tree decl, int initp)
2169 tree guard_if_stmt = NULL_TREE;
2176 /* Figure out the priority for this declaration. */
2177 priority = DECL_INIT_PRIORITY (decl);
2179 priority = DEFAULT_INIT_PRIORITY;
2181 /* Remember that we had an initialization or finalization at this
2183 pi = get_priority_info (priority);
2185 pi->initializations_p = 1;
2187 pi->destructions_p = 1;
2189 /* Trick the compiler into thinking we are at the file and line
2190 where DECL was declared so that error-messages make sense, and so
2191 that the debugger will show somewhat sensible file and line
2193 input_location = DECL_SOURCE_LOCATION (decl);
2199 Access control for implicit calls to the constructors,
2200 the conversion functions, or the destructor called to
2201 create and destroy a static data member is performed as
2202 if these calls appeared in the scope of the member's
2205 we pretend we are in a static member function of the class of
2206 which the DECL is a member. */
2207 if (member_p (decl))
2209 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
2210 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
2213 /* Conditionalize this initialization on being in the right priority
2214 and being initializing/finalizing appropriately. */
2215 guard_if_stmt = begin_if_stmt ();
2216 cond = cp_build_binary_op (EQ_EXPR,
2218 build_int_2 (priority, 0));
2219 init_cond = initp ? integer_one_node : integer_zero_node;
2220 init_cond = cp_build_binary_op (EQ_EXPR,
2223 cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
2225 /* Assume we don't need a guard. */
2227 /* We need a guard if this is an object with external linkage that
2228 might be initialized in more than one place. (For example, a
2229 static data member of a template, when the data member requires
2231 if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
2232 || DECL_ONE_ONLY (decl)
2233 || DECL_WEAK (decl)))
2237 guard = get_guard (decl);
2239 /* When using __cxa_atexit, we just check the GUARD as we would
2240 for a local static. */
2241 if (flag_use_cxa_atexit)
2243 /* When using __cxa_atexit, we never try to destroy
2244 anything from a static destructor. */
2245 my_friendly_assert (initp, 20000629);
2246 guard_cond = get_guard_cond (guard);
2248 /* If we don't have __cxa_atexit, then we will be running
2249 destructors from .fini sections, or their equivalents. So,
2250 we need to know how many times we've tried to initialize this
2251 object. We do initializations only if the GUARD is zero,
2252 i.e., if we are the first to initialize the variable. We do
2253 destructions only if the GUARD is one, i.e., if we are the
2254 last to destroy the variable. */
2257 = cp_build_binary_op (EQ_EXPR,
2258 build_unary_op (PREINCREMENT_EXPR,
2264 = cp_build_binary_op (EQ_EXPR,
2265 build_unary_op (PREDECREMENT_EXPR,
2270 cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
2273 finish_if_stmt_cond (cond, guard_if_stmt);
2275 /* If we're using __cxa_atexit, we have not already set the GUARD,
2276 so we must do so now. */
2277 if (guard && initp && flag_use_cxa_atexit)
2278 finish_expr_stmt (set_guard (guard));
2280 return guard_if_stmt;
2283 /* We've just finished generating code to do an initialization or
2284 finalization. GUARD_IF_STMT is the if-statement we used to guard
2285 the initialization. */
2288 finish_static_initialization_or_destruction (tree guard_if_stmt)
2290 finish_then_clause (guard_if_stmt);
2291 finish_if_stmt (guard_if_stmt);
2293 /* Now that we're done with DECL we don't need to pretend to be a
2294 member of its class any longer. */
2295 DECL_CONTEXT (current_function_decl) = NULL_TREE;
2296 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
2299 /* Generate code to do the initialization of DECL, a VAR_DECL with
2300 static storage duration. The initialization is INIT. */
2303 do_static_initialization (tree decl, tree init)
2307 /* Set up for the initialization. */
2309 = start_static_initialization_or_destruction (decl,
2312 /* Perform the initialization. */
2314 finish_expr_stmt (init);
2316 /* If we're using __cxa_atexit, register a a function that calls the
2317 destructor for the object. */
2318 if (flag_use_cxa_atexit)
2319 register_dtor_fn (decl);
2322 finish_static_initialization_or_destruction (guard_if_stmt);
2325 /* Generate code to do the static destruction of DECL. If DECL may be
2326 initialized more than once in different object files, GUARD is the
2327 guard variable to check. PRIORITY is the priority for the
2331 do_static_destruction (tree decl)
2335 /* If we're using __cxa_atexit, then destructors are registered
2336 immediately after objects are initialized. */
2337 my_friendly_assert (!flag_use_cxa_atexit, 20000121);
2339 /* If we don't need a destructor, there's nothing to do. */
2340 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2343 /* Actually do the destruction. */
2344 guard_if_stmt = start_static_initialization_or_destruction (decl,
2346 finish_expr_stmt (build_cleanup (decl));
2347 finish_static_initialization_or_destruction (guard_if_stmt);
2350 /* VARS is a list of variables with static storage duration which may
2351 need initialization and/or finalization. Remove those variables
2352 that don't really need to be initialized or finalized, and return
2353 the resulting list. The order in which the variables appear in
2354 VARS is in reverse order of the order in which they should actually
2355 be initialized. The list we return is in the unreversed order;
2356 i.e., the first variable should be initialized first. */
2359 prune_vars_needing_no_initialization (tree *vars)
2362 tree result = NULL_TREE;
2367 tree decl = TREE_VALUE (t);
2368 tree init = TREE_PURPOSE (t);
2370 /* Deal gracefully with error. */
2371 if (decl == error_mark_node)
2373 var = &TREE_CHAIN (t);
2377 /* The only things that can be initialized are variables. */
2378 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
2380 /* If this object is not defined, we don't need to do anything
2382 if (DECL_EXTERNAL (decl))
2384 var = &TREE_CHAIN (t);
2388 /* Also, if the initializer already contains errors, we can bail
2390 if (init && TREE_CODE (init) == TREE_LIST
2391 && value_member (error_mark_node, init))
2393 var = &TREE_CHAIN (t);
2397 /* This variable is going to need initialization and/or
2398 finalization, so we add it to the list. */
2399 *var = TREE_CHAIN (t);
2400 TREE_CHAIN (t) = result;
2407 /* Make sure we have told the back end about all the variables in
2411 write_out_vars (tree vars)
2415 for (v = vars; v; v = TREE_CHAIN (v))
2416 if (!var_finalized_p (TREE_VALUE (v)))
2417 rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
2420 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
2421 (otherwise) that will initialize all gobal objects with static
2422 storage duration having the indicated PRIORITY. */
2425 generate_ctor_or_dtor_function (bool constructor_p, int priority,
2434 input_location = *locus;
2437 /* We use `I' to indicate initialization and `D' to indicate
2439 function_key = constructor_p ? 'I' : 'D';
2441 /* We emit the function lazily, to avoid generating empty
2442 global constructors and destructors. */
2445 /* Call the static storage duration function with appropriate
2448 for (i = 0; i < ssdf_decls->elements_used; ++i)
2450 fndecl = VARRAY_TREE (ssdf_decls, i);
2452 /* Calls to pure or const functions will expand to nothing. */
2453 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2456 body = start_objects (function_key, priority);
2458 arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
2460 arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
2462 finish_expr_stmt (build_function_call (fndecl, arguments));
2466 /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
2467 calls to any functions marked with attributes indicating that
2468 they should be called at initialization- or destruction-time. */
2469 if (priority == DEFAULT_INIT_PRIORITY)
2473 for (fns = constructor_p ? static_ctors : static_dtors;
2475 fns = TREE_CHAIN (fns))
2477 fndecl = TREE_VALUE (fns);
2479 /* Calls to pure/const functions will expand to nothing. */
2480 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2483 body = start_objects (function_key, priority);
2484 finish_expr_stmt (build_function_call (fndecl, NULL_TREE));
2489 /* Close out the function. */
2491 finish_objects (function_key, priority, body);
2494 /* Generate constructor and destructor functions for the priority
2498 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
2500 location_t *locus = data;
2501 int priority = (int) n->key;
2502 priority_info pi = (priority_info) n->value;
2504 /* Generate the functions themselves, but only if they are really
2506 if (pi->initializations_p
2507 || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
2508 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
2509 if (pi->destructions_p
2510 || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
2511 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
2513 /* Keep iterating. */
2517 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
2518 decls referenced from frontend specific constructs; it will be called
2519 only for language-specific tree nodes.
2521 Here we must deal with member pointers. */
2524 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2525 tree from ATTRIBUTE_UNUSED)
2529 if (flag_unit_at_a_time)
2530 switch (TREE_CODE (t))
2533 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2534 cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
2537 if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
2538 cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t)));
2548 /* This routine is called from the last rule in yyparse ().
2549 Its job is to create all the code needed to initialize and
2550 destroy the global aggregates. We do the destruction
2551 first, since that way we only need to reverse the decls once. */
2560 unsigned ssdf_count = 0;
2562 locus = input_location;
2565 /* Bad parse errors. Just forget about it. */
2566 if (! global_bindings_p () || current_class_type || decl_namespace_list)
2570 c_common_write_pch ();
2572 /* Otherwise, GDB can get confused, because in only knows
2573 about source for LINENO-1 lines. */
2576 interface_unknown = 1;
2579 /* We now have to write out all the stuff we put off writing out.
2582 o Template specializations that we have not yet instantiated,
2583 but which are needed.
2584 o Initialization and destruction for non-local objects with
2585 static storage duration. (Local objects with static storage
2586 duration are initialized when their scope is first entered,
2587 and are cleaned up via atexit.)
2588 o Virtual function tables.
2590 All of these may cause others to be needed. For example,
2591 instantiating one function may cause another to be needed, and
2592 generating the initializer for an object may cause templates to be
2593 instantiated, etc., etc. */
2595 timevar_push (TV_VARCONST);
2597 emit_support_tinfos ();
2602 size_t n_old, n_new;
2606 /* If there are templates that we've put off instantiating, do
2608 instantiate_pending_templates ();
2611 /* Write out virtual tables as required. Note that writing out
2612 the virtual table for a template class may cause the
2613 instantiation of members of that class. If we write out
2614 vtables then we remove the class from our list so we don't
2615 have to look at it again. */
2617 while (keyed_classes != NULL_TREE
2618 && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
2621 keyed_classes = TREE_CHAIN (keyed_classes);
2627 tree next = TREE_CHAIN (t);
2631 if (maybe_emit_vtables (TREE_VALUE (next)))
2634 TREE_CHAIN (t) = TREE_CHAIN (next);
2639 next = TREE_CHAIN (t);
2643 /* Write out needed type info variables. We have to be careful
2644 looping through unemitted decls, because emit_tinfo_decl may
2645 cause other variables to be needed. We stick new elements
2646 (and old elements that we may need to reconsider) at the end
2647 of the array, then shift them back to the beginning once we're
2650 n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
2651 for (i = 0; i < n_old; ++i)
2653 tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
2654 if (emit_tinfo_decl (tinfo_decl))
2657 VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
2660 /* The only elements we want to keep are the new ones. Copy
2661 them to the beginning of the array, then get rid of the
2663 n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
2665 memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
2666 &VARRAY_TREE (unemitted_tinfo_decls, n_old),
2667 n_new * sizeof (tree));
2668 memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
2669 0, n_old * sizeof (tree));
2670 VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
2672 /* The list of objects with static storage duration is built up
2673 in reverse order. We clear STATIC_AGGREGATES so that any new
2674 aggregates added during the initialization of these will be
2675 initialized in the correct order when we next come around the
2677 vars = prune_vars_needing_no_initialization (&static_aggregates);
2683 /* We need to start a new initialization function each time
2684 through the loop. That's because we need to know which
2685 vtables have been referenced, and TREE_SYMBOL_REFERENCED
2686 isn't computed until a function is finished, and written
2687 out. That's a deficiency in the back-end. When this is
2688 fixed, these initialization functions could all become
2689 inline, with resulting performance improvements. */
2692 /* Set the line and file, so that it is obviously not from
2694 input_location = locus;
2695 ssdf_body = start_static_storage_duration_function (ssdf_count);
2697 /* Make sure the back end knows about all the variables. */
2698 write_out_vars (vars);
2700 /* First generate code to do all the initializations. */
2701 for (v = vars; v; v = TREE_CHAIN (v))
2702 do_static_initialization (TREE_VALUE (v),
2705 /* Then, generate code to do all the destructions. Do these
2706 in reverse order so that the most recently constructed
2707 variable is the first destroyed. If we're using
2708 __cxa_atexit, then we don't need to do this; functions
2709 were registered at initialization time to destroy the
2711 if (!flag_use_cxa_atexit)
2713 vars = nreverse (vars);
2714 for (v = vars; v; v = TREE_CHAIN (v))
2715 do_static_destruction (TREE_VALUE (v));
2720 /* Finish up the static storage duration function for this
2722 input_location = locus;
2723 finish_static_storage_duration_function (ssdf_body);
2725 /* All those initializations and finalizations might cause
2726 us to need more inline functions, more template
2727 instantiations, etc. */
2733 for (i = 0; i < deferred_fns_used; ++i)
2735 tree decl = VARRAY_TREE (deferred_fns, i);
2737 if (! DECL_DECLARED_INLINE_P (decl) || ! TREE_USED (decl))
2740 /* Does it need synthesizing? */
2741 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
2743 && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
2745 /* Even though we're already at the top-level, we push
2746 there again. That way, when we pop back a few lines
2747 hence, all of our state is restored. Otherwise,
2748 finish_function doesn't clean things up, and we end
2749 up with CURRENT_FUNCTION_DECL set. */
2750 push_to_top_level ();
2751 synthesize_method (decl);
2752 pop_from_top_level ();
2756 if (!DECL_SAVED_TREE (decl))
2759 import_export_decl (decl);
2761 /* We lie to the back-end, pretending that some functions
2762 are not defined when they really are. This keeps these
2763 functions from being put out unnecessarily. But, we must
2764 stop lying when the functions are referenced, or if they
2765 are not comdat since they need to be put out now. This
2766 is done in a separate for cycle, because if some deferred
2767 function is contained in another deferred function later
2768 in deferred_fns varray, rest_of_compilation would skip
2769 this function and we really cannot expand the same
2771 if (DECL_NOT_REALLY_EXTERN (decl)
2772 && DECL_INITIAL (decl)
2773 && DECL_NEEDED_P (decl))
2774 DECL_EXTERNAL (decl) = 0;
2776 /* If we're going to need to write this function out, and
2777 there's already a body for it, create RTL for it now.
2778 (There might be no body if this is a method we haven't
2779 gotten around to synthesizing yet.) */
2780 if (!DECL_EXTERNAL (decl)
2781 && DECL_NEEDED_P (decl)
2782 && !TREE_ASM_WRITTEN (decl)
2783 && (!flag_unit_at_a_time
2784 || !cgraph_node (decl)->local.finalized))
2786 /* We will output the function; no longer consider it in this
2788 DECL_DEFER_OUTPUT (decl) = 0;
2789 /* Generate RTL for this function now that we know we
2791 expand_or_defer_fn (decl);
2792 /* If we're compiling -fsyntax-only pretend that this
2793 function has been written out so that we don't try to
2795 if (flag_syntax_only)
2796 TREE_ASM_WRITTEN (decl) = 1;
2801 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
2804 /* Static data members are just like namespace-scope globals. */
2805 for (i = 0; i < pending_statics_used; ++i)
2807 tree decl = VARRAY_TREE (pending_statics, i);
2808 if (var_finalized_p (decl))
2810 import_export_decl (decl);
2811 if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
2812 DECL_EXTERNAL (decl) = 0;
2815 && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
2816 pending_statics_used))
2819 if (cgraph_assemble_pending_functions ())
2824 /* All used inline functions must have a definition at this point. */
2825 for (i = 0; i < deferred_fns_used; ++i)
2827 tree decl = VARRAY_TREE (deferred_fns, i);
2829 if (!TREE_ASM_WRITTEN (decl) && !DECL_SAVED_TREE (decl)
2830 /* An explicit instantiation can be used to specify
2831 that the body is in another unit. It will have
2832 already verified there was a definition. */
2833 && !DECL_EXPLICIT_INSTANTIATION (decl))
2835 cp_warning_at ("inline function `%D' used but never defined", decl);
2836 /* This symbol is effectively an "extern" declaration now.
2837 This is not strictly necessary, but removes a duplicate
2839 TREE_PUBLIC (decl) = 1;
2844 /* We give C linkage to static constructors and destructors. */
2845 push_lang_context (lang_name_c);
2847 /* Generate initialization and destruction functions for all
2848 priorities for which they are required. */
2849 if (priority_info_map)
2850 splay_tree_foreach (priority_info_map,
2851 generate_ctor_and_dtor_functions_for_priority,
2857 generate_ctor_or_dtor_function (/*constructor_p=*/true,
2858 DEFAULT_INIT_PRIORITY, &locus);
2860 generate_ctor_or_dtor_function (/*constructor_p=*/false,
2861 DEFAULT_INIT_PRIORITY, &locus);
2864 /* We're done with the splay-tree now. */
2865 if (priority_info_map)
2866 splay_tree_delete (priority_info_map);
2868 /* We're done with static constructors, so we can go back to "C++"
2870 pop_lang_context ();
2872 if (flag_unit_at_a_time)
2874 cgraph_finalize_compilation_unit ();
2878 /* Emit mudflap static registration function. This must be done
2879 after all the user functions have been expanded. */
2881 mudflap_finish_file ();
2883 /* Now, issue warnings about static, but not defined, functions,
2884 etc., and emit debugging information. */
2885 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
2886 if (pending_statics)
2887 check_global_declarations (&VARRAY_TREE (pending_statics, 0),
2888 pending_statics_used);
2892 /* The entire file is now complete. If requested, dump everything
2896 FILE *stream = dump_begin (TDI_tu, &flags);
2900 dump_node (global_namespace, flags & ~TDF_SLIM, stream);
2901 dump_end (TDI_tu, stream);
2905 timevar_pop (TV_VARCONST);
2907 if (flag_detailed_statistics)
2909 dump_tree_statistics ();
2910 dump_time_statistics ();
2912 input_location = locus;
2914 #ifdef ENABLE_CHECKING
2915 validate_conversion_obstack ();
2916 #endif /* ENABLE_CHECKING */
2919 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
2920 function to call in parse-tree form; it has not yet been
2921 semantically analyzed. ARGS are the arguments to the function.
2922 They have already been semantically analyzed. */
2925 build_offset_ref_call_from_tree (tree fn, tree args)
2934 object = TREE_OPERAND (fn, 0);
2936 if (processing_template_decl)
2938 my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR
2939 || TREE_CODE (fn) == MEMBER_REF,
2941 if (type_dependent_expression_p (fn)
2942 || any_type_dependent_arguments_p (args))
2943 return build_min_nt (CALL_EXPR, fn, args, NULL_TREE);
2945 /* Transform the arguments and add the implicit "this"
2946 parameter. That must be done before the FN is transformed
2947 because we depend on the form of FN. */
2948 args = build_non_dependent_args (args);
2949 if (TREE_CODE (fn) == DOTSTAR_EXPR)
2950 object = build_unary_op (ADDR_EXPR, object, 0);
2951 object = build_non_dependent_expr (object);
2952 args = tree_cons (NULL_TREE, object, args);
2953 /* Now that the arguments are done, transform FN. */
2954 fn = build_non_dependent_expr (fn);
2957 /* A qualified name corresponding to a bound pointer-to-member is
2958 represented as an OFFSET_REF:
2960 struct B { void g(); };
2962 void B::g() { (this->*p)(); } */
2963 if (TREE_CODE (fn) == OFFSET_REF)
2965 tree object_addr = build_unary_op (ADDR_EXPR, object, 0);
2966 fn = TREE_OPERAND (fn, 1);
2967 fn = get_member_function_from_ptrfunc (&object_addr, fn);
2968 args = tree_cons (NULL_TREE, object_addr, args);
2971 expr = build_function_call (fn, args);
2972 if (processing_template_decl && expr != error_mark_node)
2973 return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args, NULL_TREE);
2979 check_default_args (tree x)
2981 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
2982 bool saw_def = false;
2983 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
2984 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
2986 if (TREE_PURPOSE (arg))
2990 cp_error_at ("default argument missing for parameter %P of `%+#D'",
2998 mark_used (tree decl)
3000 TREE_USED (decl) = 1;
3001 if (processing_template_decl || skip_evaluation)
3004 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
3005 && !TREE_ASM_WRITTEN (decl))
3006 /* Remember it, so we can check it was defined. */
3008 if (DECL_DEFERRED_FN (decl))
3010 DECL_DEFERRED_FN (decl) = 1;
3011 DECL_DEFER_OUTPUT (decl) = 1;
3013 VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
3015 VARRAY_PUSH_TREE (deferred_fns, decl);
3018 assemble_external (decl);
3020 /* Is it a synthesized method that needs to be synthesized? */
3021 if (TREE_CODE (decl) == FUNCTION_DECL
3022 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
3023 && DECL_ARTIFICIAL (decl)
3024 && !DECL_THUNK_P (decl)
3025 && ! DECL_INITIAL (decl)
3026 /* Kludge: don't synthesize for default args. */
3027 && current_function_decl)
3029 synthesize_method (decl);
3030 /* If we've already synthesized the method we don't need to
3031 instantiate it, so we can return right away. */
3035 /* If this is a function or variable that is an instance of some
3036 template, we now know that we will need to actually do the
3037 instantiation. We check that DECL is not an explicit
3038 instantiation because that is not checked in instantiate_decl. */
3039 if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
3040 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3041 && (!DECL_EXPLICIT_INSTANTIATION (decl)
3042 || (TREE_CODE (decl) == FUNCTION_DECL
3043 && DECL_INLINE (DECL_TEMPLATE_RESULT
3044 (template_for_substitution (decl))))))
3048 /* Normally, we put off instantiating functions in order to
3049 improve compile times. Maintaining a stack of active
3050 functions is expensive, and the inliner knows to
3051 instantiate any functions it might need.
3053 However, if instantiating this function might help us mark
3054 the current function TREE_NOTHROW, we go ahead and
3057 This is not needed for unit-at-a-time since we reorder the functions
3058 in topological order anyway.
3060 defer = (!flag_exceptions
3061 || flag_unit_at_a_time
3063 || TREE_CODE (decl) != FUNCTION_DECL
3064 /* If the called function can't throw, we don't need to
3065 generate its body to find that out. */
3066 || TREE_NOTHROW (decl)
3068 || !current_function_decl
3069 /* If we already know the current function can't throw,
3070 then we don't need to work hard to prove it. */
3071 || TREE_NOTHROW (current_function_decl)
3072 /* If we already know that the current function *can*
3073 throw, there's no point in gathering more
3075 || cp_function_chain->can_throw);
3077 instantiate_decl (decl, defer, /*undefined_ok=*/0);
3081 #include "gt-cp-decl2.h"