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, 2010,
4 2011, 2012 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"
44 #include "c-family/c-common.h"
45 #include "c-family/c-objc.h"
47 #include "tree-inline.h"
48 #include "c-family/c-pragma.h"
49 #include "tree-dump.h"
52 #include "pointer-set.h"
53 #include "splay-tree.h"
54 #include "langhooks.h"
55 #include "c-family/c-ada-spec.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 determine_hidden_inline (tree);
89 static bool decl_defined_p (tree);
91 /* A list of static class variables. This is needed, because a
92 static class variable can be declared inside the class without
93 an initializer, and then initialized, statically, outside the class. */
94 static GTY(()) VEC(tree,gc) *pending_statics;
96 /* A list of functions which were declared inline, but which we
97 may need to emit outline anyway. */
98 static GTY(()) VEC(tree,gc) *deferred_fns;
100 /* A list of decls that use types with no linkage, which we need to make
102 static GTY(()) VEC(tree,gc) *no_linkage_decls;
104 /* Nonzero if we're done parsing and into end-of-file activities. */
110 /* Return a member function type (a METHOD_TYPE), given FNTYPE (a
111 FUNCTION_TYPE), CTYPE (class type), and QUALS (the cv-qualifiers
112 that apply to the function). */
115 build_memfn_type (tree fntype, tree ctype, cp_cv_quals quals)
121 if (fntype == error_mark_node || ctype == error_mark_node)
122 return error_mark_node;
124 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
125 || TREE_CODE (fntype) == METHOD_TYPE);
127 type_quals = quals & ~TYPE_QUAL_RESTRICT;
128 ctype = cp_build_qualified_type (ctype, type_quals);
129 raises = TYPE_RAISES_EXCEPTIONS (fntype);
130 attrs = TYPE_ATTRIBUTES (fntype);
131 fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),
132 (TREE_CODE (fntype) == METHOD_TYPE
133 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
134 : TYPE_ARG_TYPES (fntype)));
136 fntype = build_exception_variant (fntype, raises);
138 fntype = cp_build_type_attribute_variant (fntype, attrs);
143 /* Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its
144 return type changed to NEW_RET. */
147 change_return_type (tree new_ret, tree fntype)
150 tree args = TYPE_ARG_TYPES (fntype);
151 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
152 tree attrs = TYPE_ATTRIBUTES (fntype);
154 if (new_ret == error_mark_node)
157 if (same_type_p (new_ret, TREE_TYPE (fntype)))
160 if (TREE_CODE (fntype) == FUNCTION_TYPE)
162 newtype = build_function_type (new_ret, args);
163 newtype = apply_memfn_quals (newtype, type_memfn_quals (fntype));
166 newtype = build_method_type_directly
167 (class_of_this_parm (fntype), new_ret, TREE_CHAIN (args));
169 newtype = build_exception_variant (newtype, raises);
171 newtype = cp_build_type_attribute_variant (newtype, attrs);
176 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
180 cp_build_parm_decl (tree name, tree type)
182 tree parm = build_decl (input_location,
183 PARM_DECL, name, type);
184 /* DECL_ARG_TYPE is only used by the back end and the back end never
186 if (!processing_template_decl)
187 DECL_ARG_TYPE (parm) = type_passed_as (type);
189 /* If the type is a pack expansion, then we have a function
191 if (type && TREE_CODE (type) == TYPE_PACK_EXPANSION)
192 FUNCTION_PARAMETER_PACK_P (parm) = 1;
197 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
201 build_artificial_parm (tree name, tree type)
203 tree parm = cp_build_parm_decl (name, type);
204 DECL_ARTIFICIAL (parm) = 1;
205 /* All our artificial parms are implicitly `const'; they cannot be
207 TREE_READONLY (parm) = 1;
211 /* Constructors for types with virtual baseclasses need an "in-charge" flag
212 saying whether this constructor is responsible for initialization of
213 virtual baseclasses or not. All destructors also need this "in-charge"
214 flag, which additionally determines whether or not the destructor should
215 free the memory for the object.
217 This function adds the "in-charge" flag to member function FN if
218 appropriate. It is called from grokclassfn and tsubst.
219 FN must be either a constructor or destructor.
221 The in-charge flag follows the 'this' parameter, and is followed by the
222 VTT parm (if any), then the user-written parms. */
225 maybe_retrofit_in_chrg (tree fn)
227 tree basetype, arg_types, parms, parm, fntype;
229 /* If we've already add the in-charge parameter don't do it again. */
230 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
233 /* When processing templates we can't know, in general, whether or
234 not we're going to have virtual baseclasses. */
235 if (processing_template_decl)
238 /* We don't need an in-charge parameter for constructors that don't
239 have virtual bases. */
240 if (DECL_CONSTRUCTOR_P (fn)
241 && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
244 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
245 basetype = TREE_TYPE (TREE_VALUE (arg_types));
246 arg_types = TREE_CHAIN (arg_types);
248 parms = DECL_CHAIN (DECL_ARGUMENTS (fn));
250 /* If this is a subobject constructor or destructor, our caller will
251 pass us a pointer to our VTT. */
252 if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
254 parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
256 /* First add it to DECL_ARGUMENTS between 'this' and the real args... */
257 DECL_CHAIN (parm) = parms;
260 /* ...and then to TYPE_ARG_TYPES. */
261 arg_types = hash_tree_chain (vtt_parm_type, arg_types);
263 DECL_HAS_VTT_PARM_P (fn) = 1;
266 /* Then add the in-charge parm (before the VTT parm). */
267 parm = build_artificial_parm (in_charge_identifier, integer_type_node);
268 DECL_CHAIN (parm) = parms;
270 arg_types = hash_tree_chain (integer_type_node, arg_types);
272 /* Insert our new parameter(s) into the list. */
273 DECL_CHAIN (DECL_ARGUMENTS (fn)) = parms;
275 /* And rebuild the function type. */
276 fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
278 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
279 fntype = build_exception_variant (fntype,
280 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
281 if (TYPE_ATTRIBUTES (TREE_TYPE (fn)))
282 fntype = (cp_build_type_attribute_variant
283 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (fn))));
284 TREE_TYPE (fn) = fntype;
286 /* Now we've got the in-charge parameter. */
287 DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
290 /* Classes overload their constituent function names automatically.
291 When a function name is declared in a record structure,
292 its name is changed to it overloaded name. Since names for
293 constructors and destructors can conflict, we place a leading
296 CNAME is the name of the class we are grokking for.
298 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
300 FLAGS contains bits saying what's special about today's
301 arguments. DTOR_FLAG == DESTRUCTOR.
303 If FUNCTION is a destructor, then we must add the `auto-delete' field
304 as a second parameter. There is some hair associated with the fact
305 that we must "declare" this variable in the manner consistent with the
306 way the rest of the arguments were declared.
308 QUALS are the qualifiers for the this pointer. */
311 grokclassfn (tree ctype, tree function, enum overload_flags flags)
313 tree fn_name = DECL_NAME (function);
315 /* Even within an `extern "C"' block, members get C++ linkage. See
316 [dcl.link] for details. */
317 SET_DECL_LANGUAGE (function, lang_cplusplus);
319 if (fn_name == NULL_TREE)
321 error ("name missing for member function");
322 fn_name = get_identifier ("<anonymous>");
323 DECL_NAME (function) = fn_name;
326 DECL_CONTEXT (function) = ctype;
328 if (flags == DTOR_FLAG)
329 DECL_DESTRUCTOR_P (function) = 1;
331 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
332 maybe_retrofit_in_chrg (function);
335 /* Create an ARRAY_REF, checking for the user doing things backwards
339 grok_array_decl (tree array_expr, tree index_exp)
343 tree orig_array_expr = array_expr;
344 tree orig_index_exp = index_exp;
346 if (error_operand_p (array_expr) || error_operand_p (index_exp))
347 return error_mark_node;
349 if (processing_template_decl)
351 if (type_dependent_expression_p (array_expr)
352 || type_dependent_expression_p (index_exp))
353 return build_min_nt (ARRAY_REF, array_expr, index_exp,
354 NULL_TREE, NULL_TREE);
355 array_expr = build_non_dependent_expr (array_expr);
356 index_exp = build_non_dependent_expr (index_exp);
359 type = TREE_TYPE (array_expr);
361 type = non_reference (type);
363 /* If they have an `operator[]', use that. */
364 if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp)))
365 expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
366 array_expr, index_exp, NULL_TREE,
367 /*overload=*/NULL, tf_warning_or_error);
372 /* Otherwise, create an ARRAY_REF for a pointer or array type.
373 It is a little-known fact that, if `a' is an array and `i' is
374 an int, you can write `i[a]', which means the same thing as
376 if (TREE_CODE (type) == ARRAY_TYPE)
379 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
381 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
384 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
386 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
388 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
391 if ((p1 && i2) && (i1 && p2))
392 error ("ambiguous conversion for array subscript");
395 array_expr = p1, index_exp = i2;
397 array_expr = p2, index_exp = i1;
400 error ("invalid types %<%T[%T]%> for array subscript",
401 type, TREE_TYPE (index_exp));
402 return error_mark_node;
405 if (array_expr == error_mark_node || index_exp == error_mark_node)
406 error ("ambiguous conversion for array subscript");
408 expr = build_array_ref (input_location, array_expr, index_exp);
410 if (processing_template_decl && expr != error_mark_node)
411 return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
412 NULL_TREE, NULL_TREE);
416 /* Given the cast expression EXP, checking out its validity. Either return
417 an error_mark_node if there was an unavoidable error, return a cast to
418 void for trying to delete a pointer w/ the value 0, or return the
419 call to delete. If DOING_VEC is true, we handle things differently
420 for doing an array delete.
421 Implements ARM $5.3.4. This is called from the parser. */
424 delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete,
425 tsubst_flags_t complain)
429 if (exp == error_mark_node)
432 if (processing_template_decl)
434 t = build_min (DELETE_EXPR, void_type_node, exp, size);
435 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
436 DELETE_EXPR_USE_VEC (t) = doing_vec;
437 TREE_SIDE_EFFECTS (t) = 1;
441 /* An array can't have been allocated by new, so complain. */
442 if (TREE_CODE (exp) == VAR_DECL
443 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
444 warning (0, "deleting array %q#D", exp);
446 t = build_expr_type_conversion (WANT_POINTER, exp, true);
448 if (t == NULL_TREE || t == error_mark_node)
450 error ("type %q#T argument given to %<delete%>, expected pointer",
452 return error_mark_node;
455 type = TREE_TYPE (t);
457 /* As of Valley Forge, you can delete a pointer to const. */
459 /* You can't delete functions. */
460 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
462 error ("cannot delete a function. Only pointer-to-objects are "
463 "valid arguments to %<delete%>");
464 return error_mark_node;
467 /* Deleting ptr to void is undefined behavior [expr.delete/3]. */
468 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
470 warning (0, "deleting %qT is undefined", type);
474 /* Deleting a pointer with the value zero is valid and has no effect. */
475 if (integer_zerop (t))
476 return build1 (NOP_EXPR, void_type_node, t);
479 return build_vec_delete (t, /*maxindex=*/NULL_TREE,
480 sfk_deleting_destructor,
481 use_global_delete, complain);
483 return build_delete (type, t, sfk_deleting_destructor,
484 LOOKUP_NORMAL, use_global_delete,
488 /* Report an error if the indicated template declaration is not the
489 sort of thing that should be a member template. */
492 check_member_template (tree tmpl)
496 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
497 decl = DECL_TEMPLATE_RESULT (tmpl);
499 if (TREE_CODE (decl) == FUNCTION_DECL
500 || DECL_ALIAS_TEMPLATE_P (tmpl)
501 || (TREE_CODE (decl) == TYPE_DECL
502 && MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))))
504 /* The parser rejects template declarations in local classes. */
505 gcc_assert (!current_function_decl);
506 /* The parser rejects any use of virtual in a function template. */
507 gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL
508 && DECL_VIRTUAL_P (decl)));
510 /* The debug-information generating code doesn't know what to do
511 with member templates. */
512 DECL_IGNORED_P (tmpl) = 1;
515 error ("template declaration of %q#D", decl);
518 /* Return true iff TYPE is a valid Java parameter or return type. */
521 acceptable_java_type (tree type)
523 if (type == error_mark_node)
526 if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
528 if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
530 type = TREE_TYPE (type);
531 if (TREE_CODE (type) == RECORD_TYPE)
534 if (! TYPE_FOR_JAVA (type))
536 if (! CLASSTYPE_TEMPLATE_INFO (type))
538 args = CLASSTYPE_TI_ARGS (type);
539 i = TREE_VEC_LENGTH (args);
542 type = TREE_VEC_ELT (args, i);
543 if (TREE_CODE (type) == POINTER_TYPE)
544 type = TREE_TYPE (type);
545 if (! TYPE_FOR_JAVA (type))
554 /* For a METHOD in a Java class CTYPE, return true if
555 the parameter and return types are valid Java types.
556 Otherwise, print appropriate error messages, and return false. */
559 check_java_method (tree method)
562 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
563 tree ret_type = TREE_TYPE (TREE_TYPE (method));
565 if (!acceptable_java_type (ret_type))
567 error ("Java method %qD has non-Java return type %qT",
572 arg_types = TREE_CHAIN (arg_types);
573 if (DECL_HAS_IN_CHARGE_PARM_P (method))
574 arg_types = TREE_CHAIN (arg_types);
575 if (DECL_HAS_VTT_PARM_P (method))
576 arg_types = TREE_CHAIN (arg_types);
578 for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
580 tree type = TREE_VALUE (arg_types);
581 if (!acceptable_java_type (type))
583 if (type != error_mark_node)
584 error ("Java method %qD has non-Java parameter type %qT",
592 /* Sanity check: report error if this function FUNCTION is not
593 really a member of the class (CTYPE) it is supposed to belong to.
594 TEMPLATE_PARMS is used to specify the template parameters of a member
595 template passed as FUNCTION_DECL. If the member template is passed as a
596 TEMPLATE_DECL, it can be NULL since the parameters can be extracted
597 from the declaration. If the function is not a function template, it
599 It returns the original declaration for the function, NULL_TREE if
600 no declaration was found, error_mark_node if an error was emitted. */
603 check_classfn (tree ctype, tree function, tree template_parms)
609 if (DECL_USE_TEMPLATE (function)
610 && !(TREE_CODE (function) == TEMPLATE_DECL
611 && DECL_TEMPLATE_SPECIALIZATION (function))
612 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))
613 /* Since this is a specialization of a member template,
614 we're not going to find the declaration in the class.
617 struct S { template <typename T> void f(T); };
618 template <> void S::f(int);
620 we're not going to find `S::f(int)', but there's no
621 reason we should, either. We let our callers know we didn't
622 find the method, but we don't complain. */
625 /* Basic sanity check: for a template function, the template parameters
626 either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */
627 if (TREE_CODE (function) == TEMPLATE_DECL)
630 && !comp_template_parms (template_parms,
631 DECL_TEMPLATE_PARMS (function)))
633 error ("template parameter lists provided don%'t match the "
634 "template parameters of %qD", function);
635 return error_mark_node;
637 template_parms = DECL_TEMPLATE_PARMS (function);
640 /* OK, is this a definition of a member template? */
641 is_template = (template_parms != NULL_TREE);
643 /* We must enter the scope here, because conversion operators are
644 named by target type, and type equivalence relies on typenames
645 resolving within the scope of CTYPE. */
646 pushed_scope = push_scope (ctype);
647 ix = class_method_index_for_fn (complete_type (ctype), function);
650 VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);
651 tree fndecls, fndecl = 0;
653 const char *format = NULL;
655 for (fndecls = VEC_index (tree, methods, ix);
656 fndecls; fndecls = OVL_NEXT (fndecls))
660 fndecl = OVL_CURRENT (fndecls);
661 p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
662 p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
664 /* We cannot simply call decls_match because this doesn't
665 work for static member functions that are pretending to
666 be methods, and because the name may have been changed by
669 /* Get rid of the this parameter on functions that become
671 if (DECL_STATIC_FUNCTION_P (fndecl)
672 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
673 p1 = TREE_CHAIN (p1);
675 /* A member template definition only matches a member template
677 if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
680 if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
681 TREE_TYPE (TREE_TYPE (fndecl)))
682 && compparms (p1, p2)
684 || comp_template_parms (template_parms,
685 DECL_TEMPLATE_PARMS (fndecl)))
686 && (DECL_TEMPLATE_SPECIALIZATION (function)
687 == DECL_TEMPLATE_SPECIALIZATION (fndecl))
688 && (!DECL_TEMPLATE_SPECIALIZATION (function)
689 || (DECL_TI_TEMPLATE (function)
690 == DECL_TI_TEMPLATE (fndecl))))
696 pop_scope (pushed_scope);
697 return OVL_CURRENT (fndecls);
700 error_at (DECL_SOURCE_LOCATION (function),
701 "prototype for %q#D does not match any in class %qT",
703 is_conv_op = DECL_CONV_FN_P (fndecl);
706 ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
707 fndecls = VEC_index (tree, methods, ix);
710 fndecl = OVL_CURRENT (fndecls);
711 fndecls = OVL_NEXT (fndecls);
713 if (!fndecls && is_conv_op)
715 if (VEC_length (tree, methods) > (size_t) ++ix)
717 fndecls = VEC_index (tree, methods, ix);
718 if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
730 format = N_("candidates are: %+#D");
732 format = N_("candidate is: %+#D");
733 error (format, fndecl);
736 else if (!COMPLETE_TYPE_P (ctype))
737 cxx_incomplete_type_error (function, ctype);
739 error ("no %q#D member function declared in class %qT",
743 pop_scope (pushed_scope);
744 return error_mark_node;
747 /* DECL is a function with vague linkage. Remember it so that at the
748 end of the translation unit we can decide whether or not to emit
752 note_vague_linkage_fn (tree decl)
754 DECL_DEFER_OUTPUT (decl) = 1;
755 VEC_safe_push (tree, gc, deferred_fns, decl);
758 /* We have just processed the DECL, which is a static data member.
759 The other parameters are as for cp_finish_decl. */
762 finish_static_data_member_decl (tree decl,
763 tree init, bool init_const_expr_p,
767 DECL_CONTEXT (decl) = current_class_type;
769 /* We cannot call pushdecl here, because that would fill in the
770 TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
771 the right thing, namely, to put this decl out straight away. */
773 if (! processing_template_decl)
774 VEC_safe_push (tree, gc, pending_statics, decl);
776 if (LOCAL_CLASS_P (current_class_type))
777 permerror (input_location, "local class %q#T shall not have static data member %q#D",
778 current_class_type, decl);
780 DECL_IN_AGGR_P (decl) = 1;
782 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
783 && TYPE_DOMAIN (TREE_TYPE (decl)) == NULL_TREE)
784 SET_VAR_HAD_UNKNOWN_BOUND (decl);
786 cp_finish_decl (decl, init, init_const_expr_p, asmspec_tree, flags);
789 /* DECLARATOR and DECLSPECS correspond to a class member. The other
790 parameters are as for cp_finish_decl. Return the DECL for the
791 class member declared. */
794 grokfield (const cp_declarator *declarator,
795 cp_decl_specifier_seq *declspecs,
796 tree init, bool init_const_expr_p,
801 const char *asmspec = 0;
806 && TREE_CODE (init) == TREE_LIST
807 && TREE_VALUE (init) == error_mark_node
808 && TREE_CHAIN (init) == NULL_TREE)
811 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
812 if (! value || error_operand_p (value))
813 /* friend or constructor went bad. */
814 return error_mark_node;
816 if (TREE_CODE (value) == TYPE_DECL && init)
818 error ("typedef %qD is initialized (use decltype instead)", value);
822 /* Pass friendly classes back. */
823 if (value == void_type_node)
826 /* Pass friend decls back. */
827 if ((TREE_CODE (value) == FUNCTION_DECL
828 || TREE_CODE (value) == TEMPLATE_DECL)
829 && DECL_CONTEXT (value) != current_class_type)
832 name = DECL_NAME (value);
834 if (name != NULL_TREE)
836 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
838 error ("explicit template argument list not allowed");
839 return error_mark_node;
842 if (IDENTIFIER_POINTER (name)[0] == '_'
843 && ! strcmp (IDENTIFIER_POINTER (name), "_vptr"))
844 error ("member %qD conflicts with virtual function table field name",
848 /* Stash away type declarations. */
849 if (TREE_CODE (value) == TYPE_DECL)
851 DECL_NONLOCAL (value) = 1;
852 DECL_CONTEXT (value) = current_class_type;
858 /* If this is a typedef that names the class for linkage purposes
859 (7.1.3p8), apply any attributes directly to the type. */
860 if (TAGGED_TYPE_P (TREE_TYPE (value))
861 && value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))))
862 attrflags = ATTR_FLAG_TYPE_IN_PLACE;
864 cplus_decl_attributes (&value, attrlist, attrflags);
867 if (declspecs->specs[(int)ds_typedef]
868 && TREE_TYPE (value) != error_mark_node
869 && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value)
870 set_underlying_type (value);
872 /* It's important that push_template_decl below follows
873 set_underlying_type above so that the created template
874 carries the properly set type of VALUE. */
875 if (processing_template_decl)
876 value = push_template_decl (value);
878 record_locally_defined_typedef (value);
882 if (DECL_IN_AGGR_P (value))
884 error ("%qD is already defined in %qT", value, DECL_CONTEXT (value));
885 return void_type_node;
888 if (asmspec_tree && asmspec_tree != error_mark_node)
889 asmspec = TREE_STRING_POINTER (asmspec_tree);
893 if (TREE_CODE (value) == FUNCTION_DECL)
895 /* Initializers for functions are rejected early in the parser.
896 If we get here, it must be a pure specifier for a method. */
897 if (init == ridpointers[(int)RID_DELETE])
899 DECL_DELETED_FN (value) = 1;
900 DECL_DECLARED_INLINE_P (value) = 1;
901 DECL_INITIAL (value) = error_mark_node;
903 else if (init == ridpointers[(int)RID_DEFAULT])
905 if (defaultable_fn_check (value))
907 DECL_DEFAULTED_FN (value) = 1;
908 DECL_INITIALIZED_IN_CLASS_P (value) = 1;
909 DECL_DECLARED_INLINE_P (value) = 1;
912 else if (TREE_CODE (init) == DEFAULT_ARG)
913 error ("invalid initializer for member function %qD", value);
914 else if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE)
916 if (integer_zerop (init))
917 DECL_PURE_VIRTUAL_P (value) = 1;
918 else if (error_operand_p (init))
919 ; /* An error has already been reported. */
921 error ("invalid initializer for member function %qD",
926 gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE);
927 error ("initializer specified for static member function %qD",
931 else if (TREE_CODE (value) == FIELD_DECL)
932 /* C++11 NSDMI, keep going. */;
933 else if (TREE_CODE (value) != VAR_DECL)
935 else if (!processing_template_decl)
937 if (TREE_CODE (init) == CONSTRUCTOR)
938 init = digest_init (TREE_TYPE (value), init, tf_warning_or_error);
939 init = maybe_constant_init (init);
941 if (init != error_mark_node && !TREE_CONSTANT (init))
943 /* We can allow references to things that are effectively
944 static, since references are initialized with the
946 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
947 || (TREE_STATIC (init) == 0
948 && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
950 error ("field initializer is not constant");
951 init = error_mark_node;
957 if (processing_template_decl
958 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
960 value = push_template_decl (value);
961 if (error_operand_p (value))
962 return error_mark_node;
966 cplus_decl_attributes (&value, attrlist, 0);
968 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
969 && CONSTRUCTOR_IS_DIRECT_INIT (init))
970 flags = LOOKUP_NORMAL;
972 flags = LOOKUP_IMPLICIT;
974 switch (TREE_CODE (value))
977 finish_static_data_member_decl (value, init, init_const_expr_p,
978 asmspec_tree, flags);
983 error ("%<asm%> specifiers are not permitted on non-static data members");
984 if (DECL_INITIAL (value) == error_mark_node)
985 init = error_mark_node;
986 cp_finish_decl (value, init, /*init_const_expr_p=*/false,
988 DECL_IN_AGGR_P (value) = 1;
993 set_user_assembler_name (value, asmspec);
995 cp_finish_decl (value,
997 /*init_const_expr_p=*/false,
998 asmspec_tree, flags);
1000 /* Pass friends back this way. */
1001 if (DECL_FRIEND_P (value))
1002 return void_type_node;
1004 DECL_IN_AGGR_P (value) = 1;
1013 /* Like `grokfield', but for bitfields.
1014 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1017 grokbitfield (const cp_declarator *declarator,
1018 cp_decl_specifier_seq *declspecs, tree width,
1021 tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, &attrlist);
1023 if (value == error_mark_node)
1024 return NULL_TREE; /* friends went bad. */
1026 /* Pass friendly classes back. */
1027 if (TREE_CODE (value) == VOID_TYPE)
1028 return void_type_node;
1030 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))
1031 && (POINTER_TYPE_P (value)
1032 || !dependent_type_p (TREE_TYPE (value))))
1034 error ("bit-field %qD with non-integral type", value);
1035 return error_mark_node;
1038 if (TREE_CODE (value) == TYPE_DECL)
1040 error ("cannot declare %qD to be a bit-field type", value);
1044 /* Usually, finish_struct_1 catches bitfields with invalid types.
1045 But, in the case of bitfields with function type, we confuse
1046 ourselves into thinking they are member functions, so we must
1048 if (TREE_CODE (value) == FUNCTION_DECL)
1050 error ("cannot declare bit-field %qD with function type",
1055 if (DECL_IN_AGGR_P (value))
1057 error ("%qD is already defined in the class %qT", value,
1058 DECL_CONTEXT (value));
1059 return void_type_node;
1062 if (TREE_STATIC (value))
1064 error ("static member %qD cannot be a bit-field", value);
1067 cp_finish_decl (value, NULL_TREE, false, NULL_TREE, 0);
1069 if (width != error_mark_node)
1071 /* The width must be an integer type. */
1072 if (!type_dependent_expression_p (width)
1073 && !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (width)))
1074 error ("width of bit-field %qD has non-integral type %qT", value,
1076 DECL_INITIAL (value) = width;
1077 SET_DECL_C_BIT_FIELD (value);
1080 DECL_IN_AGGR_P (value) = 1;
1083 cplus_decl_attributes (&value, attrlist, /*flags=*/0);
1089 /* Returns true iff ATTR is an attribute which needs to be applied at
1090 instantiation time rather than template definition time. */
1093 is_late_template_attribute (tree attr, tree decl)
1095 tree name = TREE_PURPOSE (attr);
1096 tree args = TREE_VALUE (attr);
1097 const struct attribute_spec *spec = lookup_attribute_spec (name);
1101 /* Unknown attribute. */
1104 /* Attribute weak handling wants to write out assembly right away. */
1105 if (is_attribute_p ("weak", name))
1108 /* If any of the arguments are dependent expressions, we can't evaluate
1109 the attribute until instantiation time. */
1110 for (arg = args; arg; arg = TREE_CHAIN (arg))
1112 tree t = TREE_VALUE (arg);
1114 /* If the first attribute argument is an identifier, only consider
1115 second and following arguments. Attributes like mode, format,
1116 cleanup and several target specific attributes aren't late
1117 just because they have an IDENTIFIER_NODE as first argument. */
1118 if (arg == args && TREE_CODE (t) == IDENTIFIER_NODE)
1121 if (value_dependent_expression_p (t)
1122 || type_dependent_expression_p (t))
1126 if (TREE_CODE (decl) == TYPE_DECL
1128 || spec->type_required)
1130 tree type = TYPE_P (decl) ? decl : TREE_TYPE (decl);
1132 /* We can't apply any attributes to a completely unknown type until
1133 instantiation time. */
1134 enum tree_code code = TREE_CODE (type);
1135 if (code == TEMPLATE_TYPE_PARM
1136 || code == BOUND_TEMPLATE_TEMPLATE_PARM
1137 || code == TYPENAME_TYPE)
1139 /* Also defer most attributes on dependent types. This is not
1140 necessary in all cases, but is the better default. */
1141 else if (dependent_type_p (type)
1142 /* But attribute visibility specifically works on
1144 && !is_attribute_p ("visibility", name))
1153 /* ATTR_P is a list of attributes. Remove any attributes which need to be
1154 applied at instantiation time and return them. If IS_DEPENDENT is true,
1155 the declaration itself is dependent, so all attributes should be applied
1156 at instantiation time. */
1159 splice_template_attributes (tree *attr_p, tree decl)
1162 tree late_attrs = NULL_TREE;
1163 tree *q = &late_attrs;
1170 if (is_late_template_attribute (*p, decl))
1172 ATTR_IS_DEPENDENT (*p) = 1;
1174 *p = TREE_CHAIN (*p);
1175 q = &TREE_CHAIN (*q);
1179 p = &TREE_CHAIN (*p);
1185 /* Remove any late attributes from the list in ATTR_P and attach them to
1189 save_template_attributes (tree *attr_p, tree *decl_p)
1191 tree late_attrs = splice_template_attributes (attr_p, *decl_p);
1193 tree old_attrs = NULL_TREE;
1198 if (DECL_P (*decl_p))
1199 q = &DECL_ATTRIBUTES (*decl_p);
1201 q = &TYPE_ATTRIBUTES (*decl_p);
1205 /* Merge the late attributes at the beginning with the attribute
1207 late_attrs = merge_attributes (late_attrs, *q);
1210 if (!DECL_P (*decl_p) && *decl_p == TYPE_MAIN_VARIANT (*decl_p))
1212 /* We've added new attributes directly to the main variant, so
1213 now we need to update all of the other variants to include
1214 these new attributes. */
1216 for (variant = TYPE_NEXT_VARIANT (*decl_p); variant;
1217 variant = TYPE_NEXT_VARIANT (variant))
1219 gcc_assert (TYPE_ATTRIBUTES (variant) == old_attrs);
1220 TYPE_ATTRIBUTES (variant) = TYPE_ATTRIBUTES (*decl_p);
1225 /* Like reconstruct_complex_type, but handle also template trees. */
1228 cp_reconstruct_complex_type (tree type, tree bottom)
1232 if (TREE_CODE (type) == POINTER_TYPE)
1234 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1235 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
1236 TYPE_REF_CAN_ALIAS_ALL (type));
1238 else if (TREE_CODE (type) == REFERENCE_TYPE)
1240 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1241 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
1242 TYPE_REF_CAN_ALIAS_ALL (type));
1244 else if (TREE_CODE (type) == ARRAY_TYPE)
1246 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1247 outer = build_cplus_array_type (inner, TYPE_DOMAIN (type));
1248 /* Don't call cp_build_qualified_type on ARRAY_TYPEs, the
1249 element type qualification will be handled by the recursive
1250 cp_reconstruct_complex_type call and cp_build_qualified_type
1251 for ARRAY_TYPEs changes the element type. */
1254 else if (TREE_CODE (type) == FUNCTION_TYPE)
1256 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1257 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
1258 outer = apply_memfn_quals (outer, type_memfn_quals (type));
1260 else if (TREE_CODE (type) == METHOD_TYPE)
1262 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1263 /* The build_method_type_directly() routine prepends 'this' to argument list,
1264 so we must compensate by getting rid of it. */
1266 = build_method_type_directly
1267 (class_of_this_parm (type), inner,
1268 TREE_CHAIN (TYPE_ARG_TYPES (type)));
1270 else if (TREE_CODE (type) == OFFSET_TYPE)
1272 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1273 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
1278 if (TYPE_ATTRIBUTES (type))
1279 outer = cp_build_type_attribute_variant (outer, TYPE_ATTRIBUTES (type));
1280 return cp_build_qualified_type (outer, cp_type_quals (type));
1283 /* Replaces any constexpr expression that may be into the attributes
1284 arguments with their reduced value. */
1287 cp_check_const_attributes (tree attributes)
1290 for (attr = attributes; attr; attr = TREE_CHAIN (attr))
1293 for (arg = TREE_VALUE (attr); arg; arg = TREE_CHAIN (arg))
1295 tree expr = TREE_VALUE (arg);
1297 TREE_VALUE (arg) = maybe_constant_value (expr);
1302 /* Like decl_attributes, but handle C++ complexity. */
1305 cplus_decl_attributes (tree *decl, tree attributes, int flags)
1307 if (*decl == NULL_TREE || *decl == void_type_node
1308 || *decl == error_mark_node
1309 || attributes == NULL_TREE)
1312 if (processing_template_decl)
1314 if (check_for_bare_parameter_packs (attributes))
1317 save_template_attributes (&attributes, decl);
1318 if (attributes == NULL_TREE)
1322 cp_check_const_attributes (attributes);
1324 if (TREE_CODE (*decl) == TEMPLATE_DECL)
1325 decl = &DECL_TEMPLATE_RESULT (*decl);
1327 decl_attributes (decl, attributes, flags);
1329 if (TREE_CODE (*decl) == TYPE_DECL)
1330 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1333 /* Walks through the namespace- or function-scope anonymous union
1334 OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
1335 Returns one of the fields for use in the mangled name. */
1338 build_anon_union_vars (tree type, tree object)
1340 tree main_decl = NULL_TREE;
1343 /* Rather than write the code to handle the non-union case,
1344 just give an error. */
1345 if (TREE_CODE (type) != UNION_TYPE)
1347 error ("anonymous struct not inside named type");
1348 return error_mark_node;
1351 for (field = TYPE_FIELDS (type);
1353 field = DECL_CHAIN (field))
1358 if (DECL_ARTIFICIAL (field))
1360 if (TREE_CODE (field) != FIELD_DECL)
1362 permerror (input_location, "%q+#D invalid; an anonymous union can only "
1363 "have non-static data members", field);
1367 if (TREE_PRIVATE (field))
1368 permerror (input_location, "private member %q+#D in anonymous union", field);
1369 else if (TREE_PROTECTED (field))
1370 permerror (input_location, "protected member %q+#D in anonymous union", field);
1372 if (processing_template_decl)
1373 ref = build_min_nt (COMPONENT_REF, object,
1374 DECL_NAME (field), NULL_TREE);
1376 ref = build_class_member_access_expr (object, field, NULL_TREE,
1377 false, tf_warning_or_error);
1379 if (DECL_NAME (field))
1383 decl = build_decl (input_location,
1384 VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
1385 DECL_ANON_UNION_VAR_P (decl) = 1;
1386 DECL_ARTIFICIAL (decl) = 1;
1388 base = get_base_address (object);
1389 TREE_PUBLIC (decl) = TREE_PUBLIC (base);
1390 TREE_STATIC (decl) = TREE_STATIC (base);
1391 DECL_EXTERNAL (decl) = DECL_EXTERNAL (base);
1393 SET_DECL_VALUE_EXPR (decl, ref);
1394 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1396 decl = pushdecl (decl);
1398 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1399 decl = build_anon_union_vars (TREE_TYPE (field), ref);
1403 if (main_decl == NULL_TREE)
1410 /* Finish off the processing of a UNION_TYPE structure. If the union is an
1411 anonymous union, then all members must be laid out together. PUBLIC_P
1412 is nonzero if this union is not declared static. */
1415 finish_anon_union (tree anon_union_decl)
1421 if (anon_union_decl == error_mark_node)
1424 type = TREE_TYPE (anon_union_decl);
1425 public_p = TREE_PUBLIC (anon_union_decl);
1427 /* The VAR_DECL's context is the same as the TYPE's context. */
1428 DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1430 if (TYPE_FIELDS (type) == NULL_TREE)
1435 error ("namespace-scope anonymous aggregates must be static");
1439 main_decl = build_anon_union_vars (type, anon_union_decl);
1440 if (main_decl == error_mark_node)
1442 if (main_decl == NULL_TREE)
1444 warning (0, "anonymous union with no members");
1448 if (!processing_template_decl)
1450 /* Use main_decl to set the mangled name. */
1451 DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
1452 maybe_commonize_var (anon_union_decl);
1453 if (TREE_STATIC (anon_union_decl) || DECL_EXTERNAL (anon_union_decl))
1454 mangle_decl (anon_union_decl);
1455 DECL_NAME (anon_union_decl) = NULL_TREE;
1458 pushdecl (anon_union_decl);
1459 cp_finish_decl (anon_union_decl, NULL_TREE, false, NULL_TREE, 0);
1462 /* Auxiliary functions to make type signatures for
1463 `operator new' and `operator delete' correspond to
1464 what compiler will be expecting. */
1467 coerce_new_type (tree type)
1470 tree args = TYPE_ARG_TYPES (type);
1472 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
1474 if (!same_type_p (TREE_TYPE (type), ptr_type_node))
1477 error ("%<operator new%> must return type %qT", ptr_type_node);
1480 if (args && args != void_list_node)
1482 if (TREE_PURPOSE (args))
1484 /* [basic.stc.dynamic.allocation]
1486 The first parameter shall not have an associated default
1488 error ("the first parameter of %<operator new%> cannot "
1489 "have a default argument");
1490 /* Throw away the default argument. */
1491 TREE_PURPOSE (args) = NULL_TREE;
1494 if (!same_type_p (TREE_VALUE (args), size_type_node))
1497 args = TREE_CHAIN (args);
1504 permerror (input_location, "%<operator new%> takes type %<size_t%> (%qT) "
1505 "as first parameter", size_type_node);
1510 args = tree_cons (NULL_TREE, size_type_node, args);
1513 type = build_exception_variant
1514 (build_function_type (ptr_type_node, args),
1515 TYPE_RAISES_EXCEPTIONS (type));
1523 coerce_delete_type (tree type)
1526 tree args = TYPE_ARG_TYPES (type);
1528 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
1530 if (!same_type_p (TREE_TYPE (type), void_type_node))
1533 error ("%<operator delete%> must return type %qT", void_type_node);
1536 if (!args || args == void_list_node
1537 || !same_type_p (TREE_VALUE (args), ptr_type_node))
1540 if (args && args != void_list_node)
1541 args = TREE_CHAIN (args);
1542 error ("%<operator delete%> takes type %qT as first parameter",
1548 args = tree_cons (NULL_TREE, ptr_type_node, args);
1551 type = build_exception_variant
1552 (build_function_type (void_type_node, args),
1553 TYPE_RAISES_EXCEPTIONS (type));
1561 /* DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
1562 and mark them as needed. */
1565 mark_vtable_entries (tree decl)
1568 unsigned HOST_WIDE_INT idx;
1570 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
1575 STRIP_NOPS (fnaddr);
1577 if (TREE_CODE (fnaddr) != ADDR_EXPR
1578 && TREE_CODE (fnaddr) != FDESC_EXPR)
1579 /* This entry is an offset: a virtual base class offset, a
1580 virtual call offset, an RTTI offset, etc. */
1583 fn = TREE_OPERAND (fnaddr, 0);
1584 TREE_ADDRESSABLE (fn) = 1;
1585 /* When we don't have vcall offsets, we output thunks whenever
1586 we output the vtables that contain them. With vcall offsets,
1587 we know all the thunks we'll need when we emit a virtual
1588 function, so we emit the thunks there instead. */
1589 if (DECL_THUNK_P (fn))
1590 use_thunk (fn, /*emit_p=*/0);
1595 /* Set DECL up to have the closest approximation of "initialized common"
1596 linkage available. */
1599 comdat_linkage (tree decl)
1602 make_decl_one_only (decl, cxx_comdat_group (decl));
1603 else if (TREE_CODE (decl) == FUNCTION_DECL
1604 || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1605 /* We can just emit function and compiler-generated variables
1606 statically; having multiple copies is (for the most part) only
1609 There are two correctness issues, however: the address of a
1610 template instantiation with external linkage should be the
1611 same, independent of what translation unit asks for the
1612 address, and this will not hold when we emit multiple copies of
1613 the function. However, there's little else we can do.
1615 Also, by default, the typeinfo implementation assumes that
1616 there will be only one copy of the string used as the name for
1617 each type. Therefore, if weak symbols are unavailable, the
1618 run-time library should perform a more conservative check; it
1619 should perform a string comparison, rather than an address
1621 TREE_PUBLIC (decl) = 0;
1624 /* Static data member template instantiations, however, cannot
1625 have multiple copies. */
1626 if (DECL_INITIAL (decl) == 0
1627 || DECL_INITIAL (decl) == error_mark_node)
1628 DECL_COMMON (decl) = 1;
1629 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1631 DECL_COMMON (decl) = 1;
1632 DECL_INITIAL (decl) = error_mark_node;
1634 else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1636 /* We can't do anything useful; leave vars for explicit
1638 DECL_EXTERNAL (decl) = 1;
1639 DECL_NOT_REALLY_EXTERN (decl) = 0;
1643 DECL_COMDAT (decl) = 1;
1646 /* For win32 we also want to put explicit instantiations in
1647 linkonce sections, so that they will be merged with implicit
1648 instantiations; otherwise we get duplicate symbol errors.
1649 For Darwin we do not want explicit instantiations to be
1653 maybe_make_one_only (tree decl)
1655 /* We used to say that this was not necessary on targets that support weak
1656 symbols, because the implicit instantiations will defer to the explicit
1657 one. However, that's not actually the case in SVR4; a strong definition
1658 after a weak one is an error. Also, not making explicit
1659 instantiations one_only means that we can end up with two copies of
1660 some template instantiations. */
1664 /* We can't set DECL_COMDAT on functions, or cp_finish_file will think
1665 we can get away with not emitting them if they aren't used. We need
1666 to for variables so that cp_finish_decl will update their linkage,
1667 because their DECL_INITIAL may not have been set properly yet. */
1669 if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
1670 || (! DECL_EXPLICIT_INSTANTIATION (decl)
1671 && ! DECL_TEMPLATE_SPECIALIZATION (decl)))
1673 make_decl_one_only (decl, cxx_comdat_group (decl));
1675 if (TREE_CODE (decl) == VAR_DECL)
1677 DECL_COMDAT (decl) = 1;
1678 /* Mark it needed so we don't forget to emit it. */
1679 mark_decl_referenced (decl);
1684 /* Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage.
1685 This predicate will give the right answer during parsing of the
1686 function, which other tests may not. */
1689 vague_linkage_p (tree decl)
1691 /* Unfortunately, import_export_decl has not always been called
1692 before the function is processed, so we cannot simply check
1694 return (DECL_COMDAT (decl)
1695 || (((TREE_CODE (decl) == FUNCTION_DECL
1696 && DECL_DECLARED_INLINE_P (decl))
1697 || (DECL_LANG_SPECIFIC (decl)
1698 && DECL_TEMPLATE_INSTANTIATION (decl)))
1699 && TREE_PUBLIC (decl)));
1702 /* Determine whether or not we want to specifically import or export CTYPE,
1703 using various heuristics. */
1706 import_export_class (tree ctype)
1708 /* -1 for imported, 1 for exported. */
1709 int import_export = 0;
1711 /* It only makes sense to call this function at EOF. The reason is
1712 that this function looks at whether or not the first non-inline
1713 non-abstract virtual member function has been defined in this
1714 translation unit. But, we can't possibly know that until we've
1715 seen the entire translation unit. */
1716 gcc_assert (at_eof);
1718 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1721 /* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,
1722 we will have CLASSTYPE_INTERFACE_ONLY set but not
1723 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
1724 heuristic because someone will supply a #pragma implementation
1725 elsewhere, and deducing it here would produce a conflict. */
1726 if (CLASSTYPE_INTERFACE_ONLY (ctype))
1729 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1731 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1733 else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1734 && !flag_implicit_templates)
1735 /* For a template class, without -fimplicit-templates, check the
1736 repository. If the virtual table is assigned to this
1737 translation unit, then export the class; otherwise, import
1739 import_export = repo_export_class_p (ctype) ? 1 : -1;
1740 else if (TYPE_POLYMORPHIC_P (ctype))
1742 /* The ABI specifies that the virtual table and associated
1743 information are emitted with the key method, if any. */
1744 tree method = CLASSTYPE_KEY_METHOD (ctype);
1745 /* If weak symbol support is not available, then we must be
1746 careful not to emit the vtable when the key function is
1747 inline. An inline function can be defined in multiple
1748 translation units. If we were to emit the vtable in each
1749 translation unit containing a definition, we would get
1750 multiple definition errors at link-time. */
1751 if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method)))
1752 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1755 /* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing
1756 a definition anywhere else. */
1757 if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
1760 /* Allow back ends the chance to overrule the decision. */
1761 if (targetm.cxx.import_export_class)
1762 import_export = targetm.cxx.import_export_class (ctype, import_export);
1766 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1767 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1771 /* Return true if VAR has already been provided to the back end; in that
1772 case VAR should not be modified further by the front end. */
1774 var_finalized_p (tree var)
1776 return varpool_node (var)->finalized;
1779 /* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
1780 must be emitted in this translation unit. Mark it as such. */
1783 mark_needed (tree decl)
1785 /* It's possible that we no longer need to set
1786 TREE_SYMBOL_REFERENCED here directly, but doing so is
1788 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
1789 mark_decl_referenced (decl);
1792 /* DECL is either a FUNCTION_DECL or a VAR_DECL. This function
1793 returns true if a definition of this entity should be provided in
1794 this object file. Callers use this function to determine whether
1795 or not to let the back end know that a definition of DECL is
1796 available in this translation unit. */
1799 decl_needed_p (tree decl)
1801 gcc_assert (TREE_CODE (decl) == VAR_DECL
1802 || TREE_CODE (decl) == FUNCTION_DECL);
1803 /* This function should only be called at the end of the translation
1804 unit. We cannot be sure of whether or not something will be
1805 COMDAT until that point. */
1806 gcc_assert (at_eof);
1808 /* All entities with external linkage that are not COMDAT should be
1809 emitted; they may be referred to from other object files. */
1810 if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1812 /* If this entity was used, let the back end see it; it will decide
1813 whether or not to emit it into the object file. */
1814 if (TREE_USED (decl)
1815 || (DECL_ASSEMBLER_NAME_SET_P (decl)
1816 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1818 /* Functions marked "dllexport" must be emitted so that they are
1819 visible to other DLLs. */
1820 if (flag_keep_inline_dllexport
1821 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
1823 /* Otherwise, DECL does not need to be emitted -- yet. A subsequent
1824 reference to DECL might cause it to be emitted later. */
1828 /* If necessary, write out the vtables for the dynamic class CTYPE.
1829 Returns true if any vtables were emitted. */
1832 maybe_emit_vtables (tree ctype)
1837 struct varpool_node *current = NULL, *last = NULL, *first = NULL;
1839 /* If the vtables for this class have already been emitted there is
1840 nothing more to do. */
1841 primary_vtbl = CLASSTYPE_VTABLES (ctype);
1842 if (var_finalized_p (primary_vtbl))
1844 /* Ignore dummy vtables made by get_vtable_decl. */
1845 if (TREE_TYPE (primary_vtbl) == void_type_node)
1848 /* On some targets, we cannot determine the key method until the end
1849 of the translation unit -- which is when this function is
1851 if (!targetm.cxx.key_method_may_be_inline ())
1852 determine_key_method (ctype);
1854 /* See if any of the vtables are needed. */
1855 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
1857 import_export_decl (vtbl);
1858 if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
1863 /* If the references to this class' vtables are optimized away,
1864 still emit the appropriate debugging information. See
1866 if (DECL_COMDAT (primary_vtbl)
1867 && CLASSTYPE_DEBUG_REQUESTED (ctype))
1868 note_debug_info_needed (ctype);
1872 /* The ABI requires that we emit all of the vtables if we emit any
1874 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
1876 /* Mark entities references from the virtual table as used. */
1877 mark_vtable_entries (vtbl);
1879 if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1881 VEC(tree,gc)* cleanups = NULL;
1882 tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), &cleanups,
1885 /* It had better be all done at compile-time. */
1886 gcc_assert (!expr && !cleanups);
1890 DECL_EXTERNAL (vtbl) = 0;
1891 rest_of_decl_compilation (vtbl, 1, 1);
1893 /* Because we're only doing syntax-checking, we'll never end up
1894 actually marking the variable as written. */
1895 if (flag_syntax_only)
1896 TREE_ASM_WRITTEN (vtbl) = 1;
1897 else if (DECL_ONE_ONLY (vtbl))
1899 current = varpool_node (vtbl);
1901 last->symbol.same_comdat_group = (symtab_node) current;
1909 last->symbol.same_comdat_group = (symtab_node)first;
1911 /* Since we're writing out the vtable here, also write the debug
1913 note_debug_info_needed (ctype);
1918 /* A special return value from type_visibility meaning internal
1921 enum { VISIBILITY_ANON = VISIBILITY_INTERNAL+1 };
1923 /* walk_tree helper function for type_visibility. */
1926 min_vis_r (tree *tp, int *walk_subtrees, void *data)
1928 int *vis_p = (int *)data;
1933 else if (CLASS_TYPE_P (*tp))
1935 if (!TREE_PUBLIC (TYPE_MAIN_DECL (*tp)))
1937 *vis_p = VISIBILITY_ANON;
1940 else if (CLASSTYPE_VISIBILITY (*tp) > *vis_p)
1941 *vis_p = CLASSTYPE_VISIBILITY (*tp);
1946 /* Returns the visibility of TYPE, which is the minimum visibility of its
1950 type_visibility (tree type)
1952 int vis = VISIBILITY_DEFAULT;
1953 cp_walk_tree_without_duplicates (&type, min_vis_r, &vis);
1957 /* Limit the visibility of DECL to VISIBILITY, if not explicitly
1958 specified (or if VISIBILITY is static). If TMPL is true, this
1959 constraint is for a template argument, and takes precedence
1960 over explicitly-specified visibility on the template. */
1963 constrain_visibility (tree decl, int visibility, bool tmpl)
1965 if (visibility == VISIBILITY_ANON)
1967 /* extern "C" declarations aren't affected by the anonymous
1969 if (!DECL_EXTERN_C_P (decl))
1971 TREE_PUBLIC (decl) = 0;
1972 DECL_WEAK (decl) = 0;
1973 DECL_COMMON (decl) = 0;
1974 DECL_COMDAT_GROUP (decl) = NULL_TREE;
1975 DECL_INTERFACE_KNOWN (decl) = 1;
1976 if (DECL_LANG_SPECIFIC (decl))
1977 DECL_NOT_REALLY_EXTERN (decl) = 1;
1980 else if (visibility > DECL_VISIBILITY (decl)
1981 && (tmpl || !DECL_VISIBILITY_SPECIFIED (decl)))
1983 DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility;
1984 /* This visibility was not specified. */
1985 DECL_VISIBILITY_SPECIFIED (decl) = false;
1989 /* Constrain the visibility of DECL based on the visibility of its template
1993 constrain_visibility_for_template (tree decl, tree targs)
1995 /* If this is a template instantiation, check the innermost
1996 template args for visibility constraints. The outer template
1997 args are covered by the class check. */
1998 tree args = INNERMOST_TEMPLATE_ARGS (targs);
2000 for (i = TREE_VEC_LENGTH (args); i > 0; --i)
2004 tree arg = TREE_VEC_ELT (args, i-1);
2006 vis = type_visibility (arg);
2007 else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
2010 if (TREE_CODE (arg) == ADDR_EXPR)
2011 arg = TREE_OPERAND (arg, 0);
2012 if (TREE_CODE (arg) == VAR_DECL
2013 || TREE_CODE (arg) == FUNCTION_DECL)
2015 if (! TREE_PUBLIC (arg))
2016 vis = VISIBILITY_ANON;
2018 vis = DECL_VISIBILITY (arg);
2022 constrain_visibility (decl, vis, true);
2026 /* Like c_determine_visibility, but with additional C++-specific
2029 Function-scope entities can rely on the function's visibility because
2030 it is set in start_preparsed_function.
2032 Class-scope entities cannot rely on the class's visibility until the end
2033 of the enclosing class definition.
2035 Note that because namespaces have multiple independent definitions,
2036 namespace visibility is handled elsewhere using the #pragma visibility
2037 machinery rather than by decorating the namespace declaration.
2039 The goal is for constraints from the type to give a diagnostic, and
2040 other constraints to be applied silently. */
2043 determine_visibility (tree decl)
2045 tree class_type = NULL_TREE;
2047 bool orig_visibility_specified;
2048 enum symbol_visibility orig_visibility;
2050 /* Remember that all decls get VISIBILITY_DEFAULT when built. */
2052 /* Only relevant for names with external linkage. */
2053 if (!TREE_PUBLIC (decl))
2056 /* Cloned constructors and destructors get the same visibility as
2057 the underlying function. That should be set up in
2058 maybe_clone_body. */
2059 gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
2061 orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl);
2062 orig_visibility = DECL_VISIBILITY (decl);
2064 if (TREE_CODE (decl) == TYPE_DECL)
2066 if (CLASS_TYPE_P (TREE_TYPE (decl)))
2067 use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
2068 else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
2073 else if (DECL_LANG_SPECIFIC (decl))
2074 use_template = DECL_USE_TEMPLATE (decl);
2078 /* If DECL is a member of a class, visibility specifiers on the
2079 class can influence the visibility of the DECL. */
2080 if (DECL_CLASS_SCOPE_P (decl))
2081 class_type = DECL_CONTEXT (decl);
2084 /* Not a class member. */
2086 /* Virtual tables have DECL_CONTEXT set to their associated class,
2087 so they are automatically handled above. */
2088 gcc_assert (TREE_CODE (decl) != VAR_DECL
2089 || !DECL_VTABLE_OR_VTT_P (decl));
2091 if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
2093 /* Local statics and classes get the visibility of their
2094 containing function by default, except that
2095 -fvisibility-inlines-hidden doesn't affect them. */
2096 tree fn = DECL_CONTEXT (decl);
2097 if (DECL_VISIBILITY_SPECIFIED (fn))
2099 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
2100 DECL_VISIBILITY_SPECIFIED (decl) =
2101 DECL_VISIBILITY_SPECIFIED (fn);
2105 if (DECL_CLASS_SCOPE_P (fn))
2106 determine_visibility_from_class (decl, DECL_CONTEXT (fn));
2107 else if (determine_hidden_inline (fn))
2109 DECL_VISIBILITY (decl) = default_visibility;
2110 DECL_VISIBILITY_SPECIFIED (decl) =
2111 visibility_options.inpragma;
2115 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
2116 DECL_VISIBILITY_SPECIFIED (decl) =
2117 DECL_VISIBILITY_SPECIFIED (fn);
2121 /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
2122 but have no TEMPLATE_INFO, so don't try to check it. */
2125 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl)
2126 && flag_visibility_ms_compat)
2128 /* Under -fvisibility-ms-compat, types are visible by default,
2129 even though their contents aren't. */
2130 tree underlying_type = TREE_TYPE (DECL_NAME (decl));
2131 int underlying_vis = type_visibility (underlying_type);
2132 if (underlying_vis == VISIBILITY_ANON
2133 || (CLASS_TYPE_P (underlying_type)
2134 && CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type)))
2135 constrain_visibility (decl, underlying_vis, false);
2137 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
2139 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2141 /* tinfo visibility is based on the type it's for. */
2142 constrain_visibility
2143 (decl, type_visibility (TREE_TYPE (DECL_NAME (decl))), false);
2145 /* Give the target a chance to override the visibility associated
2147 if (TREE_PUBLIC (decl)
2148 && !DECL_REALLY_EXTERN (decl)
2149 && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl)))
2150 && !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl))))
2151 targetm.cxx.determine_class_data_visibility (decl);
2153 else if (use_template)
2154 /* Template instantiations and specializations get visibility based
2155 on their template unless they override it with an attribute. */;
2156 else if (! DECL_VISIBILITY_SPECIFIED (decl))
2158 if (determine_hidden_inline (decl))
2159 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2162 /* Set default visibility to whatever the user supplied with
2163 #pragma GCC visibility or a namespace visibility attribute. */
2164 DECL_VISIBILITY (decl) = default_visibility;
2165 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
2172 /* If the specialization doesn't specify visibility, use the
2173 visibility from the template. */
2174 tree tinfo = (TREE_CODE (decl) == TYPE_DECL
2175 ? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2176 : DECL_TEMPLATE_INFO (decl));
2177 tree args = TI_ARGS (tinfo);
2178 tree attribs = (TREE_CODE (decl) == TYPE_DECL
2179 ? TYPE_ATTRIBUTES (TREE_TYPE (decl))
2180 : DECL_ATTRIBUTES (decl));
2182 if (args != error_mark_node)
2184 tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
2186 if (!DECL_VISIBILITY_SPECIFIED (decl))
2188 if (!DECL_VISIBILITY_SPECIFIED (pattern)
2189 && determine_hidden_inline (decl))
2190 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2193 DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
2194 DECL_VISIBILITY_SPECIFIED (decl)
2195 = DECL_VISIBILITY_SPECIFIED (pattern);
2200 /* Template argument visibility outweighs #pragma or namespace
2201 visibility, but not an explicit attribute. */
2202 && !lookup_attribute ("visibility", attribs))
2204 int depth = TMPL_ARGS_DEPTH (args);
2205 int class_depth = 0;
2206 if (class_type && CLASSTYPE_TEMPLATE_INFO (class_type))
2207 class_depth = TMPL_ARGS_DEPTH (CLASSTYPE_TI_ARGS (class_type));
2208 if (DECL_VISIBILITY_SPECIFIED (decl))
2210 /* A class template member with explicit visibility
2211 overrides the class visibility, so we need to apply
2212 all the levels of template args directly. */
2214 for (i = 1; i <= depth; ++i)
2216 tree lev = TMPL_ARGS_LEVEL (args, i);
2217 constrain_visibility_for_template (decl, lev);
2220 else if (depth > class_depth)
2221 /* Limit visibility based on its template arguments. */
2222 constrain_visibility_for_template (decl, args);
2228 determine_visibility_from_class (decl, class_type);
2230 if (decl_anon_ns_mem_p (decl))
2231 /* Names in an anonymous namespace get internal linkage.
2232 This might change once we implement export. */
2233 constrain_visibility (decl, VISIBILITY_ANON, false);
2234 else if (TREE_CODE (decl) != TYPE_DECL)
2236 /* Propagate anonymity from type to decl. */
2237 int tvis = type_visibility (TREE_TYPE (decl));
2238 if (tvis == VISIBILITY_ANON
2239 || ! DECL_VISIBILITY_SPECIFIED (decl))
2240 constrain_visibility (decl, tvis, false);
2242 else if (no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/true))
2243 /* DR 757: A type without linkage shall not be used as the type of a
2244 variable or function with linkage, unless
2245 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
2246 o the variable or function is not used (3.2 [basic.def.odr]) or is
2247 defined in the same translation unit.
2249 Since non-extern "C" decls need to be defined in the same
2250 translation unit, we can make the type internal. */
2251 constrain_visibility (decl, VISIBILITY_ANON, false);
2253 /* If visibility changed and DECL already has DECL_RTL, ensure
2254 symbol flags are updated. */
2255 if ((DECL_VISIBILITY (decl) != orig_visibility
2256 || DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified)
2257 && ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
2258 || TREE_CODE (decl) == FUNCTION_DECL)
2259 && DECL_RTL_SET_P (decl))
2260 make_decl_rtl (decl);
2263 /* By default, static data members and function members receive
2264 the visibility of their containing class. */
2267 determine_visibility_from_class (tree decl, tree class_type)
2269 if (DECL_VISIBILITY_SPECIFIED (decl))
2272 if (determine_hidden_inline (decl))
2273 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2276 /* Default to the class visibility. */
2277 DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
2278 DECL_VISIBILITY_SPECIFIED (decl)
2279 = CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
2282 /* Give the target a chance to override the visibility associated
2284 if (TREE_CODE (decl) == VAR_DECL
2285 && (DECL_TINFO_P (decl)
2286 || (DECL_VTABLE_OR_VTT_P (decl)
2287 /* Construction virtual tables are not exported because
2288 they cannot be referred to from other object files;
2289 their name is not standardized by the ABI. */
2290 && !DECL_CONSTRUCTION_VTABLE_P (decl)))
2291 && TREE_PUBLIC (decl)
2292 && !DECL_REALLY_EXTERN (decl)
2293 && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
2294 targetm.cxx.determine_class_data_visibility (decl);
2297 /* Returns true iff DECL is an inline that should get hidden visibility
2298 because of -fvisibility-inlines-hidden. */
2301 determine_hidden_inline (tree decl)
2303 return (visibility_options.inlines_hidden
2304 /* Don't do this for inline templates; specializations might not be
2305 inline, and we don't want them to inherit the hidden
2306 visibility. We'll set it here for all inline instantiations. */
2307 && !processing_template_decl
2308 && TREE_CODE (decl) == FUNCTION_DECL
2309 && DECL_DECLARED_INLINE_P (decl)
2310 && (! DECL_LANG_SPECIFIC (decl)
2311 || ! DECL_EXPLICIT_INSTANTIATION (decl)));
2314 /* Constrain the visibility of a class TYPE based on the visibility of its
2315 field types. Warn if any fields require lesser visibility. */
2318 constrain_class_visibility (tree type)
2324 int vis = type_visibility (type);
2326 if (vis == VISIBILITY_ANON
2327 || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
2330 /* Don't warn about visibility if the class has explicit visibility. */
2331 if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
2332 vis = VISIBILITY_INTERNAL;
2334 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
2335 if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
2337 tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
2338 int subvis = type_visibility (ftype);
2340 if (subvis == VISIBILITY_ANON)
2342 if (!in_main_input_context ())
2344 %qT has a field %qD whose type uses the anonymous namespace",
2347 else if (MAYBE_CLASS_TYPE_P (ftype)
2348 && vis < VISIBILITY_HIDDEN
2349 && subvis >= VISIBILITY_HIDDEN)
2350 warning (OPT_Wattributes, "\
2351 %qT declared with greater visibility than the type of its field %qD",
2355 binfo = TYPE_BINFO (type);
2356 for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
2358 int subvis = type_visibility (TREE_TYPE (t));
2360 if (subvis == VISIBILITY_ANON)
2362 if (!in_main_input_context())
2364 %qT has a base %qT whose type uses the anonymous namespace",
2365 type, TREE_TYPE (t));
2367 else if (vis < VISIBILITY_HIDDEN
2368 && subvis >= VISIBILITY_HIDDEN)
2369 warning (OPT_Wattributes, "\
2370 %qT declared with greater visibility than its base %qT",
2371 type, TREE_TYPE (t));
2375 /* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage
2376 for DECL has not already been determined, do so now by setting
2377 DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this
2378 function is called entities with vague linkage whose definitions
2379 are available must have TREE_PUBLIC set.
2381 If this function decides to place DECL in COMDAT, it will set
2382 appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
2383 the caller to decide whether or not to clear DECL_EXTERNAL. Some
2384 callers defer that decision until it is clear that DECL is actually
2388 import_export_decl (tree decl)
2393 tree class_type = NULL_TREE;
2395 if (DECL_INTERFACE_KNOWN (decl))
2398 /* We cannot determine what linkage to give to an entity with vague
2399 linkage until the end of the file. For example, a virtual table
2400 for a class will be defined if and only if the key method is
2401 defined in this translation unit. As a further example, consider
2402 that when compiling a translation unit that uses PCH file with
2403 "-frepo" it would be incorrect to make decisions about what
2404 entities to emit when building the PCH; those decisions must be
2405 delayed until the repository information has been processed. */
2406 gcc_assert (at_eof);
2407 /* Object file linkage for explicit instantiations is handled in
2408 mark_decl_instantiated. For static variables in functions with
2409 vague linkage, maybe_commonize_var is used.
2411 Therefore, the only declarations that should be provided to this
2412 function are those with external linkage that are:
2414 * implicit instantiations of function templates
2418 * implicit instantiations of static data members of class
2425 Furthermore, all entities that reach this point must have a
2426 definition available in this translation unit.
2428 The following assertions check these conditions. */
2429 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
2430 || TREE_CODE (decl) == VAR_DECL);
2431 /* Any code that creates entities with TREE_PUBLIC cleared should
2432 also set DECL_INTERFACE_KNOWN. */
2433 gcc_assert (TREE_PUBLIC (decl));
2434 if (TREE_CODE (decl) == FUNCTION_DECL)
2435 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2436 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
2437 || DECL_DECLARED_INLINE_P (decl));
2439 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2440 || DECL_VTABLE_OR_VTT_P (decl)
2441 || DECL_TINFO_P (decl));
2442 /* Check that a definition of DECL is available in this translation
2444 gcc_assert (!DECL_REALLY_EXTERN (decl));
2446 /* Assume that DECL will not have COMDAT linkage. */
2448 /* Assume that DECL will not be imported into this translation
2452 /* See if the repository tells us whether or not to emit DECL in
2453 this translation unit. */
2454 emit_p = repo_emit_p (decl);
2457 else if (emit_p == 1)
2459 /* The repository indicates that this entity should be defined
2460 here. Make sure the back end honors that request. */
2461 if (TREE_CODE (decl) == VAR_DECL)
2463 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
2464 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2467 FOR_EACH_CLONE (clone, decl)
2468 mark_needed (clone);
2472 /* Output the definition as an ordinary strong definition. */
2473 DECL_EXTERNAL (decl) = 0;
2474 DECL_INTERFACE_KNOWN (decl) = 1;
2479 /* We have already decided what to do with this DECL; there is no
2480 need to check anything further. */
2482 else if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
2484 class_type = DECL_CONTEXT (decl);
2485 import_export_class (class_type);
2486 if (TYPE_FOR_JAVA (class_type))
2488 else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
2489 && CLASSTYPE_INTERFACE_ONLY (class_type))
2491 else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
2492 && !CLASSTYPE_USE_TEMPLATE (class_type)
2493 && CLASSTYPE_KEY_METHOD (class_type)
2494 && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
2495 /* The ABI requires that all virtual tables be emitted with
2496 COMDAT linkage. However, on systems where COMDAT symbols
2497 don't show up in the table of contents for a static
2498 archive, or on systems without weak symbols (where we
2499 approximate COMDAT linkage by using internal linkage), the
2500 linker will report errors about undefined symbols because
2501 it will not see the virtual table definition. Therefore,
2502 in the case that we know that the virtual table will be
2503 emitted in only one translation unit, we make the virtual
2504 table an ordinary definition with external linkage. */
2505 DECL_EXTERNAL (decl) = 0;
2506 else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
2508 /* CLASS_TYPE is being exported from this translation unit,
2509 so DECL should be defined here. */
2510 if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
2511 /* If a class is declared in a header with the "extern
2512 template" extension, then it will not be instantiated,
2513 even in translation units that would normally require
2514 it. Often such classes are explicitly instantiated in
2515 one translation unit. Therefore, the explicit
2516 instantiation must be made visible to other translation
2518 DECL_EXTERNAL (decl) = 0;
2521 /* The generic C++ ABI says that class data is always
2522 COMDAT, even if there is a key function. Some
2523 variants (e.g., the ARM EABI) says that class data
2524 only has COMDAT linkage if the class data might be
2525 emitted in more than one translation unit. When the
2526 key method can be inline and is inline, we still have
2527 to arrange for comdat even though
2528 class_data_always_comdat is false. */
2529 if (!CLASSTYPE_KEY_METHOD (class_type)
2530 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))
2531 || targetm.cxx.class_data_always_comdat ())
2533 /* The ABI requires COMDAT linkage. Normally, we
2534 only emit COMDAT things when they are needed;
2535 make sure that we realize that this entity is
2542 else if (!flag_implicit_templates
2543 && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
2548 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2550 tree type = TREE_TYPE (DECL_NAME (decl));
2551 if (CLASS_TYPE_P (type))
2554 import_export_class (type);
2555 if (CLASSTYPE_INTERFACE_KNOWN (type)
2556 && TYPE_POLYMORPHIC_P (type)
2557 && CLASSTYPE_INTERFACE_ONLY (type)
2558 /* If -fno-rtti was specified, then we cannot be sure
2559 that RTTI information will be emitted with the
2560 virtual table of the class, so we must emit it
2561 wherever it is used. */
2566 if (CLASSTYPE_INTERFACE_KNOWN (type)
2567 && !CLASSTYPE_INTERFACE_ONLY (type))
2569 comdat_p = (targetm.cxx.class_data_always_comdat ()
2570 || (CLASSTYPE_KEY_METHOD (type)
2571 && DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type))));
2576 DECL_EXTERNAL (decl) = 0;
2586 else if (DECL_TEMPLATE_INSTANTIATION (decl)
2587 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2589 /* DECL is an implicit instantiation of a function or static
2591 if ((flag_implicit_templates
2592 && !flag_use_repository)
2593 || (flag_implicit_inline_templates
2594 && TREE_CODE (decl) == FUNCTION_DECL
2595 && DECL_DECLARED_INLINE_P (decl)))
2598 /* If we are not implicitly generating templates, then mark
2599 this entity as undefined in this translation unit. */
2602 else if (DECL_FUNCTION_MEMBER_P (decl))
2604 if (!DECL_DECLARED_INLINE_P (decl))
2606 tree ctype = DECL_CONTEXT (decl);
2607 import_export_class (ctype);
2608 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
2610 DECL_NOT_REALLY_EXTERN (decl)
2611 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2612 || (DECL_DECLARED_INLINE_P (decl)
2613 && ! flag_implement_inlines
2614 && !DECL_VINDEX (decl)));
2616 if (!DECL_NOT_REALLY_EXTERN (decl))
2617 DECL_EXTERNAL (decl) = 1;
2619 /* Always make artificials weak. */
2620 if (DECL_ARTIFICIAL (decl) && flag_weak)
2623 maybe_make_one_only (decl);
2634 /* If we are importing DECL into this translation unit, mark is
2635 an undefined here. */
2636 DECL_EXTERNAL (decl) = 1;
2637 DECL_NOT_REALLY_EXTERN (decl) = 0;
2641 /* If we decided to put DECL in COMDAT, mark it accordingly at
2643 comdat_linkage (decl);
2646 DECL_INTERFACE_KNOWN (decl) = 1;
2649 /* Return an expression that performs the destruction of DECL, which
2650 must be a VAR_DECL whose type has a non-trivial destructor, or is
2651 an array whose (innermost) elements have a non-trivial destructor. */
2654 build_cleanup (tree decl)
2657 tree type = TREE_TYPE (decl);
2659 /* This function should only be called for declarations that really
2660 require cleanups. */
2661 gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type));
2663 /* Treat all objects with destructors as used; the destructor may do
2664 something substantive. */
2667 if (TREE_CODE (type) == ARRAY_TYPE)
2670 temp = build_address (decl);
2671 temp = build_delete (TREE_TYPE (temp), temp,
2672 sfk_complete_destructor,
2673 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
2674 tf_warning_or_error);
2678 /* Returns the initialization guard variable for the variable DECL,
2679 which has static storage duration. */
2682 get_guard (tree decl)
2687 sname = mangle_guard_variable (decl);
2688 guard = IDENTIFIER_GLOBAL_VALUE (sname);
2693 /* We use a type that is big enough to contain a mutex as well
2694 as an integer counter. */
2695 guard_type = targetm.cxx.guard_type ();
2696 guard = build_decl (DECL_SOURCE_LOCATION (decl),
2697 VAR_DECL, sname, guard_type);
2699 /* The guard should have the same linkage as what it guards. */
2700 TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
2701 TREE_STATIC (guard) = TREE_STATIC (decl);
2702 DECL_COMMON (guard) = DECL_COMMON (decl);
2703 DECL_COMDAT (guard) = DECL_COMDAT (decl);
2704 if (DECL_ONE_ONLY (decl))
2705 make_decl_one_only (guard, cxx_comdat_group (guard));
2706 if (TREE_PUBLIC (decl))
2707 DECL_WEAK (guard) = DECL_WEAK (decl);
2708 DECL_VISIBILITY (guard) = DECL_VISIBILITY (decl);
2709 DECL_VISIBILITY_SPECIFIED (guard) = DECL_VISIBILITY_SPECIFIED (decl);
2711 DECL_ARTIFICIAL (guard) = 1;
2712 DECL_IGNORED_P (guard) = 1;
2713 TREE_USED (guard) = 1;
2714 pushdecl_top_level_and_finish (guard, NULL_TREE);
2719 /* Return those bits of the GUARD variable that should be set when the
2720 guarded entity is actually initialized. */
2723 get_guard_bits (tree guard)
2725 if (!targetm.cxx.guard_mask_bit ())
2727 /* We only set the first byte of the guard, in order to leave room
2728 for a mutex in the high-order bits. */
2729 guard = build1 (ADDR_EXPR,
2730 build_pointer_type (TREE_TYPE (guard)),
2732 guard = build1 (NOP_EXPR,
2733 build_pointer_type (char_type_node),
2735 guard = build1 (INDIRECT_REF, char_type_node, guard);
2741 /* Return an expression which determines whether or not the GUARD
2742 variable has already been initialized. */
2745 get_guard_cond (tree guard)
2749 /* Check to see if the GUARD is zero. */
2750 guard = get_guard_bits (guard);
2752 /* Mask off all but the low bit. */
2753 if (targetm.cxx.guard_mask_bit ())
2755 guard_value = integer_one_node;
2756 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2757 guard_value = convert (TREE_TYPE (guard), guard_value);
2758 guard = cp_build_binary_op (input_location,
2759 BIT_AND_EXPR, guard, guard_value,
2760 tf_warning_or_error);
2763 guard_value = integer_zero_node;
2764 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2765 guard_value = convert (TREE_TYPE (guard), guard_value);
2766 return cp_build_binary_op (input_location,
2767 EQ_EXPR, guard, guard_value,
2768 tf_warning_or_error);
2771 /* Return an expression which sets the GUARD variable, indicating that
2772 the variable being guarded has been initialized. */
2775 set_guard (tree guard)
2779 /* Set the GUARD to one. */
2780 guard = get_guard_bits (guard);
2781 guard_init = integer_one_node;
2782 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
2783 guard_init = convert (TREE_TYPE (guard), guard_init);
2784 return cp_build_modify_expr (guard, NOP_EXPR, guard_init,
2785 tf_warning_or_error);
2788 /* Start the process of running a particular set of global constructors
2789 or destructors. Subroutine of do_[cd]tors. */
2792 start_objects (int method_type, int initp)
2798 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
2800 if (initp != DEFAULT_INIT_PRIORITY)
2810 sprintf (type, "sub_%c%c%.5u", method_type, joiner, initp);
2813 sprintf (type, "sub_%c", method_type);
2815 fndecl = build_lang_decl (FUNCTION_DECL,
2816 get_file_function_name (type),
2817 build_function_type_list (void_type_node,
2819 start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
2821 TREE_PUBLIC (current_function_decl) = 0;
2823 /* Mark as artificial because it's not explicitly in the user's
2825 DECL_ARTIFICIAL (current_function_decl) = 1;
2827 /* Mark this declaration as used to avoid spurious warnings. */
2828 TREE_USED (current_function_decl) = 1;
2830 /* Mark this function as a global constructor or destructor. */
2831 if (method_type == 'I')
2832 DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
2834 DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
2836 body = begin_compound_stmt (BCS_FN_BODY);
2841 /* Finish the process of running a particular set of global constructors
2842 or destructors. Subroutine of do_[cd]tors. */
2845 finish_objects (int method_type, int initp, tree body)
2850 finish_compound_stmt (body);
2851 fn = finish_function (0);
2853 if (method_type == 'I')
2855 DECL_STATIC_CONSTRUCTOR (fn) = 1;
2856 decl_init_priority_insert (fn, initp);
2860 DECL_STATIC_DESTRUCTOR (fn) = 1;
2861 decl_fini_priority_insert (fn, initp);
2864 expand_or_defer_fn (fn);
2867 /* The names of the parameters to the function created to handle
2868 initializations and destructions for objects with static storage
2870 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2871 #define PRIORITY_IDENTIFIER "__priority"
2873 /* The name of the function we create to handle initializations and
2874 destructions for objects with static storage duration. */
2875 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2877 /* The declaration for the __INITIALIZE_P argument. */
2878 static GTY(()) tree initialize_p_decl;
2880 /* The declaration for the __PRIORITY argument. */
2881 static GTY(()) tree priority_decl;
2883 /* The declaration for the static storage duration function. */
2884 static GTY(()) tree ssdf_decl;
2886 /* All the static storage duration functions created in this
2887 translation unit. */
2888 static GTY(()) VEC(tree,gc) *ssdf_decls;
2890 /* A map from priority levels to information about that priority
2891 level. There may be many such levels, so efficient lookup is
2893 static splay_tree priority_info_map;
2895 /* Begins the generation of the function that will handle all
2896 initialization and destruction of objects with static storage
2897 duration. The function generated takes two parameters of type
2898 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2899 nonzero, it performs initializations. Otherwise, it performs
2900 destructions. It only performs those initializations or
2901 destructions with the indicated __PRIORITY. The generated function
2904 It is assumed that this function will only be called once per
2905 translation unit. */
2908 start_static_storage_duration_function (unsigned count)
2912 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2914 /* Create the identifier for this function. It will be of the form
2915 SSDF_IDENTIFIER_<number>. */
2916 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2918 type = build_function_type_list (void_type_node,
2919 integer_type_node, integer_type_node,
2922 /* Create the FUNCTION_DECL itself. */
2923 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2924 get_identifier (id),
2926 TREE_PUBLIC (ssdf_decl) = 0;
2927 DECL_ARTIFICIAL (ssdf_decl) = 1;
2929 /* Put this function in the list of functions to be called from the
2930 static constructors and destructors. */
2933 ssdf_decls = VEC_alloc (tree, gc, 32);
2935 /* Take this opportunity to initialize the map from priority
2936 numbers to information about that priority level. */
2937 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2938 /*delete_key_fn=*/0,
2939 /*delete_value_fn=*/
2940 (splay_tree_delete_value_fn) &free);
2942 /* We always need to generate functions for the
2943 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2944 priorities later, we'll be sure to find the
2945 DEFAULT_INIT_PRIORITY. */
2946 get_priority_info (DEFAULT_INIT_PRIORITY);
2949 VEC_safe_push (tree, gc, ssdf_decls, ssdf_decl);
2951 /* Create the argument list. */
2952 initialize_p_decl = cp_build_parm_decl
2953 (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2954 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2955 TREE_USED (initialize_p_decl) = 1;
2956 priority_decl = cp_build_parm_decl
2957 (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2958 DECL_CONTEXT (priority_decl) = ssdf_decl;
2959 TREE_USED (priority_decl) = 1;
2961 DECL_CHAIN (initialize_p_decl) = priority_decl;
2962 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2964 /* Put the function in the global scope. */
2965 pushdecl (ssdf_decl);
2967 /* Start the function itself. This is equivalent to declaring the
2970 static void __ssdf (int __initialize_p, init __priority_p);
2972 It is static because we only need to call this function from the
2973 various constructor and destructor functions for this module. */
2974 start_preparsed_function (ssdf_decl,
2975 /*attrs=*/NULL_TREE,
2978 /* Set up the scope of the outermost block in the function. */
2979 body = begin_compound_stmt (BCS_FN_BODY);
2984 /* Finish the generation of the function which performs initialization
2985 and destruction of objects with static storage duration. After
2986 this point, no more such objects can be created. */
2989 finish_static_storage_duration_function (tree body)
2991 /* Close out the function. */
2992 finish_compound_stmt (body);
2993 expand_or_defer_fn (finish_function (0));
2996 /* Return the information about the indicated PRIORITY level. If no
2997 code to handle this level has yet been generated, generate the
2998 appropriate prologue. */
3000 static priority_info
3001 get_priority_info (int priority)
3006 n = splay_tree_lookup (priority_info_map,
3007 (splay_tree_key) priority);
3010 /* Create a new priority information structure, and insert it
3012 pi = XNEW (struct priority_info_s);
3013 pi->initializations_p = 0;
3014 pi->destructions_p = 0;
3015 splay_tree_insert (priority_info_map,
3016 (splay_tree_key) priority,
3017 (splay_tree_value) pi);
3020 pi = (priority_info) n->value;
3025 /* The effective initialization priority of a DECL. */
3027 #define DECL_EFFECTIVE_INIT_PRIORITY(decl) \
3028 ((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \
3029 ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl))
3031 /* Whether a DECL needs a guard to protect it against multiple
3034 #define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl) \
3035 || DECL_ONE_ONLY (decl) \
3036 || DECL_WEAK (decl)))
3038 /* Called from one_static_initialization_or_destruction(),
3040 Walks the initializer list of a global variable and looks for
3041 temporary variables (DECL_NAME() == NULL and DECL_ARTIFICIAL != 0)
3042 and that have their DECL_CONTEXT() == NULL.
3043 For each such temporary variable, set their DECL_CONTEXT() to
3044 the current function. This is necessary because otherwise
3045 some optimizers (enabled by -O2 -fprofile-arcs) might crash
3046 when trying to refer to a temporary variable that does not have
3047 it's DECL_CONTECT() properly set. */
3049 fix_temporary_vars_context_r (tree *node,
3050 int *unused ATTRIBUTE_UNUSED,
3051 void *unused1 ATTRIBUTE_UNUSED)
3053 gcc_assert (current_function_decl);
3055 if (TREE_CODE (*node) == BIND_EXPR)
3059 for (var = BIND_EXPR_VARS (*node); var; var = DECL_CHAIN (var))
3060 if (TREE_CODE (var) == VAR_DECL
3062 && DECL_ARTIFICIAL (var)
3063 && !DECL_CONTEXT (var))
3064 DECL_CONTEXT (var) = current_function_decl;
3070 /* Set up to handle the initialization or destruction of DECL. If
3071 INITP is nonzero, we are initializing the variable. Otherwise, we
3072 are destroying it. */
3075 one_static_initialization_or_destruction (tree decl, tree init, bool initp)
3077 tree guard_if_stmt = NULL_TREE;
3080 /* If we are supposed to destruct and there's a trivial destructor,
3081 nothing has to be done. */
3083 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3086 /* Trick the compiler into thinking we are at the file and line
3087 where DECL was declared so that error-messages make sense, and so
3088 that the debugger will show somewhat sensible file and line
3090 input_location = DECL_SOURCE_LOCATION (decl);
3092 /* Make sure temporary variables in the initialiser all have
3093 their DECL_CONTEXT() set to a value different from NULL_TREE.
3094 This can happen when global variables initialisers are built.
3095 In that case, the DECL_CONTEXT() of the global variables _AND_ of all
3096 the temporary variables that might have been generated in the
3097 accompagning initialisers is NULL_TREE, meaning the variables have been
3098 declared in the global namespace.
3099 What we want to do here is to fix that and make sure the DECL_CONTEXT()
3100 of the temporaries are set to the current function decl. */
3101 cp_walk_tree_without_duplicates (&init,
3102 fix_temporary_vars_context_r,
3109 Access control for implicit calls to the constructors,
3110 the conversion functions, or the destructor called to
3111 create and destroy a static data member is performed as
3112 if these calls appeared in the scope of the member's
3115 we pretend we are in a static member function of the class of
3116 which the DECL is a member. */
3117 if (member_p (decl))
3119 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
3120 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
3123 /* Assume we don't need a guard. */
3125 /* We need a guard if this is an object with external linkage that
3126 might be initialized in more than one place. (For example, a
3127 static data member of a template, when the data member requires
3129 if (NEEDS_GUARD_P (decl))
3133 guard = get_guard (decl);
3135 /* When using __cxa_atexit, we just check the GUARD as we would
3136 for a local static. */
3137 if (flag_use_cxa_atexit)
3139 /* When using __cxa_atexit, we never try to destroy
3140 anything from a static destructor. */
3142 guard_cond = get_guard_cond (guard);
3144 /* If we don't have __cxa_atexit, then we will be running
3145 destructors from .fini sections, or their equivalents. So,
3146 we need to know how many times we've tried to initialize this
3147 object. We do initializations only if the GUARD is zero,
3148 i.e., if we are the first to initialize the variable. We do
3149 destructions only if the GUARD is one, i.e., if we are the
3150 last to destroy the variable. */
3153 = cp_build_binary_op (input_location,
3155 cp_build_unary_op (PREINCREMENT_EXPR,
3158 tf_warning_or_error),
3160 tf_warning_or_error);
3163 = cp_build_binary_op (input_location,
3165 cp_build_unary_op (PREDECREMENT_EXPR,
3168 tf_warning_or_error),
3170 tf_warning_or_error);
3172 guard_if_stmt = begin_if_stmt ();
3173 finish_if_stmt_cond (guard_cond, guard_if_stmt);
3177 /* If we're using __cxa_atexit, we have not already set the GUARD,
3178 so we must do so now. */
3179 if (guard && initp && flag_use_cxa_atexit)
3180 finish_expr_stmt (set_guard (guard));
3182 /* Perform the initialization or destruction. */
3186 finish_expr_stmt (init);
3188 /* If we're using __cxa_atexit, register a function that calls the
3189 destructor for the object. */
3190 if (flag_use_cxa_atexit)
3191 finish_expr_stmt (register_dtor_fn (decl));
3194 finish_expr_stmt (build_cleanup (decl));
3196 /* Finish the guard if-stmt, if necessary. */
3199 finish_then_clause (guard_if_stmt);
3200 finish_if_stmt (guard_if_stmt);
3203 /* Now that we're done with DECL we don't need to pretend to be a
3204 member of its class any longer. */
3205 DECL_CONTEXT (current_function_decl) = NULL_TREE;
3206 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
3209 /* Generate code to do the initialization or destruction of the decls in VARS,
3210 a TREE_LIST of VAR_DECL with static storage duration.
3211 Whether initialization or destruction is performed is specified by INITP. */
3214 do_static_initialization_or_destruction (tree vars, bool initp)
3216 tree node, init_if_stmt, cond;
3218 /* Build the outer if-stmt to check for initialization or destruction. */
3219 init_if_stmt = begin_if_stmt ();
3220 cond = initp ? integer_one_node : integer_zero_node;
3221 cond = cp_build_binary_op (input_location,
3225 tf_warning_or_error);
3226 finish_if_stmt_cond (cond, init_if_stmt);
3230 tree decl = TREE_VALUE (node);
3231 tree priority_if_stmt;
3235 /* If we don't need a destructor, there's nothing to do. Avoid
3236 creating a possibly empty if-stmt. */
3237 if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3239 node = TREE_CHAIN (node);
3243 /* Remember that we had an initialization or finalization at this
3245 priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
3246 pi = get_priority_info (priority);
3248 pi->initializations_p = 1;
3250 pi->destructions_p = 1;
3252 /* Conditionalize this initialization on being in the right priority
3253 and being initializing/finalizing appropriately. */
3254 priority_if_stmt = begin_if_stmt ();
3255 cond = cp_build_binary_op (input_location,
3258 build_int_cst (NULL_TREE, priority),
3259 tf_warning_or_error);
3260 finish_if_stmt_cond (cond, priority_if_stmt);
3262 /* Process initializers with same priority. */
3264 && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
3265 node = TREE_CHAIN (node))
3266 /* Do one initialization or destruction. */
3267 one_static_initialization_or_destruction (TREE_VALUE (node),
3268 TREE_PURPOSE (node), initp);
3270 /* Finish up the priority if-stmt body. */
3271 finish_then_clause (priority_if_stmt);
3272 finish_if_stmt (priority_if_stmt);
3276 /* Finish up the init/destruct if-stmt body. */
3277 finish_then_clause (init_if_stmt);
3278 finish_if_stmt (init_if_stmt);
3281 /* VARS is a list of variables with static storage duration which may
3282 need initialization and/or finalization. Remove those variables
3283 that don't really need to be initialized or finalized, and return
3284 the resulting list. The order in which the variables appear in
3285 VARS is in reverse order of the order in which they should actually
3286 be initialized. The list we return is in the unreversed order;
3287 i.e., the first variable should be initialized first. */
3290 prune_vars_needing_no_initialization (tree *vars)
3293 tree result = NULL_TREE;
3298 tree decl = TREE_VALUE (t);
3299 tree init = TREE_PURPOSE (t);
3301 /* Deal gracefully with error. */
3302 if (decl == error_mark_node)
3304 var = &TREE_CHAIN (t);
3308 /* The only things that can be initialized are variables. */
3309 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3311 /* If this object is not defined, we don't need to do anything
3313 if (DECL_EXTERNAL (decl))
3315 var = &TREE_CHAIN (t);
3319 /* Also, if the initializer already contains errors, we can bail
3321 if (init && TREE_CODE (init) == TREE_LIST
3322 && value_member (error_mark_node, init))
3324 var = &TREE_CHAIN (t);
3328 /* This variable is going to need initialization and/or
3329 finalization, so we add it to the list. */
3330 *var = TREE_CHAIN (t);
3331 TREE_CHAIN (t) = result;
3338 /* Make sure we have told the back end about all the variables in
3342 write_out_vars (tree vars)
3346 for (v = vars; v; v = TREE_CHAIN (v))
3348 tree var = TREE_VALUE (v);
3349 if (!var_finalized_p (var))
3351 import_export_decl (var);
3352 rest_of_decl_compilation (var, 1, 1);
3357 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
3358 (otherwise) that will initialize all global objects with static
3359 storage duration having the indicated PRIORITY. */
3362 generate_ctor_or_dtor_function (bool constructor_p, int priority,
3370 input_location = *locus;
3372 /* Was: locus->line++; */
3374 /* We use `I' to indicate initialization and `D' to indicate
3376 function_key = constructor_p ? 'I' : 'D';
3378 /* We emit the function lazily, to avoid generating empty
3379 global constructors and destructors. */
3382 /* For Objective-C++, we may need to initialize metadata found in this module.
3383 This must be done _before_ any other static initializations. */
3384 if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
3385 && constructor_p && objc_static_init_needed_p ())
3387 body = start_objects (function_key, priority);
3388 objc_generate_static_init_call (NULL_TREE);
3391 /* Call the static storage duration function with appropriate
3393 FOR_EACH_VEC_ELT (tree, ssdf_decls, i, fndecl)
3395 /* Calls to pure or const functions will expand to nothing. */
3396 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
3401 body = start_objects (function_key, priority);
3403 call = cp_build_function_call_nary (fndecl, tf_warning_or_error,
3404 build_int_cst (NULL_TREE,
3406 build_int_cst (NULL_TREE,
3409 finish_expr_stmt (call);
3413 /* Close out the function. */
3415 finish_objects (function_key, priority, body);
3418 /* Generate constructor and destructor functions for the priority
3422 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
3424 location_t *locus = (location_t *) data;
3425 int priority = (int) n->key;
3426 priority_info pi = (priority_info) n->value;
3428 /* Generate the functions themselves, but only if they are really
3430 if (pi->initializations_p)
3431 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
3432 if (pi->destructions_p)
3433 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
3435 /* Keep iterating. */
3439 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
3440 decls referenced from front-end specific constructs; it will be called
3441 only for language-specific tree nodes.
3443 Here we must deal with member pointers. */
3446 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED)
3450 switch (TREE_CODE (t))
3453 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
3454 cgraph_mark_address_taken_node (
3455 cgraph_get_create_node (PTRMEM_CST_MEMBER (t)));
3458 if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
3459 cgraph_mark_address_taken_node (
3460 cgraph_get_create_node (BASELINK_FUNCTIONS (t)));
3463 if (DECL_CONTEXT (t)
3464 && flag_use_repository
3465 && TREE_CODE (DECL_CONTEXT (t)) == FUNCTION_DECL)
3466 /* If we need a static variable in a function, then we
3467 need the containing function. */
3468 mark_decl_referenced (DECL_CONTEXT (t));
3477 /* Java requires that we be able to reference a local address for a
3478 method, and not be confused by PLT entries. If hidden aliases are
3479 supported, collect and return all the functions for which we should
3480 emit a hidden alias. */
3482 static struct pointer_set_t *
3483 collect_candidates_for_java_method_aliases (void)
3485 struct cgraph_node *node;
3486 struct pointer_set_t *candidates = NULL;
3488 #ifndef HAVE_GAS_HIDDEN
3492 FOR_EACH_FUNCTION (node)
3494 tree fndecl = node->symbol.decl;
3496 if (DECL_CONTEXT (fndecl)
3497 && TYPE_P (DECL_CONTEXT (fndecl))
3498 && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
3499 && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
3501 if (candidates == NULL)
3502 candidates = pointer_set_create ();
3503 pointer_set_insert (candidates, fndecl);
3511 /* Java requires that we be able to reference a local address for a
3512 method, and not be confused by PLT entries. If hidden aliases are
3513 supported, emit one for each java function that we've emitted.
3514 CANDIDATES is the set of FUNCTION_DECLs that were gathered
3515 by collect_candidates_for_java_method_aliases. */
3518 build_java_method_aliases (struct pointer_set_t *candidates)
3520 struct cgraph_node *node;
3522 #ifndef HAVE_GAS_HIDDEN
3526 FOR_EACH_FUNCTION (node)
3528 tree fndecl = node->symbol.decl;
3530 if (TREE_ASM_WRITTEN (fndecl)
3531 && pointer_set_contains (candidates, fndecl))
3533 /* Mangle the name in a predictable way; we need to reference
3534 this from a java compiled object file. */
3535 tree oid, nid, alias;
3539 oid = DECL_ASSEMBLER_NAME (fndecl);
3540 oname = IDENTIFIER_POINTER (oid);
3541 gcc_assert (oname[0] == '_' && oname[1] == 'Z');
3542 nname = ACONCAT (("_ZGA", oname+2, NULL));
3543 nid = get_identifier (nname);
3545 alias = make_alias_for (fndecl, nid);
3546 TREE_PUBLIC (alias) = 1;
3547 DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
3549 assemble_alias (alias, oid);
3554 /* Return C++ property of T, based on given operation OP. */
3557 cpp_check (tree t, cpp_operation op)
3562 return DECL_PURE_VIRTUAL_P (t);
3563 case IS_CONSTRUCTOR:
3564 return DECL_CONSTRUCTOR_P (t);
3566 return DECL_DESTRUCTOR_P (t);
3567 case IS_COPY_CONSTRUCTOR:
3568 return DECL_COPY_CONSTRUCTOR_P (t);
3570 return TREE_CODE (t) == TEMPLATE_DECL;
3576 /* Collect source file references recursively, starting from NAMESPC. */
3579 collect_source_refs (tree namespc)
3586 /* Iterate over names in this name space. */
3587 for (t = NAMESPACE_LEVEL (namespc)->names; t; t = TREE_CHAIN (t))
3588 if (!DECL_IS_BUILTIN (t) )
3589 collect_source_ref (DECL_SOURCE_FILE (t));
3591 /* Dump siblings, if any */
3592 collect_source_refs (TREE_CHAIN (namespc));
3594 /* Dump children, if any */
3595 collect_source_refs (NAMESPACE_LEVEL (namespc)->namespaces);
3598 /* Collect decls relevant to SOURCE_FILE from all namespaces recursively,
3599 starting from NAMESPC. */
3602 collect_ada_namespace (tree namespc, const char *source_file)
3607 /* Collect decls from this namespace */
3608 collect_ada_nodes (NAMESPACE_LEVEL (namespc)->names, source_file);
3610 /* Collect siblings, if any */
3611 collect_ada_namespace (TREE_CHAIN (namespc), source_file);
3613 /* Collect children, if any */
3614 collect_ada_namespace (NAMESPACE_LEVEL (namespc)->namespaces, source_file);
3617 /* Returns true iff there is a definition available for variable or
3621 decl_defined_p (tree decl)
3623 if (TREE_CODE (decl) == FUNCTION_DECL)
3624 return (DECL_INITIAL (decl) != NULL_TREE);
3627 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3628 return !DECL_EXTERNAL (decl);
3632 /* Nonzero for a VAR_DECL whose value can be used in a constant expression.
3636 An integral constant-expression can only involve ... const
3637 variables of integral or enumeration types initialized with
3638 constant expressions ...
3640 C++0x also allows constexpr variables and temporaries initialized
3641 with constant expressions. We handle the former here, but the latter
3642 are just folded away in cxx_eval_constant_expression.
3644 The standard does not require that the expression be non-volatile.
3645 G++ implements the proposed correction in DR 457. */
3648 decl_constant_var_p (tree decl)
3650 if (!decl_maybe_constant_var_p (decl))
3653 /* We don't know if a template static data member is initialized with
3654 a constant expression until we instantiate its initializer. Even
3655 in the case of a constexpr variable, we can't treat it as a
3656 constant until its initializer is complete in case it's used in
3657 its own initializer. */
3659 return DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl);
3662 /* Returns true if DECL could be a symbolic constant variable, depending on
3666 decl_maybe_constant_var_p (tree decl)
3668 tree type = TREE_TYPE (decl);
3669 if (TREE_CODE (decl) != VAR_DECL)
3671 if (DECL_DECLARED_CONSTEXPR_P (decl))
3673 return (CP_TYPE_CONST_NON_VOLATILE_P (type)
3674 && INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3677 /* Complain that DECL uses a type with no linkage but is never defined. */
3680 no_linkage_error (tree decl)
3682 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
3683 if (TYPE_ANONYMOUS_P (t))
3685 permerror (0, "%q+#D, declared using anonymous type, "
3686 "is used but never defined", decl);
3687 if (is_typedef_decl (TYPE_NAME (t)))
3688 permerror (0, "%q+#D does not refer to the unqualified type, "
3689 "so it is not used for linkage", TYPE_NAME (t));
3692 permerror (0, "%q+#D, declared using local type %qT, "
3693 "is used but never defined", decl, t);
3696 /* Collect declarations from all namespaces relevant to SOURCE_FILE. */
3699 collect_all_refs (const char *source_file)
3701 collect_ada_namespace (global_namespace, source_file);
3704 /* Clear DECL_EXTERNAL for NODE. */
3707 clear_decl_external (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
3709 DECL_EXTERNAL (node->symbol.decl) = 0;
3713 /* This routine is called at the end of compilation.
3714 Its job is to create all the code needed to initialize and
3715 destroy the global aggregates. We do the destruction
3716 first, since that way we only need to reverse the decls once. */
3719 cp_write_global_declarations (void)
3725 unsigned ssdf_count = 0;
3728 struct pointer_set_t *candidates;
3730 locus = input_location;
3733 /* Bad parse errors. Just forget about it. */
3734 if (! global_bindings_p () || current_class_type
3735 || !VEC_empty (tree,decl_namespace_list))
3739 c_common_write_pch ();
3741 cgraph_process_same_body_aliases ();
3743 /* Handle -fdump-ada-spec[-slim] */
3744 if (dump_enabled_p (TDI_ada))
3746 if (get_dump_file_info (TDI_ada)->flags & TDF_SLIM)
3747 collect_source_ref (main_input_filename);
3749 collect_source_refs (global_namespace);
3751 dump_ada_specs (collect_all_refs, cpp_check);
3754 /* FIXME - huh? was input_line -= 1;*/
3756 timevar_start (TV_PHASE_DEFERRED);
3758 /* We now have to write out all the stuff we put off writing out.
3761 o Template specializations that we have not yet instantiated,
3762 but which are needed.
3763 o Initialization and destruction for non-local objects with
3764 static storage duration. (Local objects with static storage
3765 duration are initialized when their scope is first entered,
3766 and are cleaned up via atexit.)
3767 o Virtual function tables.
3769 All of these may cause others to be needed. For example,
3770 instantiating one function may cause another to be needed, and
3771 generating the initializer for an object may cause templates to be
3772 instantiated, etc., etc. */
3774 emit_support_tinfos ();
3783 /* If there are templates that we've put off instantiating, do
3785 instantiate_pending_templates (retries);
3788 /* Write out virtual tables as required. Note that writing out
3789 the virtual table for a template class may cause the
3790 instantiation of members of that class. If we write out
3791 vtables then we remove the class from our list so we don't
3792 have to look at it again. */
3794 while (keyed_classes != NULL_TREE
3795 && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
3798 keyed_classes = TREE_CHAIN (keyed_classes);
3804 tree next = TREE_CHAIN (t);
3808 if (maybe_emit_vtables (TREE_VALUE (next)))
3811 TREE_CHAIN (t) = TREE_CHAIN (next);
3816 next = TREE_CHAIN (t);
3820 /* Write out needed type info variables. We have to be careful
3821 looping through unemitted decls, because emit_tinfo_decl may
3822 cause other variables to be needed. New elements will be
3823 appended, and we remove from the vector those that actually
3825 for (i = VEC_length (tree, unemitted_tinfo_decls);
3826 VEC_iterate (tree, unemitted_tinfo_decls, --i, t);)
3827 if (emit_tinfo_decl (t))
3830 VEC_unordered_remove (tree, unemitted_tinfo_decls, i);
3833 /* The list of objects with static storage duration is built up
3834 in reverse order. We clear STATIC_AGGREGATES so that any new
3835 aggregates added during the initialization of these will be
3836 initialized in the correct order when we next come around the
3838 vars = prune_vars_needing_no_initialization (&static_aggregates);
3842 /* We need to start a new initialization function each time
3843 through the loop. That's because we need to know which
3844 vtables have been referenced, and TREE_SYMBOL_REFERENCED
3845 isn't computed until a function is finished, and written
3846 out. That's a deficiency in the back end. When this is
3847 fixed, these initialization functions could all become
3848 inline, with resulting performance improvements. */
3851 /* Set the line and file, so that it is obviously not from
3853 input_location = locus;
3854 ssdf_body = start_static_storage_duration_function (ssdf_count);
3856 /* Make sure the back end knows about all the variables. */
3857 write_out_vars (vars);
3859 /* First generate code to do all the initializations. */
3861 do_static_initialization_or_destruction (vars, /*initp=*/true);
3863 /* Then, generate code to do all the destructions. Do these
3864 in reverse order so that the most recently constructed
3865 variable is the first destroyed. If we're using
3866 __cxa_atexit, then we don't need to do this; functions
3867 were registered at initialization time to destroy the
3869 if (!flag_use_cxa_atexit && vars)
3871 vars = nreverse (vars);
3872 do_static_initialization_or_destruction (vars, /*initp=*/false);
3877 /* Finish up the static storage duration function for this
3879 input_location = locus;
3880 finish_static_storage_duration_function (ssdf_body);
3882 /* All those initializations and finalizations might cause
3883 us to need more inline functions, more template
3884 instantiations, etc. */
3887 /* ??? was: locus.line++; */
3890 /* Go through the set of inline functions whose bodies have not
3891 been emitted yet. If out-of-line copies of these functions
3892 are required, emit them. */
3893 FOR_EACH_VEC_ELT (tree, deferred_fns, i, decl)
3895 /* Does it need synthesizing? */
3896 if (DECL_DEFAULTED_FN (decl) && ! DECL_INITIAL (decl)
3897 && (! DECL_REALLY_EXTERN (decl) || possibly_inlined_p (decl)))
3899 /* Even though we're already at the top-level, we push
3900 there again. That way, when we pop back a few lines
3901 hence, all of our state is restored. Otherwise,
3902 finish_function doesn't clean things up, and we end
3903 up with CURRENT_FUNCTION_DECL set. */
3904 push_to_top_level ();
3905 /* The decl's location will mark where it was first
3906 needed. Save that so synthesize method can indicate
3907 where it was needed from, in case of error */
3908 input_location = DECL_SOURCE_LOCATION (decl);
3909 synthesize_method (decl);
3910 pop_from_top_level ();
3914 if (!DECL_SAVED_TREE (decl))
3917 /* We lie to the back end, pretending that some functions
3918 are not defined when they really are. This keeps these
3919 functions from being put out unnecessarily. But, we must
3920 stop lying when the functions are referenced, or if they
3921 are not comdat since they need to be put out now. If
3922 DECL_INTERFACE_KNOWN, then we have already set
3923 DECL_EXTERNAL appropriately, so there's no need to check
3924 again, and we do not want to clear DECL_EXTERNAL if a
3925 previous call to import_export_decl set it.
3927 This is done in a separate for cycle, because if some
3928 deferred function is contained in another deferred
3929 function later in deferred_fns varray,
3930 rest_of_compilation would skip this function and we
3931 really cannot expand the same function twice. */
3932 import_export_decl (decl);
3933 if (DECL_NOT_REALLY_EXTERN (decl)
3934 && DECL_INITIAL (decl)
3935 && decl_needed_p (decl))
3937 struct cgraph_node *node, *next;
3939 node = cgraph_get_node (decl);
3940 if (node->same_body_alias)
3941 node = cgraph_alias_aliased_node (node);
3943 cgraph_for_node_and_aliases (node, clear_decl_external,
3945 /* If we mark !DECL_EXTERNAL one of the symbols in some comdat
3946 group, we need to mark all symbols in the same comdat group
3948 if (node->symbol.same_comdat_group)
3949 for (next = cgraph (node->symbol.same_comdat_group);
3951 next = cgraph (next->symbol.same_comdat_group))
3952 cgraph_for_node_and_aliases (next, clear_decl_external,
3956 /* If we're going to need to write this function out, and
3957 there's already a body for it, create RTL for it now.
3958 (There might be no body if this is a method we haven't
3959 gotten around to synthesizing yet.) */
3960 if (!DECL_EXTERNAL (decl)
3961 && decl_needed_p (decl)
3962 && !TREE_ASM_WRITTEN (decl)
3963 && !cgraph_get_node (decl)->local.finalized)
3965 /* We will output the function; no longer consider it in this
3967 DECL_DEFER_OUTPUT (decl) = 0;
3968 /* Generate RTL for this function now that we know we
3970 expand_or_defer_fn (decl);
3971 /* If we're compiling -fsyntax-only pretend that this
3972 function has been written out so that we don't try to
3974 if (flag_syntax_only)
3975 TREE_ASM_WRITTEN (decl) = 1;
3980 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
3983 /* Static data members are just like namespace-scope globals. */
3984 FOR_EACH_VEC_ELT (tree, pending_statics, i, decl)
3986 if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl)
3987 /* Don't write it out if we haven't seen a definition. */
3988 || DECL_IN_AGGR_P (decl))
3990 import_export_decl (decl);
3991 /* If this static data member is needed, provide it to the
3993 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
3994 DECL_EXTERNAL (decl) = 0;
3996 if (VEC_length (tree, pending_statics) != 0
3997 && wrapup_global_declarations (VEC_address (tree, pending_statics),
3998 VEC_length (tree, pending_statics)))
4005 /* All used inline functions must have a definition at this point. */
4006 FOR_EACH_VEC_ELT (tree, deferred_fns, i, decl)
4008 if (/* Check online inline functions that were actually used. */
4009 DECL_ODR_USED (decl) && DECL_DECLARED_INLINE_P (decl)
4010 /* If the definition actually was available here, then the
4011 fact that the function was not defined merely represents
4012 that for some reason (use of a template repository,
4013 #pragma interface, etc.) we decided not to emit the
4015 && !DECL_INITIAL (decl)
4016 /* Don't complain if the template was defined. */
4017 && !(DECL_TEMPLATE_INSTANTIATION (decl)
4018 && DECL_INITIAL (DECL_TEMPLATE_RESULT
4019 (template_for_substitution (decl)))))
4021 warning (0, "inline function %q+D used but never defined", decl);
4022 /* Avoid a duplicate warning from check_global_declaration_1. */
4023 TREE_NO_WARNING (decl) = 1;
4027 /* So must decls that use a type with no linkage. */
4028 FOR_EACH_VEC_ELT (tree, no_linkage_decls, i, decl)
4029 if (!decl_defined_p (decl))
4030 no_linkage_error (decl);
4032 /* Then, do the Objective-C stuff. This is where all the
4033 Objective-C module stuff gets generated (symtab,
4034 class/protocol/selector lists etc). This must be done after C++
4035 templates, destructors etc. so that selectors used in C++
4036 templates are properly allocated. */
4037 if (c_dialect_objc ())
4038 objc_write_global_declarations ();
4040 /* We give C linkage to static constructors and destructors. */
4041 push_lang_context (lang_name_c);
4043 /* Generate initialization and destruction functions for all
4044 priorities for which they are required. */
4045 if (priority_info_map)
4046 splay_tree_foreach (priority_info_map,
4047 generate_ctor_and_dtor_functions_for_priority,
4049 else if (c_dialect_objc () && objc_static_init_needed_p ())
4050 /* If this is obj-c++ and we need a static init, call
4051 generate_ctor_or_dtor_function. */
4052 generate_ctor_or_dtor_function (/*constructor_p=*/true,
4053 DEFAULT_INIT_PRIORITY, &locus);
4055 /* We're done with the splay-tree now. */
4056 if (priority_info_map)
4057 splay_tree_delete (priority_info_map);
4059 /* Generate any missing aliases. */
4060 maybe_apply_pending_pragma_weaks ();
4062 /* We're done with static constructors, so we can go back to "C++"
4064 pop_lang_context ();
4066 /* Collect candidates for Java hidden aliases. */
4067 candidates = collect_candidates_for_java_method_aliases ();
4069 timevar_stop (TV_PHASE_DEFERRED);
4070 timevar_start (TV_PHASE_CGRAPH);
4072 cgraph_finalize_compilation_unit ();
4074 timevar_stop (TV_PHASE_CGRAPH);
4075 timevar_start (TV_PHASE_CHECK_DBGINFO);
4077 /* Now, issue warnings about static, but not defined, functions,
4078 etc., and emit debugging information. */
4079 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
4080 if (VEC_length (tree, pending_statics) != 0)
4082 check_global_declarations (VEC_address (tree, pending_statics),
4083 VEC_length (tree, pending_statics));
4084 emit_debug_global_declarations (VEC_address (tree, pending_statics),
4085 VEC_length (tree, pending_statics));
4088 perform_deferred_noexcept_checks ();
4090 /* Generate hidden aliases for Java. */
4093 build_java_method_aliases (candidates);
4094 pointer_set_destroy (candidates);
4099 /* The entire file is now complete. If requested, dump everything
4103 FILE *stream = dump_begin (TDI_tu, &flags);
4107 dump_node (global_namespace, flags & ~TDF_SLIM, stream);
4108 dump_end (TDI_tu, stream);
4112 if (flag_detailed_statistics)
4114 dump_tree_statistics ();
4115 dump_time_statistics ();
4117 input_location = locus;
4119 #ifdef ENABLE_CHECKING
4120 validate_conversion_obstack ();
4121 #endif /* ENABLE_CHECKING */
4123 timevar_stop (TV_PHASE_CHECK_DBGINFO);
4126 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
4127 function to call in parse-tree form; it has not yet been
4128 semantically analyzed. ARGS are the arguments to the function.
4129 They have already been semantically analyzed. This may change
4133 build_offset_ref_call_from_tree (tree fn, VEC(tree,gc) **args)
4136 VEC(tree,gc) *orig_args = NULL;
4141 object = TREE_OPERAND (fn, 0);
4143 if (processing_template_decl)
4145 gcc_assert (TREE_CODE (fn) == DOTSTAR_EXPR
4146 || TREE_CODE (fn) == MEMBER_REF);
4147 if (type_dependent_expression_p (fn)
4148 || any_type_dependent_arguments_p (*args))
4149 return build_nt_call_vec (fn, *args);
4151 orig_args = make_tree_vector_copy (*args);
4153 /* Transform the arguments and add the implicit "this"
4154 parameter. That must be done before the FN is transformed
4155 because we depend on the form of FN. */
4156 make_args_non_dependent (*args);
4157 object = build_non_dependent_expr (object);
4158 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4160 if (TREE_CODE (fn) == DOTSTAR_EXPR)
4161 object = cp_build_addr_expr (object, tf_warning_or_error);
4162 VEC_safe_insert (tree, gc, *args, 0, object);
4164 /* Now that the arguments are done, transform FN. */
4165 fn = build_non_dependent_expr (fn);
4168 /* A qualified name corresponding to a bound pointer-to-member is
4169 represented as an OFFSET_REF:
4171 struct B { void g(); };
4173 void B::g() { (this->*p)(); } */
4174 if (TREE_CODE (fn) == OFFSET_REF)
4176 tree object_addr = cp_build_addr_expr (object, tf_warning_or_error);
4177 fn = TREE_OPERAND (fn, 1);
4178 fn = get_member_function_from_ptrfunc (&object_addr, fn,
4179 tf_warning_or_error);
4180 VEC_safe_insert (tree, gc, *args, 0, object_addr);
4183 if (CLASS_TYPE_P (TREE_TYPE (fn)))
4184 expr = build_op_call (fn, args, tf_warning_or_error);
4186 expr = cp_build_function_call_vec (fn, args, tf_warning_or_error);
4187 if (processing_template_decl && expr != error_mark_node)
4188 expr = build_min_non_dep_call_vec (expr, orig_fn, orig_args);
4190 if (orig_args != NULL)
4191 release_tree_vector (orig_args);
4198 check_default_args (tree x)
4200 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
4201 bool saw_def = false;
4202 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
4203 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
4205 if (TREE_PURPOSE (arg))
4209 error ("default argument missing for parameter %P of %q+#D", i, x);
4210 TREE_PURPOSE (arg) = error_mark_node;
4215 /* Return true if function DECL can be inlined. This is used to force
4216 instantiation of methods that might be interesting for inlining. */
4218 possibly_inlined_p (tree decl)
4220 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
4221 if (DECL_UNINLINABLE (decl))
4223 if (!optimize || pragma_java_exceptions)
4224 return DECL_DECLARED_INLINE_P (decl);
4225 /* When optimizing, we might inline everything when flatten
4226 attribute or heuristics inlining for size or autoinlining
4231 /* Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
4232 If DECL is a specialization or implicitly declared class member,
4233 generate the actual definition. Return false if something goes
4234 wrong, true otherwise. */
4237 mark_used (tree decl)
4239 /* If DECL is a BASELINK for a single function, then treat it just
4240 like the DECL for the function. Otherwise, if the BASELINK is
4241 for an overloaded function, we don't know which function was
4242 actually used until after overload resolution. */
4243 if (BASELINK_P (decl))
4245 decl = BASELINK_FUNCTIONS (decl);
4246 if (really_overloaded_fn (decl))
4248 decl = OVL_CURRENT (decl);
4251 /* Set TREE_USED for the benefit of -Wunused. */
4252 TREE_USED (decl) = 1;
4253 if (DECL_CLONED_FUNCTION_P (decl))
4254 TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4256 if (TREE_CODE (decl) == FUNCTION_DECL
4257 && DECL_DELETED_FN (decl))
4259 if (DECL_ARTIFICIAL (decl))
4261 if (DECL_OVERLOADED_OPERATOR_P (decl) == TYPE_EXPR
4262 && LAMBDA_TYPE_P (DECL_CONTEXT (decl)))
4264 /* We mark a lambda conversion op as deleted if we can't
4265 generate it properly; see maybe_add_lambda_conv_op. */
4266 sorry ("converting lambda which uses %<...%> to "
4267 "function pointer");
4271 error ("use of deleted function %qD", decl);
4272 if (!maybe_explain_implicit_delete (decl))
4273 error_at (DECL_SOURCE_LOCATION (decl), "declared here");
4277 /* We can only check DECL_ODR_USED on variables or functions with
4278 DECL_LANG_SPECIFIC set, and these are also the only decls that we
4279 might need special handling for. */
4280 if ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4281 || DECL_LANG_SPECIFIC (decl) == NULL
4282 || DECL_THUNK_P (decl))
4284 if (!processing_template_decl && type_uses_auto (TREE_TYPE (decl)))
4285 error ("use of %qD before deduction of %<auto%>", decl);
4289 /* We only want to do this processing once. We don't need to keep trying
4290 to instantiate inline templates, because unit-at-a-time will make sure
4291 we get them compiled before functions that want to inline them. */
4292 if (DECL_ODR_USED (decl))
4295 /* If within finish_function, defer the rest until that function
4296 finishes, otherwise it might recurse. */
4297 if (defer_mark_used_calls)
4299 VEC_safe_push (tree, gc, deferred_mark_used_calls, decl);
4303 if (TREE_CODE (decl) == FUNCTION_DECL)
4304 maybe_instantiate_noexcept (decl);
4306 /* Normally, we can wait until instantiation-time to synthesize DECL.
4307 However, if DECL is a static data member initialized with a constant
4308 or a constexpr function, we need it right now because a reference to
4309 such a data member or a call to such function is not value-dependent.
4310 For a function that uses auto in the return type, we need to instantiate
4311 it to find out its type. */
4312 if ((decl_maybe_constant_var_p (decl)
4313 || (TREE_CODE (decl) == FUNCTION_DECL
4314 && (DECL_DECLARED_CONSTEXPR_P (decl)
4315 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl))))))
4316 && DECL_LANG_SPECIFIC (decl)
4317 && DECL_TEMPLATE_INFO (decl)
4318 && !uses_template_parms (DECL_TI_ARGS (decl)))
4320 /* Instantiating a function will result in garbage collection. We
4321 must treat this situation as if we were within the body of a
4322 function so as to avoid collecting live data only referenced from
4323 the stack (such as overload resolution candidates). */
4325 instantiate_decl (decl, /*defer_ok=*/false,
4326 /*expl_inst_class_mem_p=*/false);
4330 if (type_uses_auto (TREE_TYPE (decl)))
4331 error ("use of %qD before deduction of %<auto%>", decl);
4333 /* If we don't need a value, then we don't need to synthesize DECL. */
4334 if (cp_unevaluated_operand != 0)
4337 if (processing_template_decl)
4340 /* Check this too in case we're within fold_non_dependent_expr. */
4341 if (DECL_TEMPLATE_INFO (decl)
4342 && uses_template_parms (DECL_TI_ARGS (decl)))
4345 DECL_ODR_USED (decl) = 1;
4346 if (DECL_CLONED_FUNCTION_P (decl))
4347 DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4349 /* DR 757: A type without linkage shall not be used as the type of a
4350 variable or function with linkage, unless
4351 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
4352 o the variable or function is not used (3.2 [basic.def.odr]) or is
4353 defined in the same translation unit. */
4354 if (cxx_dialect > cxx98
4355 && decl_linkage (decl) != lk_none
4356 && !DECL_EXTERN_C_P (decl)
4357 && !DECL_ARTIFICIAL (decl)
4358 && !decl_defined_p (decl)
4359 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
4361 if (is_local_extern (decl))
4362 /* There's no way to define a local extern, and adding it to
4363 the vector interferes with GC, so give an error now. */
4364 no_linkage_error (decl);
4366 VEC_safe_push (tree, gc, no_linkage_decls, decl);
4369 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
4370 && !DECL_INITIAL (decl) && !DECL_ARTIFICIAL (decl))
4371 /* Remember it, so we can check it was defined. */
4372 note_vague_linkage_fn (decl);
4374 /* Is it a synthesized method that needs to be synthesized? */
4375 if (TREE_CODE (decl) == FUNCTION_DECL
4376 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
4377 && DECL_DEFAULTED_FN (decl)
4378 /* A function defaulted outside the class is synthesized either by
4379 cp_finish_decl or instantiate_decl. */
4380 && !DECL_DEFAULTED_OUTSIDE_CLASS_P (decl)
4381 && ! DECL_INITIAL (decl))
4383 /* Defer virtual destructors so that thunks get the right
4385 if (DECL_VIRTUAL_P (decl) && !at_eof)
4387 note_vague_linkage_fn (decl);
4391 /* Remember the current location for a function we will end up
4392 synthesizing. Then we can inform the user where it was
4393 required in the case of error. */
4394 DECL_SOURCE_LOCATION (decl) = input_location;
4396 /* Synthesizing an implicitly defined member function will result in
4397 garbage collection. We must treat this situation as if we were
4398 within the body of a function so as to avoid collecting live data
4399 on the stack (such as overload resolution candidates).
4401 We could just let cp_write_global_declarations handle synthesizing
4402 this function by adding it to deferred_fns, but doing
4403 it at the use site produces better error messages. */
4405 synthesize_method (decl);
4407 /* If this is a synthesized method we don't need to
4408 do the instantiation test below. */
4410 else if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4411 && DECL_TEMPLATE_INFO (decl)
4412 && (!DECL_EXPLICIT_INSTANTIATION (decl)
4413 || always_instantiate_p (decl)))
4414 /* If this is a function or variable that is an instance of some
4415 template, we now know that we will need to actually do the
4416 instantiation. We check that DECL is not an explicit
4417 instantiation because that is not checked in instantiate_decl.
4419 We put off instantiating functions in order to improve compile
4420 times. Maintaining a stack of active functions is expensive,
4421 and the inliner knows to instantiate any functions it might
4422 need. Therefore, we always try to defer instantiation. */
4425 instantiate_decl (decl, /*defer_ok=*/true,
4426 /*expl_inst_class_mem_p=*/false);
4433 #include "gt-cp-decl2.h"