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, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
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 #include "tree-dump.h"
55 #include "pointer-set.h"
57 extern cpp_reader *parse_in;
59 /* This structure contains information about the initializations
60 and/or destructions required for a particular priority level. */
61 typedef struct priority_info_s {
62 /* Nonzero if there have been any initializations at this priority
63 throughout the translation unit. */
64 int initializations_p;
65 /* Nonzero if there have been any destructions at this priority
66 throughout the translation unit. */
70 static void mark_vtable_entries (tree);
71 static bool maybe_emit_vtables (tree);
72 static bool acceptable_java_type (tree);
73 static tree start_objects (int, int);
74 static void finish_objects (int, int, tree);
75 static tree start_static_storage_duration_function (unsigned);
76 static void finish_static_storage_duration_function (tree);
77 static priority_info get_priority_info (int);
78 static void do_static_initialization_or_destruction (tree, bool);
79 static void one_static_initialization_or_destruction (tree, tree, bool);
80 static void generate_ctor_or_dtor_function (bool, int, location_t *);
81 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
83 static tree prune_vars_needing_no_initialization (tree *);
84 static void write_out_vars (tree);
85 static void import_export_class (tree);
86 static tree get_guard_bits (tree);
87 static void determine_visibility_from_class (tree, tree);
88 static bool decl_defined_p (tree);
90 /* A list of static class variables. This is needed, because a
91 static class variable can be declared inside the class without
92 an initializer, and then initialized, statically, outside the class. */
93 static GTY(()) VEC(tree,gc) *pending_statics;
95 /* A list of functions which were declared inline, but which we
96 may need to emit outline anyway. */
97 static GTY(()) VEC(tree,gc) *deferred_fns;
99 /* A list of decls that use types with no linkage, which we need to make
101 static GTY(()) VEC(tree,gc) *no_linkage_decls;
103 /* Nonzero if we're done parsing and into end-of-file activities. */
109 /* Return a member function type (a METHOD_TYPE), given FNTYPE (a
110 FUNCTION_TYPE), CTYPE (class type), and QUALS (the cv-qualifiers
111 that apply to the function). */
114 build_memfn_type (tree fntype, tree ctype, cp_cv_quals quals)
120 if (fntype == error_mark_node || ctype == error_mark_node)
121 return error_mark_node;
123 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
124 || TREE_CODE (fntype) == METHOD_TYPE);
126 type_quals = quals & ~TYPE_QUAL_RESTRICT;
127 ctype = cp_build_qualified_type (ctype, type_quals);
128 raises = TYPE_RAISES_EXCEPTIONS (fntype);
129 attrs = TYPE_ATTRIBUTES (fntype);
130 fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),
131 (TREE_CODE (fntype) == METHOD_TYPE
132 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
133 : TYPE_ARG_TYPES (fntype)));
135 fntype = build_exception_variant (fntype, raises);
137 fntype = cp_build_type_attribute_variant (fntype, attrs);
142 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
146 cp_build_parm_decl (tree name, tree type)
148 tree parm = build_decl (input_location,
149 PARM_DECL, name, type);
150 /* DECL_ARG_TYPE is only used by the back end and the back end never
152 if (!processing_template_decl)
153 DECL_ARG_TYPE (parm) = type_passed_as (type);
155 /* If the type is a pack expansion, then we have a function
157 if (type && TREE_CODE (type) == TYPE_PACK_EXPANSION)
158 FUNCTION_PARAMETER_PACK_P (parm) = 1;
163 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
167 build_artificial_parm (tree name, tree type)
169 tree parm = cp_build_parm_decl (name, type);
170 DECL_ARTIFICIAL (parm) = 1;
171 /* All our artificial parms are implicitly `const'; they cannot be
173 TREE_READONLY (parm) = 1;
177 /* Constructors for types with virtual baseclasses need an "in-charge" flag
178 saying whether this constructor is responsible for initialization of
179 virtual baseclasses or not. All destructors also need this "in-charge"
180 flag, which additionally determines whether or not the destructor should
181 free the memory for the object.
183 This function adds the "in-charge" flag to member function FN if
184 appropriate. It is called from grokclassfn and tsubst.
185 FN must be either a constructor or destructor.
187 The in-charge flag follows the 'this' parameter, and is followed by the
188 VTT parm (if any), then the user-written parms. */
191 maybe_retrofit_in_chrg (tree fn)
193 tree basetype, arg_types, parms, parm, fntype;
195 /* If we've already add the in-charge parameter don't do it again. */
196 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
199 /* When processing templates we can't know, in general, whether or
200 not we're going to have virtual baseclasses. */
201 if (processing_template_decl)
204 /* We don't need an in-charge parameter for constructors that don't
205 have virtual bases. */
206 if (DECL_CONSTRUCTOR_P (fn)
207 && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
210 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
211 basetype = TREE_TYPE (TREE_VALUE (arg_types));
212 arg_types = TREE_CHAIN (arg_types);
214 parms = TREE_CHAIN (DECL_ARGUMENTS (fn));
216 /* If this is a subobject constructor or destructor, our caller will
217 pass us a pointer to our VTT. */
218 if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
220 parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
222 /* First add it to DECL_ARGUMENTS between 'this' and the real args... */
223 TREE_CHAIN (parm) = parms;
226 /* ...and then to TYPE_ARG_TYPES. */
227 arg_types = hash_tree_chain (vtt_parm_type, arg_types);
229 DECL_HAS_VTT_PARM_P (fn) = 1;
232 /* Then add the in-charge parm (before the VTT parm). */
233 parm = build_artificial_parm (in_charge_identifier, integer_type_node);
234 TREE_CHAIN (parm) = parms;
236 arg_types = hash_tree_chain (integer_type_node, arg_types);
238 /* Insert our new parameter(s) into the list. */
239 TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms;
241 /* And rebuild the function type. */
242 fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
244 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
245 fntype = build_exception_variant (fntype,
246 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
247 if (TYPE_ATTRIBUTES (TREE_TYPE (fn)))
248 fntype = (cp_build_type_attribute_variant
249 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (fn))));
250 TREE_TYPE (fn) = fntype;
252 /* Now we've got the in-charge parameter. */
253 DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
256 /* Classes overload their constituent function names automatically.
257 When a function name is declared in a record structure,
258 its name is changed to it overloaded name. Since names for
259 constructors and destructors can conflict, we place a leading
262 CNAME is the name of the class we are grokking for.
264 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
266 FLAGS contains bits saying what's special about today's
267 arguments. DTOR_FLAG == DESTRUCTOR.
269 If FUNCTION is a destructor, then we must add the `auto-delete' field
270 as a second parameter. There is some hair associated with the fact
271 that we must "declare" this variable in the manner consistent with the
272 way the rest of the arguments were declared.
274 QUALS are the qualifiers for the this pointer. */
277 grokclassfn (tree ctype, tree function, enum overload_flags flags)
279 tree fn_name = DECL_NAME (function);
281 /* Even within an `extern "C"' block, members get C++ linkage. See
282 [dcl.link] for details. */
283 SET_DECL_LANGUAGE (function, lang_cplusplus);
285 if (fn_name == NULL_TREE)
287 error ("name missing for member function");
288 fn_name = get_identifier ("<anonymous>");
289 DECL_NAME (function) = fn_name;
292 DECL_CONTEXT (function) = ctype;
294 if (flags == DTOR_FLAG)
295 DECL_DESTRUCTOR_P (function) = 1;
297 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
298 maybe_retrofit_in_chrg (function);
301 /* Create an ARRAY_REF, checking for the user doing things backwards
305 grok_array_decl (tree array_expr, tree index_exp)
309 tree orig_array_expr = array_expr;
310 tree orig_index_exp = index_exp;
312 if (error_operand_p (array_expr) || error_operand_p (index_exp))
313 return error_mark_node;
315 if (processing_template_decl)
317 if (type_dependent_expression_p (array_expr)
318 || type_dependent_expression_p (index_exp))
319 return build_min_nt (ARRAY_REF, array_expr, index_exp,
320 NULL_TREE, NULL_TREE);
321 array_expr = build_non_dependent_expr (array_expr);
322 index_exp = build_non_dependent_expr (index_exp);
325 type = TREE_TYPE (array_expr);
327 type = non_reference (type);
329 /* If they have an `operator[]', use that. */
330 if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp)))
331 expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
332 array_expr, index_exp, NULL_TREE,
333 /*overloaded_p=*/NULL, tf_warning_or_error);
338 /* Otherwise, create an ARRAY_REF for a pointer or array type.
339 It is a little-known fact that, if `a' is an array and `i' is
340 an int, you can write `i[a]', which means the same thing as
342 if (TREE_CODE (type) == ARRAY_TYPE)
345 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
347 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
350 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
352 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
354 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
357 if ((p1 && i2) && (i1 && p2))
358 error ("ambiguous conversion for array subscript");
361 array_expr = p1, index_exp = i2;
363 array_expr = p2, index_exp = i1;
366 error ("invalid types %<%T[%T]%> for array subscript",
367 type, TREE_TYPE (index_exp));
368 return error_mark_node;
371 if (array_expr == error_mark_node || index_exp == error_mark_node)
372 error ("ambiguous conversion for array subscript");
374 expr = build_array_ref (input_location, array_expr, index_exp);
376 if (processing_template_decl && expr != error_mark_node)
377 return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
378 NULL_TREE, NULL_TREE);
382 /* Given the cast expression EXP, checking out its validity. Either return
383 an error_mark_node if there was an unavoidable error, return a cast to
384 void for trying to delete a pointer w/ the value 0, or return the
385 call to delete. If DOING_VEC is true, we handle things differently
386 for doing an array delete.
387 Implements ARM $5.3.4. This is called from the parser. */
390 delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete)
394 if (exp == error_mark_node)
397 if (processing_template_decl)
399 t = build_min (DELETE_EXPR, void_type_node, exp, size);
400 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
401 DELETE_EXPR_USE_VEC (t) = doing_vec;
402 TREE_SIDE_EFFECTS (t) = 1;
406 /* An array can't have been allocated by new, so complain. */
407 if (TREE_CODE (exp) == VAR_DECL
408 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
409 warning (0, "deleting array %q#D", exp);
411 t = build_expr_type_conversion (WANT_POINTER, exp, true);
413 if (t == NULL_TREE || t == error_mark_node)
415 error ("type %q#T argument given to %<delete%>, expected pointer",
417 return error_mark_node;
420 type = TREE_TYPE (t);
422 /* As of Valley Forge, you can delete a pointer to const. */
424 /* You can't delete functions. */
425 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
427 error ("cannot delete a function. Only pointer-to-objects are "
428 "valid arguments to %<delete%>");
429 return error_mark_node;
432 /* Deleting ptr to void is undefined behavior [expr.delete/3]. */
433 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
435 warning (0, "deleting %qT is undefined", type);
439 /* Deleting a pointer with the value zero is valid and has no effect. */
440 if (integer_zerop (t))
441 return build1 (NOP_EXPR, void_type_node, t);
444 return build_vec_delete (t, /*maxindex=*/NULL_TREE,
445 sfk_deleting_destructor,
448 return build_delete (type, t, sfk_deleting_destructor,
449 LOOKUP_NORMAL, use_global_delete);
452 /* Report an error if the indicated template declaration is not the
453 sort of thing that should be a member template. */
456 check_member_template (tree tmpl)
460 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
461 decl = DECL_TEMPLATE_RESULT (tmpl);
463 if (TREE_CODE (decl) == FUNCTION_DECL
464 || (TREE_CODE (decl) == TYPE_DECL
465 && MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))))
467 /* The parser rejects template declarations in local classes. */
468 gcc_assert (!current_function_decl);
469 /* The parser rejects any use of virtual in a function template. */
470 gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL
471 && DECL_VIRTUAL_P (decl)));
473 /* The debug-information generating code doesn't know what to do
474 with member templates. */
475 DECL_IGNORED_P (tmpl) = 1;
478 error ("template declaration of %q#D", decl);
481 /* Return true iff TYPE is a valid Java parameter or return type. */
484 acceptable_java_type (tree type)
486 if (type == error_mark_node)
489 if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
491 if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
493 type = TREE_TYPE (type);
494 if (TREE_CODE (type) == RECORD_TYPE)
497 if (! TYPE_FOR_JAVA (type))
499 if (! CLASSTYPE_TEMPLATE_INFO (type))
501 args = CLASSTYPE_TI_ARGS (type);
502 i = TREE_VEC_LENGTH (args);
505 type = TREE_VEC_ELT (args, i);
506 if (TREE_CODE (type) == POINTER_TYPE)
507 type = TREE_TYPE (type);
508 if (! TYPE_FOR_JAVA (type))
517 /* For a METHOD in a Java class CTYPE, return true if
518 the parameter and return types are valid Java types.
519 Otherwise, print appropriate error messages, and return false. */
522 check_java_method (tree method)
525 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
526 tree ret_type = TREE_TYPE (TREE_TYPE (method));
528 if (!acceptable_java_type (ret_type))
530 error ("Java method %qD has non-Java return type %qT",
535 arg_types = TREE_CHAIN (arg_types);
536 if (DECL_HAS_IN_CHARGE_PARM_P (method))
537 arg_types = TREE_CHAIN (arg_types);
538 if (DECL_HAS_VTT_PARM_P (method))
539 arg_types = TREE_CHAIN (arg_types);
541 for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
543 tree type = TREE_VALUE (arg_types);
544 if (!acceptable_java_type (type))
546 if (type != error_mark_node)
547 error ("Java method %qD has non-Java parameter type %qT",
555 /* Sanity check: report error if this function FUNCTION is not
556 really a member of the class (CTYPE) it is supposed to belong to.
557 TEMPLATE_PARMS is used to specify the template parameters of a member
558 template passed as FUNCTION_DECL. If the member template is passed as a
559 TEMPLATE_DECL, it can be NULL since the parameters can be extracted
560 from the declaration. If the function is not a function template, it
562 It returns the original declaration for the function, NULL_TREE if
563 no declaration was found, error_mark_node if an error was emitted. */
566 check_classfn (tree ctype, tree function, tree template_parms)
572 if (DECL_USE_TEMPLATE (function)
573 && !(TREE_CODE (function) == TEMPLATE_DECL
574 && DECL_TEMPLATE_SPECIALIZATION (function))
575 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))
576 /* Since this is a specialization of a member template,
577 we're not going to find the declaration in the class.
580 struct S { template <typename T> void f(T); };
581 template <> void S::f(int);
583 we're not going to find `S::f(int)', but there's no
584 reason we should, either. We let our callers know we didn't
585 find the method, but we don't complain. */
588 /* Basic sanity check: for a template function, the template parameters
589 either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */
590 if (TREE_CODE (function) == TEMPLATE_DECL)
593 && !comp_template_parms (template_parms,
594 DECL_TEMPLATE_PARMS (function)))
596 error ("template parameter lists provided don't match the "
597 "template parameters of %qD", function);
598 return error_mark_node;
600 template_parms = DECL_TEMPLATE_PARMS (function);
603 /* OK, is this a definition of a member template? */
604 is_template = (template_parms != NULL_TREE);
606 /* We must enter the scope here, because conversion operators are
607 named by target type, and type equivalence relies on typenames
608 resolving within the scope of CTYPE. */
609 pushed_scope = push_scope (ctype);
610 ix = class_method_index_for_fn (complete_type (ctype), function);
613 VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);
614 tree fndecls, fndecl = 0;
616 const char *format = NULL;
618 for (fndecls = VEC_index (tree, methods, ix);
619 fndecls; fndecls = OVL_NEXT (fndecls))
623 fndecl = OVL_CURRENT (fndecls);
624 p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
625 p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
627 /* We cannot simply call decls_match because this doesn't
628 work for static member functions that are pretending to
629 be methods, and because the name may have been changed by
632 /* Get rid of the this parameter on functions that become
634 if (DECL_STATIC_FUNCTION_P (fndecl)
635 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
636 p1 = TREE_CHAIN (p1);
638 /* A member template definition only matches a member template
640 if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
643 if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
644 TREE_TYPE (TREE_TYPE (fndecl)))
645 && compparms (p1, p2)
647 || comp_template_parms (template_parms,
648 DECL_TEMPLATE_PARMS (fndecl)))
649 && (DECL_TEMPLATE_SPECIALIZATION (function)
650 == DECL_TEMPLATE_SPECIALIZATION (fndecl))
651 && (!DECL_TEMPLATE_SPECIALIZATION (function)
652 || (DECL_TI_TEMPLATE (function)
653 == DECL_TI_TEMPLATE (fndecl))))
659 pop_scope (pushed_scope);
660 return OVL_CURRENT (fndecls);
663 error_at (DECL_SOURCE_LOCATION (function),
664 "prototype for %q#D does not match any in class %qT",
666 is_conv_op = DECL_CONV_FN_P (fndecl);
669 ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
670 fndecls = VEC_index (tree, methods, ix);
673 fndecl = OVL_CURRENT (fndecls);
674 fndecls = OVL_NEXT (fndecls);
676 if (!fndecls && is_conv_op)
678 if (VEC_length (tree, methods) > (size_t) ++ix)
680 fndecls = VEC_index (tree, methods, ix);
681 if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
693 format = N_("candidates are: %+#D");
695 format = N_("candidate is: %+#D");
696 error (format, fndecl);
699 else if (!COMPLETE_TYPE_P (ctype))
700 cxx_incomplete_type_error (function, ctype);
702 error ("no %q#D member function declared in class %qT",
706 pop_scope (pushed_scope);
707 return error_mark_node;
710 /* DECL is a function with vague linkage. Remember it so that at the
711 end of the translation unit we can decide whether or not to emit
715 note_vague_linkage_fn (tree decl)
717 DECL_DEFER_OUTPUT (decl) = 1;
718 VEC_safe_push (tree, gc, deferred_fns, decl);
721 /* We have just processed the DECL, which is a static data member.
722 The other parameters are as for cp_finish_decl. */
725 finish_static_data_member_decl (tree decl,
726 tree init, bool init_const_expr_p,
730 DECL_CONTEXT (decl) = current_class_type;
732 /* We cannot call pushdecl here, because that would fill in the
733 TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
734 the right thing, namely, to put this decl out straight away. */
736 if (! processing_template_decl)
737 VEC_safe_push (tree, gc, pending_statics, decl);
739 if (LOCAL_CLASS_P (current_class_type))
740 permerror (input_location, "local class %q#T shall not have static data member %q#D",
741 current_class_type, decl);
743 /* Static consts need not be initialized in the class definition. */
744 if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
746 static int explained = 0;
748 error ("initializer invalid for static member with constructor");
751 error ("(an out of class initialization is required)");
757 DECL_INITIAL (decl) = init;
758 DECL_IN_AGGR_P (decl) = 1;
760 cp_finish_decl (decl, init, init_const_expr_p, asmspec_tree, flags);
763 /* DECLARATOR and DECLSPECS correspond to a class member. The other
764 parameters are as for cp_finish_decl. Return the DECL for the
765 class member declared. */
768 grokfield (const cp_declarator *declarator,
769 cp_decl_specifier_seq *declspecs,
770 tree init, bool init_const_expr_p,
775 const char *asmspec = 0;
776 int flags = LOOKUP_ONLYCONVERTING;
780 && TREE_CODE (init) == TREE_LIST
781 && TREE_VALUE (init) == error_mark_node
782 && TREE_CHAIN (init) == NULL_TREE)
785 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
786 if (! value || error_operand_p (value))
787 /* friend or constructor went bad. */
788 return error_mark_node;
790 if (TREE_CODE (value) == TYPE_DECL && init)
792 error ("typedef %qD is initialized (use decltype instead)", value);
796 /* Pass friendly classes back. */
797 if (value == void_type_node)
800 /* Pass friend decls back. */
801 if ((TREE_CODE (value) == FUNCTION_DECL
802 || TREE_CODE (value) == TEMPLATE_DECL)
803 && DECL_CONTEXT (value) != current_class_type)
806 name = DECL_NAME (value);
808 if (name != NULL_TREE)
810 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
812 error ("explicit template argument list not allowed");
813 return error_mark_node;
816 if (IDENTIFIER_POINTER (name)[0] == '_'
817 && ! strcmp (IDENTIFIER_POINTER (name), "_vptr"))
818 error ("member %qD conflicts with virtual function table field name",
822 /* Stash away type declarations. */
823 if (TREE_CODE (value) == TYPE_DECL)
825 DECL_NONLOCAL (value) = 1;
826 DECL_CONTEXT (value) = current_class_type;
828 if (processing_template_decl)
829 value = push_template_decl (value);
835 /* If this is a typedef that names the class for linkage purposes
836 (7.1.3p8), apply any attributes directly to the type. */
837 if (TAGGED_TYPE_P (TREE_TYPE (value))
838 && value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))))
839 attrflags = ATTR_FLAG_TYPE_IN_PLACE;
841 cplus_decl_attributes (&value, attrlist, attrflags);
844 if (declspecs->specs[(int)ds_typedef]
845 && TREE_TYPE (value) != error_mark_node
846 && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value)
847 set_underlying_type (value);
852 if (DECL_IN_AGGR_P (value))
854 error ("%qD is already defined in %qT", value, DECL_CONTEXT (value));
855 return void_type_node;
858 if (asmspec_tree && asmspec_tree != error_mark_node)
859 asmspec = TREE_STRING_POINTER (asmspec_tree);
863 if (TREE_CODE (value) == FUNCTION_DECL)
865 /* Initializers for functions are rejected early in the parser.
866 If we get here, it must be a pure specifier for a method. */
867 if (init == ridpointers[(int)RID_DELETE])
869 DECL_DELETED_FN (value) = 1;
870 DECL_DECLARED_INLINE_P (value) = 1;
871 DECL_INITIAL (value) = error_mark_node;
873 else if (init == ridpointers[(int)RID_DEFAULT])
875 if (defaultable_fn_check (value))
877 DECL_DEFAULTED_FN (value) = 1;
878 DECL_INITIALIZED_IN_CLASS_P (value) = 1;
879 DECL_DECLARED_INLINE_P (value) = 1;
882 else if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE)
884 gcc_assert (error_operand_p (init) || integer_zerop (init));
885 DECL_PURE_VIRTUAL_P (value) = 1;
889 gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE);
890 error ("initializer specified for static member function %qD",
894 else if (pedantic && TREE_CODE (value) != VAR_DECL)
895 /* Already complained in grokdeclarator. */
897 else if (!processing_template_decl)
899 if (TREE_CODE (init) == CONSTRUCTOR)
900 init = digest_init (TREE_TYPE (value), init);
902 init = integral_constant_value (init);
904 if (init != error_mark_node && !TREE_CONSTANT (init))
906 /* We can allow references to things that are effectively
907 static, since references are initialized with the
909 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
910 || (TREE_STATIC (init) == 0
911 && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
913 error ("field initializer is not constant");
914 init = error_mark_node;
920 if (processing_template_decl
921 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
923 value = push_template_decl (value);
924 if (error_operand_p (value))
925 return error_mark_node;
929 cplus_decl_attributes (&value, attrlist, 0);
931 switch (TREE_CODE (value))
934 finish_static_data_member_decl (value, init, init_const_expr_p,
935 asmspec_tree, flags);
940 error ("%<asm%> specifiers are not permitted on non-static data members");
941 if (DECL_INITIAL (value) == error_mark_node)
942 init = error_mark_node;
943 cp_finish_decl (value, init, /*init_const_expr_p=*/false,
945 DECL_INITIAL (value) = init;
946 DECL_IN_AGGR_P (value) = 1;
951 set_user_assembler_name (value, asmspec);
953 cp_finish_decl (value,
955 /*init_const_expr_p=*/false,
956 asmspec_tree, flags);
958 /* Pass friends back this way. */
959 if (DECL_FRIEND_P (value))
960 return void_type_node;
962 DECL_IN_AGGR_P (value) = 1;
971 /* Like `grokfield', but for bitfields.
972 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
975 grokbitfield (const cp_declarator *declarator,
976 cp_decl_specifier_seq *declspecs, tree width,
979 tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, &attrlist);
981 if (value == error_mark_node)
982 return NULL_TREE; /* friends went bad. */
984 /* Pass friendly classes back. */
985 if (TREE_CODE (value) == VOID_TYPE)
986 return void_type_node;
988 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))
989 && (POINTER_TYPE_P (value)
990 || !dependent_type_p (TREE_TYPE (value))))
992 error ("bit-field %qD with non-integral type", value);
993 return error_mark_node;
996 if (TREE_CODE (value) == TYPE_DECL)
998 error ("cannot declare %qD to be a bit-field type", value);
1002 /* Usually, finish_struct_1 catches bitfields with invalid types.
1003 But, in the case of bitfields with function type, we confuse
1004 ourselves into thinking they are member functions, so we must
1006 if (TREE_CODE (value) == FUNCTION_DECL)
1008 error ("cannot declare bit-field %qD with function type",
1013 if (DECL_IN_AGGR_P (value))
1015 error ("%qD is already defined in the class %qT", value,
1016 DECL_CONTEXT (value));
1017 return void_type_node;
1020 if (TREE_STATIC (value))
1022 error ("static member %qD cannot be a bit-field", value);
1025 cp_finish_decl (value, NULL_TREE, false, NULL_TREE, 0);
1027 if (width != error_mark_node)
1029 constant_expression_warning (width);
1030 DECL_INITIAL (value) = width;
1031 SET_DECL_C_BIT_FIELD (value);
1034 DECL_IN_AGGR_P (value) = 1;
1037 cplus_decl_attributes (&value, attrlist, /*flags=*/0);
1043 /* Returns true iff ATTR is an attribute which needs to be applied at
1044 instantiation time rather than template definition time. */
1047 is_late_template_attribute (tree attr, tree decl)
1049 tree name = TREE_PURPOSE (attr);
1050 tree args = TREE_VALUE (attr);
1051 const struct attribute_spec *spec = lookup_attribute_spec (name);
1055 /* Unknown attribute. */
1058 /* Attribute weak handling wants to write out assembly right away. */
1059 if (is_attribute_p ("weak", name))
1062 /* If any of the arguments are dependent expressions, we can't evaluate
1063 the attribute until instantiation time. */
1064 for (arg = args; arg; arg = TREE_CHAIN (arg))
1066 tree t = TREE_VALUE (arg);
1068 /* If the first attribute argument is an identifier, only consider
1069 second and following arguments. Attributes like mode, format,
1070 cleanup and several target specific attributes aren't late
1071 just because they have an IDENTIFIER_NODE as first argument. */
1072 if (arg == args && TREE_CODE (t) == IDENTIFIER_NODE)
1075 if (value_dependent_expression_p (t)
1076 || type_dependent_expression_p (t))
1080 if (TREE_CODE (decl) == TYPE_DECL
1082 || spec->type_required)
1084 tree type = TYPE_P (decl) ? decl : TREE_TYPE (decl);
1086 /* We can't apply any attributes to a completely unknown type until
1087 instantiation time. */
1088 enum tree_code code = TREE_CODE (type);
1089 if (code == TEMPLATE_TYPE_PARM
1090 || code == BOUND_TEMPLATE_TEMPLATE_PARM
1091 || code == TYPENAME_TYPE)
1093 /* Also defer most attributes on dependent types. This is not
1094 necessary in all cases, but is the better default. */
1095 else if (dependent_type_p (type)
1096 /* But attribute visibility specifically works on
1098 && !is_attribute_p ("visibility", name))
1107 /* ATTR_P is a list of attributes. Remove any attributes which need to be
1108 applied at instantiation time and return them. If IS_DEPENDENT is true,
1109 the declaration itself is dependent, so all attributes should be applied
1110 at instantiation time. */
1113 splice_template_attributes (tree *attr_p, tree decl)
1116 tree late_attrs = NULL_TREE;
1117 tree *q = &late_attrs;
1124 if (is_late_template_attribute (*p, decl))
1126 ATTR_IS_DEPENDENT (*p) = 1;
1128 *p = TREE_CHAIN (*p);
1129 q = &TREE_CHAIN (*q);
1133 p = &TREE_CHAIN (*p);
1139 /* Remove any late attributes from the list in ATTR_P and attach them to
1143 save_template_attributes (tree *attr_p, tree *decl_p)
1145 tree late_attrs = splice_template_attributes (attr_p, *decl_p);
1147 tree old_attrs = NULL_TREE;
1152 if (DECL_P (*decl_p))
1153 q = &DECL_ATTRIBUTES (*decl_p);
1155 q = &TYPE_ATTRIBUTES (*decl_p);
1159 /* Place the late attributes at the beginning of the attribute
1161 TREE_CHAIN (tree_last (late_attrs)) = *q;
1164 if (!DECL_P (*decl_p) && *decl_p == TYPE_MAIN_VARIANT (*decl_p))
1166 /* We've added new attributes directly to the main variant, so
1167 now we need to update all of the other variants to include
1168 these new attributes. */
1170 for (variant = TYPE_NEXT_VARIANT (*decl_p); variant;
1171 variant = TYPE_NEXT_VARIANT (variant))
1173 gcc_assert (TYPE_ATTRIBUTES (variant) == old_attrs);
1174 TYPE_ATTRIBUTES (variant) = TYPE_ATTRIBUTES (*decl_p);
1179 /* Like reconstruct_complex_type, but handle also template trees. */
1182 cp_reconstruct_complex_type (tree type, tree bottom)
1186 if (TREE_CODE (type) == POINTER_TYPE)
1188 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1189 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
1190 TYPE_REF_CAN_ALIAS_ALL (type));
1192 else if (TREE_CODE (type) == REFERENCE_TYPE)
1194 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1195 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
1196 TYPE_REF_CAN_ALIAS_ALL (type));
1198 else if (TREE_CODE (type) == ARRAY_TYPE)
1200 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1201 outer = build_cplus_array_type (inner, TYPE_DOMAIN (type));
1202 /* Don't call cp_build_qualified_type on ARRAY_TYPEs, the
1203 element type qualification will be handled by the recursive
1204 cp_reconstruct_complex_type call and cp_build_qualified_type
1205 for ARRAY_TYPEs changes the element type. */
1208 else if (TREE_CODE (type) == FUNCTION_TYPE)
1210 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1211 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
1213 else if (TREE_CODE (type) == METHOD_TYPE)
1215 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1216 /* The build_method_type_directly() routine prepends 'this' to argument list,
1217 so we must compensate by getting rid of it. */
1219 = build_method_type_directly
1220 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
1222 TREE_CHAIN (TYPE_ARG_TYPES (type)));
1224 else if (TREE_CODE (type) == OFFSET_TYPE)
1226 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1227 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
1232 if (TYPE_ATTRIBUTES (type))
1233 outer = cp_build_type_attribute_variant (outer, TYPE_ATTRIBUTES (type));
1234 return cp_build_qualified_type (outer, TYPE_QUALS (type));
1237 /* Like decl_attributes, but handle C++ complexity. */
1240 cplus_decl_attributes (tree *decl, tree attributes, int flags)
1242 if (*decl == NULL_TREE || *decl == void_type_node
1243 || *decl == error_mark_node
1244 || attributes == NULL_TREE)
1247 if (processing_template_decl)
1249 if (check_for_bare_parameter_packs (attributes))
1252 save_template_attributes (&attributes, decl);
1253 if (attributes == NULL_TREE)
1257 if (TREE_CODE (*decl) == TEMPLATE_DECL)
1258 decl = &DECL_TEMPLATE_RESULT (*decl);
1260 decl_attributes (decl, attributes, flags);
1262 if (TREE_CODE (*decl) == TYPE_DECL)
1263 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1266 /* Walks through the namespace- or function-scope anonymous union
1267 OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
1268 Returns one of the fields for use in the mangled name. */
1271 build_anon_union_vars (tree type, tree object)
1273 tree main_decl = NULL_TREE;
1276 /* Rather than write the code to handle the non-union case,
1277 just give an error. */
1278 if (TREE_CODE (type) != UNION_TYPE)
1279 error ("anonymous struct not inside named type");
1281 for (field = TYPE_FIELDS (type);
1283 field = TREE_CHAIN (field))
1288 if (DECL_ARTIFICIAL (field))
1290 if (TREE_CODE (field) != FIELD_DECL)
1292 permerror (input_location, "%q+#D invalid; an anonymous union can only "
1293 "have non-static data members", field);
1297 if (TREE_PRIVATE (field))
1298 permerror (input_location, "private member %q+#D in anonymous union", field);
1299 else if (TREE_PROTECTED (field))
1300 permerror (input_location, "protected member %q+#D in anonymous union", field);
1302 if (processing_template_decl)
1303 ref = build_min_nt (COMPONENT_REF, object,
1304 DECL_NAME (field), NULL_TREE);
1306 ref = build_class_member_access_expr (object, field, NULL_TREE,
1307 false, tf_warning_or_error);
1309 if (DECL_NAME (field))
1313 decl = build_decl (input_location,
1314 VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
1315 DECL_ANON_UNION_VAR_P (decl) = 1;
1317 base = get_base_address (object);
1318 TREE_PUBLIC (decl) = TREE_PUBLIC (base);
1319 TREE_STATIC (decl) = TREE_STATIC (base);
1320 DECL_EXTERNAL (decl) = DECL_EXTERNAL (base);
1322 SET_DECL_VALUE_EXPR (decl, ref);
1323 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1325 decl = pushdecl (decl);
1327 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1328 decl = build_anon_union_vars (TREE_TYPE (field), ref);
1332 if (main_decl == NULL_TREE)
1339 /* Finish off the processing of a UNION_TYPE structure. If the union is an
1340 anonymous union, then all members must be laid out together. PUBLIC_P
1341 is nonzero if this union is not declared static. */
1344 finish_anon_union (tree anon_union_decl)
1350 if (anon_union_decl == error_mark_node)
1353 type = TREE_TYPE (anon_union_decl);
1354 public_p = TREE_PUBLIC (anon_union_decl);
1356 /* The VAR_DECL's context is the same as the TYPE's context. */
1357 DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1359 if (TYPE_FIELDS (type) == NULL_TREE)
1364 error ("namespace-scope anonymous aggregates must be static");
1368 main_decl = build_anon_union_vars (type, anon_union_decl);
1369 if (main_decl == error_mark_node)
1371 if (main_decl == NULL_TREE)
1373 warning (0, "anonymous union with no members");
1377 if (!processing_template_decl)
1379 /* Use main_decl to set the mangled name. */
1380 DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
1381 maybe_commonize_var (anon_union_decl);
1382 mangle_decl (anon_union_decl);
1383 DECL_NAME (anon_union_decl) = NULL_TREE;
1386 pushdecl (anon_union_decl);
1387 if (building_stmt_tree ()
1388 && at_function_scope_p ())
1389 add_decl_expr (anon_union_decl);
1390 else if (!processing_template_decl)
1391 rest_of_decl_compilation (anon_union_decl,
1392 toplevel_bindings_p (), at_eof);
1395 /* Auxiliary functions to make type signatures for
1396 `operator new' and `operator delete' correspond to
1397 what compiler will be expecting. */
1400 coerce_new_type (tree type)
1403 tree args = TYPE_ARG_TYPES (type);
1405 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
1407 if (!same_type_p (TREE_TYPE (type), ptr_type_node))
1410 error ("%<operator new%> must return type %qT", ptr_type_node);
1413 if (args && args != void_list_node)
1415 if (TREE_PURPOSE (args))
1417 /* [basic.stc.dynamic.allocation]
1419 The first parameter shall not have an associated default
1421 error ("the first parameter of %<operator new%> cannot "
1422 "have a default argument");
1423 /* Throw away the default argument. */
1424 TREE_PURPOSE (args) = NULL_TREE;
1427 if (!same_type_p (TREE_VALUE (args), size_type_node))
1430 args = TREE_CHAIN (args);
1437 permerror (input_location, "%<operator new%> takes type %<size_t%> (%qT) "
1438 "as first parameter", size_type_node);
1443 args = tree_cons (NULL_TREE, size_type_node, args);
1446 type = build_exception_variant
1447 (build_function_type (ptr_type_node, args),
1448 TYPE_RAISES_EXCEPTIONS (type));
1456 coerce_delete_type (tree type)
1459 tree args = TYPE_ARG_TYPES (type);
1461 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
1463 if (!same_type_p (TREE_TYPE (type), void_type_node))
1466 error ("%<operator delete%> must return type %qT", void_type_node);
1469 if (!args || args == void_list_node
1470 || !same_type_p (TREE_VALUE (args), ptr_type_node))
1473 if (args && args != void_list_node)
1474 args = TREE_CHAIN (args);
1475 error ("%<operator delete%> takes type %qT as first parameter",
1481 args = tree_cons (NULL_TREE, ptr_type_node, args);
1484 type = build_exception_variant
1485 (build_function_type (void_type_node, args),
1486 TYPE_RAISES_EXCEPTIONS (type));
1494 /* DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
1495 and mark them as needed. */
1498 mark_vtable_entries (tree decl)
1501 unsigned HOST_WIDE_INT idx;
1503 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
1508 STRIP_NOPS (fnaddr);
1510 if (TREE_CODE (fnaddr) != ADDR_EXPR
1511 && TREE_CODE (fnaddr) != FDESC_EXPR)
1512 /* This entry is an offset: a virtual base class offset, a
1513 virtual call offset, an RTTI offset, etc. */
1516 fn = TREE_OPERAND (fnaddr, 0);
1517 TREE_ADDRESSABLE (fn) = 1;
1518 /* When we don't have vcall offsets, we output thunks whenever
1519 we output the vtables that contain them. With vcall offsets,
1520 we know all the thunks we'll need when we emit a virtual
1521 function, so we emit the thunks there instead. */
1522 if (DECL_THUNK_P (fn))
1523 use_thunk (fn, /*emit_p=*/0);
1528 /* Set DECL up to have the closest approximation of "initialized common"
1529 linkage available. */
1532 comdat_linkage (tree decl)
1535 make_decl_one_only (decl, cxx_comdat_group (decl));
1536 else if (TREE_CODE (decl) == FUNCTION_DECL
1537 || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1538 /* We can just emit function and compiler-generated variables
1539 statically; having multiple copies is (for the most part) only
1542 There are two correctness issues, however: the address of a
1543 template instantiation with external linkage should be the
1544 same, independent of what translation unit asks for the
1545 address, and this will not hold when we emit multiple copies of
1546 the function. However, there's little else we can do.
1548 Also, by default, the typeinfo implementation assumes that
1549 there will be only one copy of the string used as the name for
1550 each type. Therefore, if weak symbols are unavailable, the
1551 run-time library should perform a more conservative check; it
1552 should perform a string comparison, rather than an address
1554 TREE_PUBLIC (decl) = 0;
1557 /* Static data member template instantiations, however, cannot
1558 have multiple copies. */
1559 if (DECL_INITIAL (decl) == 0
1560 || DECL_INITIAL (decl) == error_mark_node)
1561 DECL_COMMON (decl) = 1;
1562 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1564 DECL_COMMON (decl) = 1;
1565 DECL_INITIAL (decl) = error_mark_node;
1567 else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1569 /* We can't do anything useful; leave vars for explicit
1571 DECL_EXTERNAL (decl) = 1;
1572 DECL_NOT_REALLY_EXTERN (decl) = 0;
1576 if (DECL_LANG_SPECIFIC (decl))
1577 DECL_COMDAT (decl) = 1;
1580 /* For win32 we also want to put explicit instantiations in
1581 linkonce sections, so that they will be merged with implicit
1582 instantiations; otherwise we get duplicate symbol errors.
1583 For Darwin we do not want explicit instantiations to be
1587 maybe_make_one_only (tree decl)
1589 /* We used to say that this was not necessary on targets that support weak
1590 symbols, because the implicit instantiations will defer to the explicit
1591 one. However, that's not actually the case in SVR4; a strong definition
1592 after a weak one is an error. Also, not making explicit
1593 instantiations one_only means that we can end up with two copies of
1594 some template instantiations. */
1598 /* We can't set DECL_COMDAT on functions, or cp_finish_file will think
1599 we can get away with not emitting them if they aren't used. We need
1600 to for variables so that cp_finish_decl will update their linkage,
1601 because their DECL_INITIAL may not have been set properly yet. */
1603 if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
1604 || (! DECL_EXPLICIT_INSTANTIATION (decl)
1605 && ! DECL_TEMPLATE_SPECIALIZATION (decl)))
1607 make_decl_one_only (decl, cxx_comdat_group (decl));
1609 if (TREE_CODE (decl) == VAR_DECL)
1611 DECL_COMDAT (decl) = 1;
1612 /* Mark it needed so we don't forget to emit it. */
1613 mark_decl_referenced (decl);
1618 /* Returns true iff DECL, a FUNCTION_DECL, has vague linkage. This
1619 predicate will give the right answer during parsing of the function,
1620 which other tests may not. */
1623 vague_linkage_fn_p (tree fn)
1625 /* Unfortunately, import_export_decl has not always been called
1626 before the function is processed, so we cannot simply check
1628 return (DECL_COMDAT (fn)
1629 || ((DECL_DECLARED_INLINE_P (fn)
1630 || DECL_TEMPLATE_INSTANTIATION (fn))
1631 && TREE_PUBLIC (fn)));
1634 /* Determine whether or not we want to specifically import or export CTYPE,
1635 using various heuristics. */
1638 import_export_class (tree ctype)
1640 /* -1 for imported, 1 for exported. */
1641 int import_export = 0;
1643 /* It only makes sense to call this function at EOF. The reason is
1644 that this function looks at whether or not the first non-inline
1645 non-abstract virtual member function has been defined in this
1646 translation unit. But, we can't possibly know that until we've
1647 seen the entire translation unit. */
1648 gcc_assert (at_eof);
1650 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1653 /* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,
1654 we will have CLASSTYPE_INTERFACE_ONLY set but not
1655 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
1656 heuristic because someone will supply a #pragma implementation
1657 elsewhere, and deducing it here would produce a conflict. */
1658 if (CLASSTYPE_INTERFACE_ONLY (ctype))
1661 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1663 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1665 else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1666 && !flag_implicit_templates)
1667 /* For a template class, without -fimplicit-templates, check the
1668 repository. If the virtual table is assigned to this
1669 translation unit, then export the class; otherwise, import
1671 import_export = repo_export_class_p (ctype) ? 1 : -1;
1672 else if (TYPE_POLYMORPHIC_P (ctype))
1674 /* The ABI specifies that the virtual table and associated
1675 information are emitted with the key method, if any. */
1676 tree method = CLASSTYPE_KEY_METHOD (ctype);
1677 /* If weak symbol support is not available, then we must be
1678 careful not to emit the vtable when the key function is
1679 inline. An inline function can be defined in multiple
1680 translation units. If we were to emit the vtable in each
1681 translation unit containing a definition, we would get
1682 multiple definition errors at link-time. */
1683 if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method)))
1684 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1687 /* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing
1688 a definition anywhere else. */
1689 if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
1692 /* Allow back ends the chance to overrule the decision. */
1693 if (targetm.cxx.import_export_class)
1694 import_export = targetm.cxx.import_export_class (ctype, import_export);
1698 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1699 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1703 /* Return true if VAR has already been provided to the back end; in that
1704 case VAR should not be modified further by the front end. */
1706 var_finalized_p (tree var)
1708 return varpool_node (var)->finalized;
1711 /* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
1712 must be emitted in this translation unit. Mark it as such. */
1715 mark_needed (tree decl)
1717 /* It's possible that we no longer need to set
1718 TREE_SYMBOL_REFERENCED here directly, but doing so is
1720 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
1721 mark_decl_referenced (decl);
1724 /* DECL is either a FUNCTION_DECL or a VAR_DECL. This function
1725 returns true if a definition of this entity should be provided in
1726 this object file. Callers use this function to determine whether
1727 or not to let the back end know that a definition of DECL is
1728 available in this translation unit. */
1731 decl_needed_p (tree decl)
1733 gcc_assert (TREE_CODE (decl) == VAR_DECL
1734 || TREE_CODE (decl) == FUNCTION_DECL);
1735 /* This function should only be called at the end of the translation
1736 unit. We cannot be sure of whether or not something will be
1737 COMDAT until that point. */
1738 gcc_assert (at_eof);
1740 /* All entities with external linkage that are not COMDAT should be
1741 emitted; they may be referred to from other object files. */
1742 if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1744 /* If this entity was used, let the back end see it; it will decide
1745 whether or not to emit it into the object file. */
1746 if (TREE_USED (decl)
1747 || (DECL_ASSEMBLER_NAME_SET_P (decl)
1748 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1750 /* Functions marked "dllexport" must be emitted so that they are
1751 visible to other DLLs. */
1752 if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
1754 /* Otherwise, DECL does not need to be emitted -- yet. A subsequent
1755 reference to DECL might cause it to be emitted later. */
1759 /* If necessary, write out the vtables for the dynamic class CTYPE.
1760 Returns true if any vtables were emitted. */
1763 maybe_emit_vtables (tree ctype)
1769 /* If the vtables for this class have already been emitted there is
1770 nothing more to do. */
1771 primary_vtbl = CLASSTYPE_VTABLES (ctype);
1772 if (var_finalized_p (primary_vtbl))
1774 /* Ignore dummy vtables made by get_vtable_decl. */
1775 if (TREE_TYPE (primary_vtbl) == void_type_node)
1778 /* On some targets, we cannot determine the key method until the end
1779 of the translation unit -- which is when this function is
1781 if (!targetm.cxx.key_method_may_be_inline ())
1782 determine_key_method (ctype);
1784 /* See if any of the vtables are needed. */
1785 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1787 import_export_decl (vtbl);
1788 if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
1793 /* If the references to this class' vtables are optimized away,
1794 still emit the appropriate debugging information. See
1796 if (DECL_COMDAT (primary_vtbl)
1797 && CLASSTYPE_DEBUG_REQUESTED (ctype))
1798 note_debug_info_needed (ctype);
1802 /* The ABI requires that we emit all of the vtables if we emit any
1804 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1806 /* Mark entities references from the virtual table as used. */
1807 mark_vtable_entries (vtbl);
1809 if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1811 tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), LOOKUP_NORMAL);
1813 /* It had better be all done at compile-time. */
1818 DECL_EXTERNAL (vtbl) = 0;
1819 rest_of_decl_compilation (vtbl, 1, 1);
1821 /* Because we're only doing syntax-checking, we'll never end up
1822 actually marking the variable as written. */
1823 if (flag_syntax_only)
1824 TREE_ASM_WRITTEN (vtbl) = 1;
1827 /* Since we're writing out the vtable here, also write the debug
1829 note_debug_info_needed (ctype);
1834 /* A special return value from type_visibility meaning internal
1837 enum { VISIBILITY_ANON = VISIBILITY_INTERNAL+1 };
1839 /* walk_tree helper function for type_visibility. */
1842 min_vis_r (tree *tp, int *walk_subtrees, void *data)
1844 int *vis_p = (int *)data;
1849 else if (CLASS_TYPE_P (*tp))
1851 if (!TREE_PUBLIC (TYPE_MAIN_DECL (*tp)))
1853 *vis_p = VISIBILITY_ANON;
1856 else if (CLASSTYPE_VISIBILITY (*tp) > *vis_p)
1857 *vis_p = CLASSTYPE_VISIBILITY (*tp);
1862 /* Returns the visibility of TYPE, which is the minimum visibility of its
1866 type_visibility (tree type)
1868 int vis = VISIBILITY_DEFAULT;
1869 cp_walk_tree_without_duplicates (&type, min_vis_r, &vis);
1873 /* Limit the visibility of DECL to VISIBILITY, if not explicitly
1874 specified (or if VISIBILITY is static). */
1877 constrain_visibility (tree decl, int visibility)
1879 if (visibility == VISIBILITY_ANON)
1881 /* extern "C" declarations aren't affected by the anonymous
1883 if (!DECL_EXTERN_C_P (decl))
1885 TREE_PUBLIC (decl) = 0;
1886 DECL_COMDAT_GROUP (decl) = NULL_TREE;
1887 DECL_INTERFACE_KNOWN (decl) = 1;
1888 if (DECL_LANG_SPECIFIC (decl))
1889 DECL_NOT_REALLY_EXTERN (decl) = 1;
1892 else if (visibility > DECL_VISIBILITY (decl)
1893 && !DECL_VISIBILITY_SPECIFIED (decl))
1895 DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility;
1901 /* Constrain the visibility of DECL based on the visibility of its template
1905 constrain_visibility_for_template (tree decl, tree targs)
1907 /* If this is a template instantiation, check the innermost
1908 template args for visibility constraints. The outer template
1909 args are covered by the class check. */
1910 tree args = INNERMOST_TEMPLATE_ARGS (targs);
1912 for (i = TREE_VEC_LENGTH (args); i > 0; --i)
1916 tree arg = TREE_VEC_ELT (args, i-1);
1918 vis = type_visibility (arg);
1919 else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
1922 if (TREE_CODE (arg) == ADDR_EXPR)
1923 arg = TREE_OPERAND (arg, 0);
1924 if (TREE_CODE (arg) == VAR_DECL
1925 || TREE_CODE (arg) == FUNCTION_DECL)
1927 if (! TREE_PUBLIC (arg))
1928 vis = VISIBILITY_ANON;
1930 vis = DECL_VISIBILITY (arg);
1934 constrain_visibility (decl, vis);
1938 /* Like c_determine_visibility, but with additional C++-specific
1941 Function-scope entities can rely on the function's visibility because
1942 it is set in start_preparsed_function.
1944 Class-scope entities cannot rely on the class's visibility until the end
1945 of the enclosing class definition.
1947 Note that because namespaces have multiple independent definitions,
1948 namespace visibility is handled elsewhere using the #pragma visibility
1949 machinery rather than by decorating the namespace declaration.
1951 The goal is for constraints from the type to give a diagnostic, and
1952 other constraints to be applied silently. */
1955 determine_visibility (tree decl)
1957 tree class_type = NULL_TREE;
1959 bool orig_visibility_specified;
1960 enum symbol_visibility orig_visibility;
1962 /* Remember that all decls get VISIBILITY_DEFAULT when built. */
1964 /* Only relevant for names with external linkage. */
1965 if (!TREE_PUBLIC (decl))
1968 /* Cloned constructors and destructors get the same visibility as
1969 the underlying function. That should be set up in
1970 maybe_clone_body. */
1971 gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
1973 orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl);
1974 orig_visibility = DECL_VISIBILITY (decl);
1976 if (TREE_CODE (decl) == TYPE_DECL)
1978 if (CLASS_TYPE_P (TREE_TYPE (decl)))
1979 use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
1980 else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
1985 else if (DECL_LANG_SPECIFIC (decl))
1986 use_template = DECL_USE_TEMPLATE (decl);
1990 /* If DECL is a member of a class, visibility specifiers on the
1991 class can influence the visibility of the DECL. */
1992 if (DECL_CLASS_SCOPE_P (decl))
1993 class_type = DECL_CONTEXT (decl);
1996 /* Not a class member. */
1998 /* Virtual tables have DECL_CONTEXT set to their associated class,
1999 so they are automatically handled above. */
2000 gcc_assert (TREE_CODE (decl) != VAR_DECL
2001 || !DECL_VTABLE_OR_VTT_P (decl));
2003 if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
2005 /* Local statics and classes get the visibility of their
2006 containing function by default, except that
2007 -fvisibility-inlines-hidden doesn't affect them. */
2008 tree fn = DECL_CONTEXT (decl);
2009 if (DECL_VISIBILITY_SPECIFIED (fn) || ! DECL_CLASS_SCOPE_P (fn))
2011 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
2012 DECL_VISIBILITY_SPECIFIED (decl) =
2013 DECL_VISIBILITY_SPECIFIED (fn);
2016 determine_visibility_from_class (decl, DECL_CONTEXT (fn));
2018 /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
2019 but have no TEMPLATE_INFO, so don't try to check it. */
2022 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl)
2023 && flag_visibility_ms_compat)
2025 /* Under -fvisibility-ms-compat, types are visible by default,
2026 even though their contents aren't. */
2027 tree underlying_type = TREE_TYPE (DECL_NAME (decl));
2028 int underlying_vis = type_visibility (underlying_type);
2029 if (underlying_vis == VISIBILITY_ANON
2030 || CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type))
2031 constrain_visibility (decl, underlying_vis);
2033 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
2035 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2037 /* tinfo visibility is based on the type it's for. */
2038 constrain_visibility
2039 (decl, type_visibility (TREE_TYPE (DECL_NAME (decl))));
2041 /* Give the target a chance to override the visibility associated
2043 if (TREE_PUBLIC (decl)
2044 && !DECL_REALLY_EXTERN (decl)
2045 && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl)))
2046 && !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl))))
2047 targetm.cxx.determine_class_data_visibility (decl);
2049 else if (use_template)
2050 /* Template instantiations and specializations get visibility based
2051 on their template unless they override it with an attribute. */;
2052 else if (! DECL_VISIBILITY_SPECIFIED (decl))
2054 /* Set default visibility to whatever the user supplied with
2055 #pragma GCC visibility or a namespace visibility attribute. */
2056 DECL_VISIBILITY (decl) = default_visibility;
2057 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
2063 /* If the specialization doesn't specify visibility, use the
2064 visibility from the template. */
2065 tree tinfo = (TREE_CODE (decl) == TYPE_DECL
2066 ? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2067 : DECL_TEMPLATE_INFO (decl));
2068 tree args = TI_ARGS (tinfo);
2070 if (args != error_mark_node)
2072 int depth = TMPL_ARGS_DEPTH (args);
2073 tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
2075 if (!DECL_VISIBILITY_SPECIFIED (decl))
2077 DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
2078 DECL_VISIBILITY_SPECIFIED (decl)
2079 = DECL_VISIBILITY_SPECIFIED (pattern);
2082 /* FIXME should TMPL_ARGS_DEPTH really return 1 for null input? */
2083 if (args && depth > template_class_depth (class_type))
2084 /* Limit visibility based on its template arguments. */
2085 constrain_visibility_for_template (decl, args);
2090 determine_visibility_from_class (decl, class_type);
2092 if (decl_anon_ns_mem_p (decl))
2093 /* Names in an anonymous namespace get internal linkage.
2094 This might change once we implement export. */
2095 constrain_visibility (decl, VISIBILITY_ANON);
2096 else if (TREE_CODE (decl) != TYPE_DECL)
2098 /* Propagate anonymity from type to decl. */
2099 int tvis = type_visibility (TREE_TYPE (decl));
2100 if (tvis == VISIBILITY_ANON
2101 || ! DECL_VISIBILITY_SPECIFIED (decl))
2102 constrain_visibility (decl, tvis);
2104 else if (no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/true))
2105 /* DR 757: A type without linkage shall not be used as the type of a
2106 variable or function with linkage, unless
2107 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
2108 o the variable or function is not used (3.2 [basic.def.odr]) or is
2109 defined in the same translation unit.
2111 Since non-extern "C" decls need to be defined in the same
2112 translation unit, we can make the type internal. */
2113 constrain_visibility (decl, VISIBILITY_ANON);
2115 /* If visibility changed and DECL already has DECL_RTL, ensure
2116 symbol flags are updated. */
2117 if ((DECL_VISIBILITY (decl) != orig_visibility
2118 || DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified)
2119 && ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
2120 || TREE_CODE (decl) == FUNCTION_DECL)
2121 && DECL_RTL_SET_P (decl))
2122 make_decl_rtl (decl);
2125 /* By default, static data members and function members receive
2126 the visibility of their containing class. */
2129 determine_visibility_from_class (tree decl, tree class_type)
2131 if (DECL_VISIBILITY_SPECIFIED (decl))
2134 if (visibility_options.inlines_hidden
2135 /* Don't do this for inline templates; specializations might not be
2136 inline, and we don't want them to inherit the hidden
2137 visibility. We'll set it here for all inline instantiations. */
2138 && !processing_template_decl
2139 && TREE_CODE (decl) == FUNCTION_DECL
2140 && DECL_DECLARED_INLINE_P (decl)
2141 && (! DECL_LANG_SPECIFIC (decl)
2142 || ! DECL_EXPLICIT_INSTANTIATION (decl)))
2143 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2146 /* Default to the class visibility. */
2147 DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
2148 DECL_VISIBILITY_SPECIFIED (decl)
2149 = CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
2152 /* Give the target a chance to override the visibility associated
2154 if (TREE_CODE (decl) == VAR_DECL
2155 && (DECL_TINFO_P (decl)
2156 || (DECL_VTABLE_OR_VTT_P (decl)
2157 /* Construction virtual tables are not exported because
2158 they cannot be referred to from other object files;
2159 their name is not standardized by the ABI. */
2160 && !DECL_CONSTRUCTION_VTABLE_P (decl)))
2161 && TREE_PUBLIC (decl)
2162 && !DECL_REALLY_EXTERN (decl)
2163 && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
2164 targetm.cxx.determine_class_data_visibility (decl);
2167 /* Constrain the visibility of a class TYPE based on the visibility of its
2168 field types. Warn if any fields require lesser visibility. */
2171 constrain_class_visibility (tree type)
2177 int vis = type_visibility (type);
2179 if (vis == VISIBILITY_ANON
2180 || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
2183 /* Don't warn about visibility if the class has explicit visibility. */
2184 if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
2185 vis = VISIBILITY_INTERNAL;
2187 for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
2188 if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
2190 tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
2191 int subvis = type_visibility (ftype);
2193 if (subvis == VISIBILITY_ANON)
2195 if (!in_main_input_context ())
2197 %qT has a field %qD whose type uses the anonymous namespace",
2200 else if (MAYBE_CLASS_TYPE_P (ftype)
2201 && vis < VISIBILITY_HIDDEN
2202 && subvis >= VISIBILITY_HIDDEN)
2203 warning (OPT_Wattributes, "\
2204 %qT declared with greater visibility than the type of its field %qD",
2208 binfo = TYPE_BINFO (type);
2209 for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
2211 int subvis = type_visibility (TREE_TYPE (t));
2213 if (subvis == VISIBILITY_ANON)
2215 if (!in_main_input_context())
2217 %qT has a base %qT whose type uses the anonymous namespace",
2218 type, TREE_TYPE (t));
2220 else if (vis < VISIBILITY_HIDDEN
2221 && subvis >= VISIBILITY_HIDDEN)
2222 warning (OPT_Wattributes, "\
2223 %qT declared with greater visibility than its base %qT",
2224 type, TREE_TYPE (t));
2228 /* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage
2229 for DECL has not already been determined, do so now by setting
2230 DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this
2231 function is called entities with vague linkage whose definitions
2232 are available must have TREE_PUBLIC set.
2234 If this function decides to place DECL in COMDAT, it will set
2235 appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
2236 the caller to decide whether or not to clear DECL_EXTERNAL. Some
2237 callers defer that decision until it is clear that DECL is actually
2241 import_export_decl (tree decl)
2246 tree class_type = NULL_TREE;
2248 if (DECL_INTERFACE_KNOWN (decl))
2251 /* We cannot determine what linkage to give to an entity with vague
2252 linkage until the end of the file. For example, a virtual table
2253 for a class will be defined if and only if the key method is
2254 defined in this translation unit. As a further example, consider
2255 that when compiling a translation unit that uses PCH file with
2256 "-frepo" it would be incorrect to make decisions about what
2257 entities to emit when building the PCH; those decisions must be
2258 delayed until the repository information has been processed. */
2259 gcc_assert (at_eof);
2260 /* Object file linkage for explicit instantiations is handled in
2261 mark_decl_instantiated. For static variables in functions with
2262 vague linkage, maybe_commonize_var is used.
2264 Therefore, the only declarations that should be provided to this
2265 function are those with external linkage that are:
2267 * implicit instantiations of function templates
2271 * implicit instantiations of static data members of class
2278 Furthermore, all entities that reach this point must have a
2279 definition available in this translation unit.
2281 The following assertions check these conditions. */
2282 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
2283 || TREE_CODE (decl) == VAR_DECL);
2284 /* Any code that creates entities with TREE_PUBLIC cleared should
2285 also set DECL_INTERFACE_KNOWN. */
2286 gcc_assert (TREE_PUBLIC (decl));
2287 if (TREE_CODE (decl) == FUNCTION_DECL)
2288 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2289 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
2290 || DECL_DECLARED_INLINE_P (decl));
2292 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2293 || DECL_VTABLE_OR_VTT_P (decl)
2294 || DECL_TINFO_P (decl));
2295 /* Check that a definition of DECL is available in this translation
2297 gcc_assert (!DECL_REALLY_EXTERN (decl));
2299 /* Assume that DECL will not have COMDAT linkage. */
2301 /* Assume that DECL will not be imported into this translation
2305 /* See if the repository tells us whether or not to emit DECL in
2306 this translation unit. */
2307 emit_p = repo_emit_p (decl);
2310 else if (emit_p == 1)
2312 /* The repository indicates that this entity should be defined
2313 here. Make sure the back end honors that request. */
2314 if (TREE_CODE (decl) == VAR_DECL)
2316 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
2317 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2320 FOR_EACH_CLONE (clone, decl)
2321 mark_needed (clone);
2325 /* Output the definition as an ordinary strong definition. */
2326 DECL_EXTERNAL (decl) = 0;
2327 DECL_INTERFACE_KNOWN (decl) = 1;
2332 /* We have already decided what to do with this DECL; there is no
2333 need to check anything further. */
2335 else if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
2337 class_type = DECL_CONTEXT (decl);
2338 import_export_class (class_type);
2339 if (TYPE_FOR_JAVA (class_type))
2341 else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
2342 && CLASSTYPE_INTERFACE_ONLY (class_type))
2344 else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
2345 && !CLASSTYPE_USE_TEMPLATE (class_type)
2346 && CLASSTYPE_KEY_METHOD (class_type)
2347 && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
2348 /* The ABI requires that all virtual tables be emitted with
2349 COMDAT linkage. However, on systems where COMDAT symbols
2350 don't show up in the table of contents for a static
2351 archive, or on systems without weak symbols (where we
2352 approximate COMDAT linkage by using internal linkage), the
2353 linker will report errors about undefined symbols because
2354 it will not see the virtual table definition. Therefore,
2355 in the case that we know that the virtual table will be
2356 emitted in only one translation unit, we make the virtual
2357 table an ordinary definition with external linkage. */
2358 DECL_EXTERNAL (decl) = 0;
2359 else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
2361 /* CLASS_TYPE is being exported from this translation unit,
2362 so DECL should be defined here. */
2363 if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
2364 /* If a class is declared in a header with the "extern
2365 template" extension, then it will not be instantiated,
2366 even in translation units that would normally require
2367 it. Often such classes are explicitly instantiated in
2368 one translation unit. Therefore, the explicit
2369 instantiation must be made visible to other translation
2371 DECL_EXTERNAL (decl) = 0;
2374 /* The generic C++ ABI says that class data is always
2375 COMDAT, even if there is a key function. Some
2376 variants (e.g., the ARM EABI) says that class data
2377 only has COMDAT linkage if the class data might be
2378 emitted in more than one translation unit. When the
2379 key method can be inline and is inline, we still have
2380 to arrange for comdat even though
2381 class_data_always_comdat is false. */
2382 if (!CLASSTYPE_KEY_METHOD (class_type)
2383 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))
2384 || targetm.cxx.class_data_always_comdat ())
2386 /* The ABI requires COMDAT linkage. Normally, we
2387 only emit COMDAT things when they are needed;
2388 make sure that we realize that this entity is
2395 else if (!flag_implicit_templates
2396 && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
2401 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2403 tree type = TREE_TYPE (DECL_NAME (decl));
2404 if (CLASS_TYPE_P (type))
2407 import_export_class (type);
2408 if (CLASSTYPE_INTERFACE_KNOWN (type)
2409 && TYPE_POLYMORPHIC_P (type)
2410 && CLASSTYPE_INTERFACE_ONLY (type)
2411 /* If -fno-rtti was specified, then we cannot be sure
2412 that RTTI information will be emitted with the
2413 virtual table of the class, so we must emit it
2414 wherever it is used. */
2419 if (CLASSTYPE_INTERFACE_KNOWN (type)
2420 && !CLASSTYPE_INTERFACE_ONLY (type))
2422 comdat_p = (targetm.cxx.class_data_always_comdat ()
2423 || (CLASSTYPE_KEY_METHOD (type)
2424 && DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type))));
2429 DECL_EXTERNAL (decl) = 0;
2439 else if (DECL_TEMPLATE_INSTANTIATION (decl)
2440 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2442 /* DECL is an implicit instantiation of a function or static
2444 if ((flag_implicit_templates
2445 && !flag_use_repository)
2446 || (flag_implicit_inline_templates
2447 && TREE_CODE (decl) == FUNCTION_DECL
2448 && DECL_DECLARED_INLINE_P (decl)))
2451 /* If we are not implicitly generating templates, then mark
2452 this entity as undefined in this translation unit. */
2455 else if (DECL_FUNCTION_MEMBER_P (decl))
2457 if (!DECL_DECLARED_INLINE_P (decl))
2459 tree ctype = DECL_CONTEXT (decl);
2460 import_export_class (ctype);
2461 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
2463 DECL_NOT_REALLY_EXTERN (decl)
2464 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2465 || (DECL_DECLARED_INLINE_P (decl)
2466 && ! flag_implement_inlines
2467 && !DECL_VINDEX (decl)));
2469 if (!DECL_NOT_REALLY_EXTERN (decl))
2470 DECL_EXTERNAL (decl) = 1;
2472 /* Always make artificials weak. */
2473 if (DECL_ARTIFICIAL (decl) && flag_weak)
2476 maybe_make_one_only (decl);
2487 /* If we are importing DECL into this translation unit, mark is
2488 an undefined here. */
2489 DECL_EXTERNAL (decl) = 1;
2490 DECL_NOT_REALLY_EXTERN (decl) = 0;
2494 /* If we decided to put DECL in COMDAT, mark it accordingly at
2496 comdat_linkage (decl);
2499 DECL_INTERFACE_KNOWN (decl) = 1;
2502 /* Return an expression that performs the destruction of DECL, which
2503 must be a VAR_DECL whose type has a non-trivial destructor, or is
2504 an array whose (innermost) elements have a non-trivial destructor. */
2507 build_cleanup (tree decl)
2510 tree type = TREE_TYPE (decl);
2512 /* This function should only be called for declarations that really
2513 require cleanups. */
2514 gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type));
2516 /* Treat all objects with destructors as used; the destructor may do
2517 something substantive. */
2520 if (TREE_CODE (type) == ARRAY_TYPE)
2523 temp = build_address (decl);
2524 temp = build_delete (TREE_TYPE (temp), temp,
2525 sfk_complete_destructor,
2526 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
2530 /* Returns the initialization guard variable for the variable DECL,
2531 which has static storage duration. */
2534 get_guard (tree decl)
2539 sname = mangle_guard_variable (decl);
2540 guard = IDENTIFIER_GLOBAL_VALUE (sname);
2545 /* We use a type that is big enough to contain a mutex as well
2546 as an integer counter. */
2547 guard_type = targetm.cxx.guard_type ();
2548 guard = build_decl (DECL_SOURCE_LOCATION (decl),
2549 VAR_DECL, sname, guard_type);
2551 /* The guard should have the same linkage as what it guards. */
2552 TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
2553 TREE_STATIC (guard) = TREE_STATIC (decl);
2554 DECL_COMMON (guard) = DECL_COMMON (decl);
2555 DECL_COMDAT_GROUP (guard) = DECL_COMDAT_GROUP (decl);
2556 if (TREE_PUBLIC (decl))
2557 DECL_WEAK (guard) = DECL_WEAK (decl);
2558 DECL_VISIBILITY (guard) = DECL_VISIBILITY (decl);
2559 DECL_VISIBILITY_SPECIFIED (guard) = DECL_VISIBILITY_SPECIFIED (decl);
2561 DECL_ARTIFICIAL (guard) = 1;
2562 DECL_IGNORED_P (guard) = 1;
2563 TREE_USED (guard) = 1;
2564 pushdecl_top_level_and_finish (guard, NULL_TREE);
2569 /* Return those bits of the GUARD variable that should be set when the
2570 guarded entity is actually initialized. */
2573 get_guard_bits (tree guard)
2575 if (!targetm.cxx.guard_mask_bit ())
2577 /* We only set the first byte of the guard, in order to leave room
2578 for a mutex in the high-order bits. */
2579 guard = build1 (ADDR_EXPR,
2580 build_pointer_type (TREE_TYPE (guard)),
2582 guard = build1 (NOP_EXPR,
2583 build_pointer_type (char_type_node),
2585 guard = build1 (INDIRECT_REF, char_type_node, guard);
2591 /* Return an expression which determines whether or not the GUARD
2592 variable has already been initialized. */
2595 get_guard_cond (tree guard)
2599 /* Check to see if the GUARD is zero. */
2600 guard = get_guard_bits (guard);
2602 /* Mask off all but the low bit. */
2603 if (targetm.cxx.guard_mask_bit ())
2605 guard_value = integer_one_node;
2606 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2607 guard_value = convert (TREE_TYPE (guard), guard_value);
2608 guard = cp_build_binary_op (input_location,
2609 BIT_AND_EXPR, guard, guard_value,
2610 tf_warning_or_error);
2613 guard_value = integer_zero_node;
2614 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2615 guard_value = convert (TREE_TYPE (guard), guard_value);
2616 return cp_build_binary_op (input_location,
2617 EQ_EXPR, guard, guard_value,
2618 tf_warning_or_error);
2621 /* Return an expression which sets the GUARD variable, indicating that
2622 the variable being guarded has been initialized. */
2625 set_guard (tree guard)
2629 /* Set the GUARD to one. */
2630 guard = get_guard_bits (guard);
2631 guard_init = integer_one_node;
2632 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
2633 guard_init = convert (TREE_TYPE (guard), guard_init);
2634 return cp_build_modify_expr (guard, NOP_EXPR, guard_init,
2635 tf_warning_or_error);
2638 /* Start the process of running a particular set of global constructors
2639 or destructors. Subroutine of do_[cd]tors. */
2642 start_objects (int method_type, int initp)
2648 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
2650 if (initp != DEFAULT_INIT_PRIORITY)
2660 sprintf (type, "%c%c%.5u", method_type, joiner, initp);
2663 sprintf (type, "%c", method_type);
2665 fndecl = build_lang_decl (FUNCTION_DECL,
2666 get_file_function_name (type),
2667 build_function_type (void_type_node,
2669 start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
2671 TREE_PUBLIC (current_function_decl) = 0;
2673 /* Mark as artificial because it's not explicitly in the user's
2675 DECL_ARTIFICIAL (current_function_decl) = 1;
2677 /* Mark this declaration as used to avoid spurious warnings. */
2678 TREE_USED (current_function_decl) = 1;
2680 /* Mark this function as a global constructor or destructor. */
2681 if (method_type == 'I')
2682 DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
2684 DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
2686 body = begin_compound_stmt (BCS_FN_BODY);
2691 /* Finish the process of running a particular set of global constructors
2692 or destructors. Subroutine of do_[cd]tors. */
2695 finish_objects (int method_type, int initp, tree body)
2700 finish_compound_stmt (body);
2701 fn = finish_function (0);
2703 if (method_type == 'I')
2705 DECL_STATIC_CONSTRUCTOR (fn) = 1;
2706 decl_init_priority_insert (fn, initp);
2710 DECL_STATIC_DESTRUCTOR (fn) = 1;
2711 decl_fini_priority_insert (fn, initp);
2714 expand_or_defer_fn (fn);
2717 /* The names of the parameters to the function created to handle
2718 initializations and destructions for objects with static storage
2720 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2721 #define PRIORITY_IDENTIFIER "__priority"
2723 /* The name of the function we create to handle initializations and
2724 destructions for objects with static storage duration. */
2725 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2727 /* The declaration for the __INITIALIZE_P argument. */
2728 static GTY(()) tree initialize_p_decl;
2730 /* The declaration for the __PRIORITY argument. */
2731 static GTY(()) tree priority_decl;
2733 /* The declaration for the static storage duration function. */
2734 static GTY(()) tree ssdf_decl;
2736 /* All the static storage duration functions created in this
2737 translation unit. */
2738 static GTY(()) VEC(tree,gc) *ssdf_decls;
2740 /* A map from priority levels to information about that priority
2741 level. There may be many such levels, so efficient lookup is
2743 static splay_tree priority_info_map;
2745 /* Begins the generation of the function that will handle all
2746 initialization and destruction of objects with static storage
2747 duration. The function generated takes two parameters of type
2748 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2749 nonzero, it performs initializations. Otherwise, it performs
2750 destructions. It only performs those initializations or
2751 destructions with the indicated __PRIORITY. The generated function
2754 It is assumed that this function will only be called once per
2755 translation unit. */
2758 start_static_storage_duration_function (unsigned count)
2763 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2765 /* Create the identifier for this function. It will be of the form
2766 SSDF_IDENTIFIER_<number>. */
2767 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2769 /* Create the parameters. */
2770 parm_types = void_list_node;
2771 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2772 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2773 type = build_function_type (void_type_node, parm_types);
2775 /* Create the FUNCTION_DECL itself. */
2776 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2777 get_identifier (id),
2779 TREE_PUBLIC (ssdf_decl) = 0;
2780 DECL_ARTIFICIAL (ssdf_decl) = 1;
2782 /* Put this function in the list of functions to be called from the
2783 static constructors and destructors. */
2786 ssdf_decls = VEC_alloc (tree, gc, 32);
2788 /* Take this opportunity to initialize the map from priority
2789 numbers to information about that priority level. */
2790 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2791 /*delete_key_fn=*/0,
2792 /*delete_value_fn=*/
2793 (splay_tree_delete_value_fn) &free);
2795 /* We always need to generate functions for the
2796 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2797 priorities later, we'll be sure to find the
2798 DEFAULT_INIT_PRIORITY. */
2799 get_priority_info (DEFAULT_INIT_PRIORITY);
2802 VEC_safe_push (tree, gc, ssdf_decls, ssdf_decl);
2804 /* Create the argument list. */
2805 initialize_p_decl = cp_build_parm_decl
2806 (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2807 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2808 TREE_USED (initialize_p_decl) = 1;
2809 priority_decl = cp_build_parm_decl
2810 (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2811 DECL_CONTEXT (priority_decl) = ssdf_decl;
2812 TREE_USED (priority_decl) = 1;
2814 TREE_CHAIN (initialize_p_decl) = priority_decl;
2815 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2817 /* Put the function in the global scope. */
2818 pushdecl (ssdf_decl);
2820 /* Start the function itself. This is equivalent to declaring the
2823 static void __ssdf (int __initialize_p, init __priority_p);
2825 It is static because we only need to call this function from the
2826 various constructor and destructor functions for this module. */
2827 start_preparsed_function (ssdf_decl,
2828 /*attrs=*/NULL_TREE,
2831 /* Set up the scope of the outermost block in the function. */
2832 body = begin_compound_stmt (BCS_FN_BODY);
2837 /* Finish the generation of the function which performs initialization
2838 and destruction of objects with static storage duration. After
2839 this point, no more such objects can be created. */
2842 finish_static_storage_duration_function (tree body)
2844 /* Close out the function. */
2845 finish_compound_stmt (body);
2846 expand_or_defer_fn (finish_function (0));
2849 /* Return the information about the indicated PRIORITY level. If no
2850 code to handle this level has yet been generated, generate the
2851 appropriate prologue. */
2853 static priority_info
2854 get_priority_info (int priority)
2859 n = splay_tree_lookup (priority_info_map,
2860 (splay_tree_key) priority);
2863 /* Create a new priority information structure, and insert it
2865 pi = XNEW (struct priority_info_s);
2866 pi->initializations_p = 0;
2867 pi->destructions_p = 0;
2868 splay_tree_insert (priority_info_map,
2869 (splay_tree_key) priority,
2870 (splay_tree_value) pi);
2873 pi = (priority_info) n->value;
2878 /* The effective initialization priority of a DECL. */
2880 #define DECL_EFFECTIVE_INIT_PRIORITY(decl) \
2881 ((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \
2882 ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl))
2884 /* Whether a DECL needs a guard to protect it against multiple
2887 #define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl) \
2888 || DECL_ONE_ONLY (decl) \
2889 || DECL_WEAK (decl)))
2891 /* Called from one_static_initialization_or_destruction(),
2893 Walks the initializer list of a global variable and looks for
2894 temporary variables (DECL_NAME() == NULL and DECL_ARTIFICIAL != 0)
2895 and that have their DECL_CONTEXT() == NULL.
2896 For each such temporary variable, set their DECL_CONTEXT() to
2897 the current function. This is necessary because otherwise
2898 some optimizers (enabled by -O2 -fprofile-arcs) might crash
2899 when trying to refer to a temporary variable that does not have
2900 it's DECL_CONTECT() properly set. */
2902 fix_temporary_vars_context_r (tree *node,
2903 int *unused ATTRIBUTE_UNUSED,
2904 void *unused1 ATTRIBUTE_UNUSED)
2906 gcc_assert (current_function_decl);
2908 if (TREE_CODE (*node) == BIND_EXPR)
2912 for (var = BIND_EXPR_VARS (*node); var; var = TREE_CHAIN (var))
2913 if (TREE_CODE (var) == VAR_DECL
2915 && DECL_ARTIFICIAL (var)
2916 && !DECL_CONTEXT (var))
2917 DECL_CONTEXT (var) = current_function_decl;
2923 /* Set up to handle the initialization or destruction of DECL. If
2924 INITP is nonzero, we are initializing the variable. Otherwise, we
2925 are destroying it. */
2928 one_static_initialization_or_destruction (tree decl, tree init, bool initp)
2930 tree guard_if_stmt = NULL_TREE;
2933 /* If we are supposed to destruct and there's a trivial destructor,
2934 nothing has to be done. */
2936 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2939 /* Trick the compiler into thinking we are at the file and line
2940 where DECL was declared so that error-messages make sense, and so
2941 that the debugger will show somewhat sensible file and line
2943 input_location = DECL_SOURCE_LOCATION (decl);
2945 /* Make sure temporary variables in the initialiser all have
2946 their DECL_CONTEXT() set to a value different from NULL_TREE.
2947 This can happen when global variables initialisers are built.
2948 In that case, the DECL_CONTEXT() of the global variables _AND_ of all
2949 the temporary variables that might have been generated in the
2950 accompagning initialisers is NULL_TREE, meaning the variables have been
2951 declared in the global namespace.
2952 What we want to do here is to fix that and make sure the DECL_CONTEXT()
2953 of the temporaries are set to the current function decl. */
2954 cp_walk_tree_without_duplicates (&init,
2955 fix_temporary_vars_context_r,
2962 Access control for implicit calls to the constructors,
2963 the conversion functions, or the destructor called to
2964 create and destroy a static data member is performed as
2965 if these calls appeared in the scope of the member's
2968 we pretend we are in a static member function of the class of
2969 which the DECL is a member. */
2970 if (member_p (decl))
2972 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
2973 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
2976 /* Assume we don't need a guard. */
2978 /* We need a guard if this is an object with external linkage that
2979 might be initialized in more than one place. (For example, a
2980 static data member of a template, when the data member requires
2982 if (NEEDS_GUARD_P (decl))
2986 guard = get_guard (decl);
2988 /* When using __cxa_atexit, we just check the GUARD as we would
2989 for a local static. */
2990 if (flag_use_cxa_atexit)
2992 /* When using __cxa_atexit, we never try to destroy
2993 anything from a static destructor. */
2995 guard_cond = get_guard_cond (guard);
2997 /* If we don't have __cxa_atexit, then we will be running
2998 destructors from .fini sections, or their equivalents. So,
2999 we need to know how many times we've tried to initialize this
3000 object. We do initializations only if the GUARD is zero,
3001 i.e., if we are the first to initialize the variable. We do
3002 destructions only if the GUARD is one, i.e., if we are the
3003 last to destroy the variable. */
3006 = cp_build_binary_op (input_location,
3008 cp_build_unary_op (PREINCREMENT_EXPR,
3011 tf_warning_or_error),
3013 tf_warning_or_error);
3016 = cp_build_binary_op (input_location,
3018 cp_build_unary_op (PREDECREMENT_EXPR,
3021 tf_warning_or_error),
3023 tf_warning_or_error);
3025 guard_if_stmt = begin_if_stmt ();
3026 finish_if_stmt_cond (guard_cond, guard_if_stmt);
3030 /* If we're using __cxa_atexit, we have not already set the GUARD,
3031 so we must do so now. */
3032 if (guard && initp && flag_use_cxa_atexit)
3033 finish_expr_stmt (set_guard (guard));
3035 /* Perform the initialization or destruction. */
3039 finish_expr_stmt (init);
3041 /* If we're using __cxa_atexit, register a function that calls the
3042 destructor for the object. */
3043 if (flag_use_cxa_atexit)
3044 finish_expr_stmt (register_dtor_fn (decl));
3047 finish_expr_stmt (build_cleanup (decl));
3049 /* Finish the guard if-stmt, if necessary. */
3052 finish_then_clause (guard_if_stmt);
3053 finish_if_stmt (guard_if_stmt);
3056 /* Now that we're done with DECL we don't need to pretend to be a
3057 member of its class any longer. */
3058 DECL_CONTEXT (current_function_decl) = NULL_TREE;
3059 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
3062 /* Generate code to do the initialization or destruction of the decls in VARS,
3063 a TREE_LIST of VAR_DECL with static storage duration.
3064 Whether initialization or destruction is performed is specified by INITP. */
3067 do_static_initialization_or_destruction (tree vars, bool initp)
3069 tree node, init_if_stmt, cond;
3071 /* Build the outer if-stmt to check for initialization or destruction. */
3072 init_if_stmt = begin_if_stmt ();
3073 cond = initp ? integer_one_node : integer_zero_node;
3074 cond = cp_build_binary_op (input_location,
3078 tf_warning_or_error);
3079 finish_if_stmt_cond (cond, init_if_stmt);
3083 tree decl = TREE_VALUE (node);
3084 tree priority_if_stmt;
3088 /* If we don't need a destructor, there's nothing to do. Avoid
3089 creating a possibly empty if-stmt. */
3090 if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3092 node = TREE_CHAIN (node);
3096 /* Remember that we had an initialization or finalization at this
3098 priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
3099 pi = get_priority_info (priority);
3101 pi->initializations_p = 1;
3103 pi->destructions_p = 1;
3105 /* Conditionalize this initialization on being in the right priority
3106 and being initializing/finalizing appropriately. */
3107 priority_if_stmt = begin_if_stmt ();
3108 cond = cp_build_binary_op (input_location,
3111 build_int_cst (NULL_TREE, priority),
3112 tf_warning_or_error);
3113 finish_if_stmt_cond (cond, priority_if_stmt);
3115 /* Process initializers with same priority. */
3117 && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
3118 node = TREE_CHAIN (node))
3119 /* Do one initialization or destruction. */
3120 one_static_initialization_or_destruction (TREE_VALUE (node),
3121 TREE_PURPOSE (node), initp);
3123 /* Finish up the priority if-stmt body. */
3124 finish_then_clause (priority_if_stmt);
3125 finish_if_stmt (priority_if_stmt);
3129 /* Finish up the init/destruct if-stmt body. */
3130 finish_then_clause (init_if_stmt);
3131 finish_if_stmt (init_if_stmt);
3134 /* VARS is a list of variables with static storage duration which may
3135 need initialization and/or finalization. Remove those variables
3136 that don't really need to be initialized or finalized, and return
3137 the resulting list. The order in which the variables appear in
3138 VARS is in reverse order of the order in which they should actually
3139 be initialized. The list we return is in the unreversed order;
3140 i.e., the first variable should be initialized first. */
3143 prune_vars_needing_no_initialization (tree *vars)
3146 tree result = NULL_TREE;
3151 tree decl = TREE_VALUE (t);
3152 tree init = TREE_PURPOSE (t);
3154 /* Deal gracefully with error. */
3155 if (decl == error_mark_node)
3157 var = &TREE_CHAIN (t);
3161 /* The only things that can be initialized are variables. */
3162 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3164 /* If this object is not defined, we don't need to do anything
3166 if (DECL_EXTERNAL (decl))
3168 var = &TREE_CHAIN (t);
3172 /* Also, if the initializer already contains errors, we can bail
3174 if (init && TREE_CODE (init) == TREE_LIST
3175 && value_member (error_mark_node, init))
3177 var = &TREE_CHAIN (t);
3181 /* This variable is going to need initialization and/or
3182 finalization, so we add it to the list. */
3183 *var = TREE_CHAIN (t);
3184 TREE_CHAIN (t) = result;
3191 /* Make sure we have told the back end about all the variables in
3195 write_out_vars (tree vars)
3199 for (v = vars; v; v = TREE_CHAIN (v))
3201 tree var = TREE_VALUE (v);
3202 if (!var_finalized_p (var))
3204 import_export_decl (var);
3205 rest_of_decl_compilation (var, 1, 1);
3210 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
3211 (otherwise) that will initialize all global objects with static
3212 storage duration having the indicated PRIORITY. */
3215 generate_ctor_or_dtor_function (bool constructor_p, int priority,
3224 input_location = *locus;
3226 /* Was: locus->line++; */
3228 /* We use `I' to indicate initialization and `D' to indicate
3230 function_key = constructor_p ? 'I' : 'D';
3232 /* We emit the function lazily, to avoid generating empty
3233 global constructors and destructors. */
3236 /* For Objective-C++, we may need to initialize metadata found in this module.
3237 This must be done _before_ any other static initializations. */
3238 if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
3239 && constructor_p && objc_static_init_needed_p ())
3241 body = start_objects (function_key, priority);
3242 objc_generate_static_init_call (NULL_TREE);
3245 /* Call the static storage duration function with appropriate
3247 for (i = 0; VEC_iterate (tree, ssdf_decls, i, fndecl); ++i)
3249 /* Calls to pure or const functions will expand to nothing. */
3250 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
3253 body = start_objects (function_key, priority);
3255 arguments = tree_cons (NULL_TREE,
3256 build_int_cst (NULL_TREE, priority),
3258 arguments = tree_cons (NULL_TREE,
3259 build_int_cst (NULL_TREE, constructor_p),
3261 finish_expr_stmt (cp_build_function_call (fndecl, arguments,
3262 tf_warning_or_error));
3266 /* Close out the function. */
3268 finish_objects (function_key, priority, body);
3271 /* Generate constructor and destructor functions for the priority
3275 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
3277 location_t *locus = (location_t *) data;
3278 int priority = (int) n->key;
3279 priority_info pi = (priority_info) n->value;
3281 /* Generate the functions themselves, but only if they are really
3283 if (pi->initializations_p)
3284 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
3285 if (pi->destructions_p)
3286 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
3288 /* Keep iterating. */
3292 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
3293 decls referenced from front-end specific constructs; it will be called
3294 only for language-specific tree nodes.
3296 Here we must deal with member pointers. */
3299 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED)
3303 switch (TREE_CODE (t))
3306 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
3307 cgraph_mark_address_taken_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
3310 if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
3311 cgraph_mark_address_taken_node (cgraph_node (BASELINK_FUNCTIONS (t)));
3314 if (DECL_VTABLE_OR_VTT_P (t))
3316 /* The ABI requires that all virtual tables be emitted
3317 whenever one of them is. */
3319 for (vtbl = CLASSTYPE_VTABLES (DECL_CONTEXT (t));
3321 vtbl = TREE_CHAIN (vtbl))
3322 mark_decl_referenced (vtbl);
3324 else if (DECL_CONTEXT (t)
3325 && flag_use_repository
3326 && TREE_CODE (DECL_CONTEXT (t)) == FUNCTION_DECL)
3327 /* If we need a static variable in a function, then we
3328 need the containing function. */
3329 mark_decl_referenced (DECL_CONTEXT (t));
3338 /* Java requires that we be able to reference a local address for a
3339 method, and not be confused by PLT entries. If hidden aliases are
3340 supported, collect and return all the functions for which we should
3341 emit a hidden alias. */
3343 static struct pointer_set_t *
3344 collect_candidates_for_java_method_aliases (void)
3346 struct cgraph_node *node;
3347 struct pointer_set_t *candidates = NULL;
3349 #ifndef HAVE_GAS_HIDDEN
3353 for (node = cgraph_nodes; node ; node = node->next)
3355 tree fndecl = node->decl;
3357 if (DECL_CONTEXT (fndecl)
3358 && TYPE_P (DECL_CONTEXT (fndecl))
3359 && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
3360 && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
3362 if (candidates == NULL)
3363 candidates = pointer_set_create ();
3364 pointer_set_insert (candidates, fndecl);
3372 /* Java requires that we be able to reference a local address for a
3373 method, and not be confused by PLT entries. If hidden aliases are
3374 supported, emit one for each java function that we've emitted.
3375 CANDIDATES is the set of FUNCTION_DECLs that were gathered
3376 by collect_candidates_for_java_method_aliases. */
3379 build_java_method_aliases (struct pointer_set_t *candidates)
3381 struct cgraph_node *node;
3383 #ifndef HAVE_GAS_HIDDEN
3387 for (node = cgraph_nodes; node ; node = node->next)
3389 tree fndecl = node->decl;
3391 if (TREE_ASM_WRITTEN (fndecl)
3392 && pointer_set_contains (candidates, fndecl))
3394 /* Mangle the name in a predictable way; we need to reference
3395 this from a java compiled object file. */
3396 tree oid, nid, alias;
3400 oid = DECL_ASSEMBLER_NAME (fndecl);
3401 oname = IDENTIFIER_POINTER (oid);
3402 gcc_assert (oname[0] == '_' && oname[1] == 'Z');
3403 nname = ACONCAT (("_ZGA", oname+2, NULL));
3404 nid = get_identifier (nname);
3406 alias = make_alias_for (fndecl, nid);
3407 TREE_PUBLIC (alias) = 1;
3408 DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
3410 assemble_alias (alias, oid);
3415 /* Returns true iff there is a definition available for variable or
3419 decl_defined_p (tree decl)
3421 if (TREE_CODE (decl) == FUNCTION_DECL)
3422 return (DECL_INITIAL (decl) != NULL_TREE);
3425 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3426 return !DECL_EXTERNAL (decl);
3430 /* Complain that DECL uses a type with no linkage but is never defined. */
3433 no_linkage_error (tree decl)
3435 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
3436 if (TYPE_ANONYMOUS_P (t))
3438 permerror (0, "%q+#D, declared using anonymous type, "
3439 "is used but never defined", decl);
3440 if (is_typedef_decl (TYPE_NAME (t)))
3441 permerror (0, "%q+#D does not refer to the unqualified type, "
3442 "so it is not used for linkage", TYPE_NAME (t));
3445 permerror (0, "%q+#D, declared using local type %qT, "
3446 "is used but never defined", decl, t);
3449 /* This routine is called at the end of compilation.
3450 Its job is to create all the code needed to initialize and
3451 destroy the global aggregates. We do the destruction
3452 first, since that way we only need to reverse the decls once. */
3455 cp_write_global_declarations (void)
3461 unsigned ssdf_count = 0;
3464 struct pointer_set_t *candidates;
3466 locus = input_location;
3469 /* Bad parse errors. Just forget about it. */
3470 if (! global_bindings_p () || current_class_type || decl_namespace_list)
3474 c_common_write_pch ();
3476 /* FIXME - huh? was input_line -= 1;*/
3478 /* We now have to write out all the stuff we put off writing out.
3481 o Template specializations that we have not yet instantiated,
3482 but which are needed.
3483 o Initialization and destruction for non-local objects with
3484 static storage duration. (Local objects with static storage
3485 duration are initialized when their scope is first entered,
3486 and are cleaned up via atexit.)
3487 o Virtual function tables.
3489 All of these may cause others to be needed. For example,
3490 instantiating one function may cause another to be needed, and
3491 generating the initializer for an object may cause templates to be
3492 instantiated, etc., etc. */
3494 timevar_push (TV_VARCONST);
3496 emit_support_tinfos ();
3505 /* If there are templates that we've put off instantiating, do
3507 instantiate_pending_templates (retries);
3510 /* Write out virtual tables as required. Note that writing out
3511 the virtual table for a template class may cause the
3512 instantiation of members of that class. If we write out
3513 vtables then we remove the class from our list so we don't
3514 have to look at it again. */
3516 while (keyed_classes != NULL_TREE
3517 && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
3520 keyed_classes = TREE_CHAIN (keyed_classes);
3526 tree next = TREE_CHAIN (t);
3530 if (maybe_emit_vtables (TREE_VALUE (next)))
3533 TREE_CHAIN (t) = TREE_CHAIN (next);
3538 next = TREE_CHAIN (t);
3542 /* Write out needed type info variables. We have to be careful
3543 looping through unemitted decls, because emit_tinfo_decl may
3544 cause other variables to be needed. New elements will be
3545 appended, and we remove from the vector those that actually
3547 for (i = VEC_length (tree, unemitted_tinfo_decls);
3548 VEC_iterate (tree, unemitted_tinfo_decls, --i, t);)
3549 if (emit_tinfo_decl (t))
3552 VEC_unordered_remove (tree, unemitted_tinfo_decls, i);
3555 /* The list of objects with static storage duration is built up
3556 in reverse order. We clear STATIC_AGGREGATES so that any new
3557 aggregates added during the initialization of these will be
3558 initialized in the correct order when we next come around the
3560 vars = prune_vars_needing_no_initialization (&static_aggregates);
3564 /* We need to start a new initialization function each time
3565 through the loop. That's because we need to know which
3566 vtables have been referenced, and TREE_SYMBOL_REFERENCED
3567 isn't computed until a function is finished, and written
3568 out. That's a deficiency in the back end. When this is
3569 fixed, these initialization functions could all become
3570 inline, with resulting performance improvements. */
3573 /* Set the line and file, so that it is obviously not from
3575 input_location = locus;
3576 ssdf_body = start_static_storage_duration_function (ssdf_count);
3578 /* Make sure the back end knows about all the variables. */
3579 write_out_vars (vars);
3581 /* First generate code to do all the initializations. */
3583 do_static_initialization_or_destruction (vars, /*initp=*/true);
3585 /* Then, generate code to do all the destructions. Do these
3586 in reverse order so that the most recently constructed
3587 variable is the first destroyed. If we're using
3588 __cxa_atexit, then we don't need to do this; functions
3589 were registered at initialization time to destroy the
3591 if (!flag_use_cxa_atexit && vars)
3593 vars = nreverse (vars);
3594 do_static_initialization_or_destruction (vars, /*initp=*/false);
3599 /* Finish up the static storage duration function for this
3601 input_location = locus;
3602 finish_static_storage_duration_function (ssdf_body);
3604 /* All those initializations and finalizations might cause
3605 us to need more inline functions, more template
3606 instantiations, etc. */
3609 /* ??? was: locus.line++; */
3612 /* Go through the set of inline functions whose bodies have not
3613 been emitted yet. If out-of-line copies of these functions
3614 are required, emit them. */
3615 for (i = 0; VEC_iterate (tree, deferred_fns, i, decl); ++i)
3617 /* Does it need synthesizing? */
3618 if (DECL_DEFAULTED_FN (decl) && ! DECL_INITIAL (decl)
3619 && (! DECL_REALLY_EXTERN (decl) || possibly_inlined_p (decl)))
3621 /* Even though we're already at the top-level, we push
3622 there again. That way, when we pop back a few lines
3623 hence, all of our state is restored. Otherwise,
3624 finish_function doesn't clean things up, and we end
3625 up with CURRENT_FUNCTION_DECL set. */
3626 push_to_top_level ();
3627 /* The decl's location will mark where it was first
3628 needed. Save that so synthesize method can indicate
3629 where it was needed from, in case of error */
3630 input_location = DECL_SOURCE_LOCATION (decl);
3631 synthesize_method (decl);
3632 pop_from_top_level ();
3636 if (!DECL_SAVED_TREE (decl))
3639 /* We lie to the back end, pretending that some functions
3640 are not defined when they really are. This keeps these
3641 functions from being put out unnecessarily. But, we must
3642 stop lying when the functions are referenced, or if they
3643 are not comdat since they need to be put out now. If
3644 DECL_INTERFACE_KNOWN, then we have already set
3645 DECL_EXTERNAL appropriately, so there's no need to check
3646 again, and we do not want to clear DECL_EXTERNAL if a
3647 previous call to import_export_decl set it.
3649 This is done in a separate for cycle, because if some
3650 deferred function is contained in another deferred
3651 function later in deferred_fns varray,
3652 rest_of_compilation would skip this function and we
3653 really cannot expand the same function twice. */
3654 import_export_decl (decl);
3655 if (DECL_NOT_REALLY_EXTERN (decl)
3656 && DECL_INITIAL (decl)
3657 && decl_needed_p (decl))
3658 DECL_EXTERNAL (decl) = 0;
3660 /* If we're going to need to write this function out, and
3661 there's already a body for it, create RTL for it now.
3662 (There might be no body if this is a method we haven't
3663 gotten around to synthesizing yet.) */
3664 if (!DECL_EXTERNAL (decl)
3665 && decl_needed_p (decl)
3666 && !TREE_ASM_WRITTEN (decl)
3667 && !cgraph_node (decl)->local.finalized)
3669 /* We will output the function; no longer consider it in this
3671 DECL_DEFER_OUTPUT (decl) = 0;
3672 /* Generate RTL for this function now that we know we
3674 expand_or_defer_fn (decl);
3675 /* If we're compiling -fsyntax-only pretend that this
3676 function has been written out so that we don't try to
3678 if (flag_syntax_only)
3679 TREE_ASM_WRITTEN (decl) = 1;
3684 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
3687 /* Static data members are just like namespace-scope globals. */
3688 for (i = 0; VEC_iterate (tree, pending_statics, i, decl); ++i)
3690 if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl)
3691 /* Don't write it out if we haven't seen a definition. */
3692 || DECL_IN_AGGR_P (decl))
3694 import_export_decl (decl);
3695 /* If this static data member is needed, provide it to the
3697 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
3698 DECL_EXTERNAL (decl) = 0;
3700 if (VEC_length (tree, pending_statics) != 0
3701 && wrapup_global_declarations (VEC_address (tree, pending_statics),
3702 VEC_length (tree, pending_statics)))
3709 /* All used inline functions must have a definition at this point. */
3710 for (i = 0; VEC_iterate (tree, deferred_fns, i, decl); ++i)
3712 if (/* Check online inline functions that were actually used. */
3713 DECL_ODR_USED (decl) && DECL_DECLARED_INLINE_P (decl)
3714 /* If the definition actually was available here, then the
3715 fact that the function was not defined merely represents
3716 that for some reason (use of a template repository,
3717 #pragma interface, etc.) we decided not to emit the
3719 && !DECL_INITIAL (decl)
3720 /* An explicit instantiation can be used to specify
3721 that the body is in another unit. It will have
3722 already verified there was a definition. */
3723 && !DECL_EXPLICIT_INSTANTIATION (decl))
3725 warning (0, "inline function %q+D used but never defined", decl);
3726 /* Avoid a duplicate warning from check_global_declaration_1. */
3727 TREE_NO_WARNING (decl) = 1;
3731 /* So must decls that use a type with no linkage. */
3732 for (i = 0; VEC_iterate (tree, no_linkage_decls, i, decl); ++i)
3733 if (!decl_defined_p (decl))
3734 no_linkage_error (decl);
3736 /* We give C linkage to static constructors and destructors. */
3737 push_lang_context (lang_name_c);
3739 /* Generate initialization and destruction functions for all
3740 priorities for which they are required. */
3741 if (priority_info_map)
3742 splay_tree_foreach (priority_info_map,
3743 generate_ctor_and_dtor_functions_for_priority,
3745 else if (c_dialect_objc () && objc_static_init_needed_p ())
3746 /* If this is obj-c++ and we need a static init, call
3747 generate_ctor_or_dtor_function. */
3748 generate_ctor_or_dtor_function (/*constructor_p=*/true,
3749 DEFAULT_INIT_PRIORITY, &locus);
3751 /* We're done with the splay-tree now. */
3752 if (priority_info_map)
3753 splay_tree_delete (priority_info_map);
3755 /* Generate any missing aliases. */
3756 maybe_apply_pending_pragma_weaks ();
3758 /* We're done with static constructors, so we can go back to "C++"
3760 pop_lang_context ();
3762 /* Collect candidates for Java hidden aliases. */
3763 candidates = collect_candidates_for_java_method_aliases ();
3765 cgraph_finalize_compilation_unit ();
3767 /* Now, issue warnings about static, but not defined, functions,
3768 etc., and emit debugging information. */
3769 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
3770 if (VEC_length (tree, pending_statics) != 0)
3772 check_global_declarations (VEC_address (tree, pending_statics),
3773 VEC_length (tree, pending_statics));
3774 emit_debug_global_declarations (VEC_address (tree, pending_statics),
3775 VEC_length (tree, pending_statics));
3778 /* Generate hidden aliases for Java. */
3781 build_java_method_aliases (candidates);
3782 pointer_set_destroy (candidates);
3787 /* The entire file is now complete. If requested, dump everything
3791 FILE *stream = dump_begin (TDI_tu, &flags);
3795 dump_node (global_namespace, flags & ~TDF_SLIM, stream);
3796 dump_end (TDI_tu, stream);
3800 timevar_pop (TV_VARCONST);
3802 if (flag_detailed_statistics)
3804 dump_tree_statistics ();
3805 dump_time_statistics ();
3807 input_location = locus;
3809 #ifdef ENABLE_CHECKING
3810 validate_conversion_obstack ();
3811 #endif /* ENABLE_CHECKING */
3814 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
3815 function to call in parse-tree form; it has not yet been
3816 semantically analyzed. ARGS are the arguments to the function.
3817 They have already been semantically analyzed. This may change
3821 build_offset_ref_call_from_tree (tree fn, VEC(tree,gc) **args)
3824 VEC(tree,gc) *orig_args = NULL;
3829 object = TREE_OPERAND (fn, 0);
3831 if (processing_template_decl)
3833 gcc_assert (TREE_CODE (fn) == DOTSTAR_EXPR
3834 || TREE_CODE (fn) == MEMBER_REF);
3835 if (type_dependent_expression_p (fn)
3836 || any_type_dependent_arguments_p (*args))
3837 return build_nt_call_vec (fn, *args);
3839 orig_args = make_tree_vector_copy (*args);
3841 /* Transform the arguments and add the implicit "this"
3842 parameter. That must be done before the FN is transformed
3843 because we depend on the form of FN. */
3844 make_args_non_dependent (*args);
3845 object = build_non_dependent_expr (object);
3846 if (TREE_CODE (fn) == DOTSTAR_EXPR)
3847 object = cp_build_unary_op (ADDR_EXPR, object, 0, tf_warning_or_error);
3848 VEC_safe_insert (tree, gc, *args, 0, object);
3849 /* Now that the arguments are done, transform FN. */
3850 fn = build_non_dependent_expr (fn);
3853 /* A qualified name corresponding to a bound pointer-to-member is
3854 represented as an OFFSET_REF:
3856 struct B { void g(); };
3858 void B::g() { (this->*p)(); } */
3859 if (TREE_CODE (fn) == OFFSET_REF)
3861 tree object_addr = cp_build_unary_op (ADDR_EXPR, object, 0,
3862 tf_warning_or_error);
3863 fn = TREE_OPERAND (fn, 1);
3864 fn = get_member_function_from_ptrfunc (&object_addr, fn);
3865 VEC_safe_insert (tree, gc, *args, 0, object_addr);
3868 expr = cp_build_function_call_vec (fn, args, tf_warning_or_error);
3869 if (processing_template_decl && expr != error_mark_node)
3870 expr = build_min_non_dep_call_vec (expr, orig_fn, orig_args);
3872 if (orig_args != NULL)
3873 release_tree_vector (orig_args);
3880 check_default_args (tree x)
3882 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
3883 bool saw_def = false;
3884 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
3885 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
3887 if (TREE_PURPOSE (arg))
3891 error ("default argument missing for parameter %P of %q+#D", i, x);
3892 TREE_PURPOSE (arg) = error_mark_node;
3897 /* Return true if function DECL can be inlined. This is used to force
3898 instantiation of methods that might be interesting for inlining. */
3900 possibly_inlined_p (tree decl)
3902 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
3903 if (DECL_UNINLINABLE (decl))
3905 if (!optimize || pragma_java_exceptions)
3906 return DECL_DECLARED_INLINE_P (decl);
3907 /* When optimizing, we might inline everything when flatten
3908 attribute or heuristics inlining for size or autoinlining
3913 /* Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
3914 If DECL is a specialization or implicitly declared class member,
3915 generate the actual definition. */
3918 mark_used (tree decl)
3920 HOST_WIDE_INT saved_processing_template_decl = 0;
3922 /* If DECL is a BASELINK for a single function, then treat it just
3923 like the DECL for the function. Otherwise, if the BASELINK is
3924 for an overloaded function, we don't know which function was
3925 actually used until after overload resolution. */
3926 if (TREE_CODE (decl) == BASELINK)
3928 decl = BASELINK_FUNCTIONS (decl);
3929 if (really_overloaded_fn (decl))
3931 decl = OVL_CURRENT (decl);
3934 /* Set TREE_USED for the benefit of -Wunused. */
3935 TREE_USED (decl) = 1;
3936 if (DECL_CLONED_FUNCTION_P (decl))
3937 TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
3939 if (TREE_CODE (decl) == FUNCTION_DECL
3940 && DECL_DELETED_FN (decl))
3942 error ("deleted function %q+D", decl);
3943 error ("used here");
3946 /* If we don't need a value, then we don't need to synthesize DECL. */
3947 if (cp_unevaluated_operand != 0)
3950 /* We can only check DECL_ODR_USED on variables or functions with
3951 DECL_LANG_SPECIFIC set, and these are also the only decls that we
3952 might need special handling for. */
3953 if ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
3954 || DECL_LANG_SPECIFIC (decl) == NULL
3955 || DECL_THUNK_P (decl))
3958 /* We only want to do this processing once. We don't need to keep trying
3959 to instantiate inline templates, because unit-at-a-time will make sure
3960 we get them compiled before functions that want to inline them. */
3961 if (DECL_ODR_USED (decl))
3964 /* If within finish_function, defer the rest until that function
3965 finishes, otherwise it might recurse. */
3966 if (defer_mark_used_calls)
3968 VEC_safe_push (tree, gc, deferred_mark_used_calls, decl);
3972 /* Normally, we can wait until instantiation-time to synthesize
3973 DECL. However, if DECL is a static data member initialized with
3974 a constant, we need the value right now because a reference to
3975 such a data member is not value-dependent. */
3976 if (TREE_CODE (decl) == VAR_DECL
3977 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)
3978 && DECL_CLASS_SCOPE_P (decl))
3980 /* Don't try to instantiate members of dependent types. We
3981 cannot just use dependent_type_p here because this function
3982 may be called from fold_non_dependent_expr, and then we may
3983 see dependent types, even though processing_template_decl
3985 if (CLASSTYPE_TEMPLATE_INFO ((DECL_CONTEXT (decl)))
3986 && uses_template_parms (CLASSTYPE_TI_ARGS (DECL_CONTEXT (decl))))
3988 /* Pretend that we are not in a template, even if we are, so
3989 that the static data member initializer will be processed. */
3990 saved_processing_template_decl = processing_template_decl;
3991 processing_template_decl = 0;
3994 if (processing_template_decl)
3997 DECL_ODR_USED (decl) = 1;
3998 if (DECL_CLONED_FUNCTION_P (decl))
3999 DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4001 /* DR 757: A type without linkage shall not be used as the type of a
4002 variable or function with linkage, unless
4003 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
4004 o the variable or function is not used (3.2 [basic.def.odr]) or is
4005 defined in the same translation unit. */
4006 if (cxx_dialect > cxx98
4007 && decl_linkage (decl) != lk_none
4008 && !DECL_EXTERN_C_P (decl)
4009 && !DECL_ARTIFICIAL (decl)
4010 && !decl_defined_p (decl)
4011 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
4013 if (is_local_extern (decl))
4014 /* There's no way to define a local extern, and adding it to
4015 the vector interferes with GC, so give an error now. */
4016 no_linkage_error (decl);
4018 VEC_safe_push (tree, gc, no_linkage_decls, decl);
4021 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
4022 && !DECL_INITIAL (decl) && !DECL_ARTIFICIAL (decl))
4023 /* Remember it, so we can check it was defined. */
4024 note_vague_linkage_fn (decl);
4026 /* Is it a synthesized method that needs to be synthesized? */
4027 if (TREE_CODE (decl) == FUNCTION_DECL
4028 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
4029 && DECL_DEFAULTED_FN (decl)
4030 && ! DECL_INITIAL (decl))
4032 /* Remember the current location for a function we will end up
4033 synthesizing. Then we can inform the user where it was
4034 required in the case of error. */
4035 DECL_SOURCE_LOCATION (decl) = input_location;
4037 /* Synthesizing an implicitly defined member function will result in
4038 garbage collection. We must treat this situation as if we were
4039 within the body of a function so as to avoid collecting live data
4040 on the stack (such as overload resolution candidates).
4042 We could just let cp_write_global_declarations handle synthesizing
4043 this function, since we just added it to deferred_fns, but doing
4044 it at the use site produces better error messages. */
4046 synthesize_method (decl);
4048 /* If this is a synthesized method we don't need to
4049 do the instantiation test below. */
4051 else if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4052 && DECL_TEMPLATE_INFO (decl)
4053 && (!DECL_EXPLICIT_INSTANTIATION (decl)
4054 || always_instantiate_p (decl)))
4055 /* If this is a function or variable that is an instance of some
4056 template, we now know that we will need to actually do the
4057 instantiation. We check that DECL is not an explicit
4058 instantiation because that is not checked in instantiate_decl.
4060 We put off instantiating functions in order to improve compile
4061 times. Maintaining a stack of active functions is expensive,
4062 and the inliner knows to instantiate any functions it might
4063 need. Therefore, we always try to defer instantiation. */
4064 instantiate_decl (decl, /*defer_ok=*/true,
4065 /*expl_inst_class_mem_p=*/false);
4067 processing_template_decl = saved_processing_template_decl;
4070 #include "gt-cp-decl2.h"