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 TREE_USED (decl) = 1;
1786 mark_decl_referenced (decl);
1789 /* DECL is either a FUNCTION_DECL or a VAR_DECL. This function
1790 returns true if a definition of this entity should be provided in
1791 this object file. Callers use this function to determine whether
1792 or not to let the back end know that a definition of DECL is
1793 available in this translation unit. */
1796 decl_needed_p (tree decl)
1798 gcc_assert (TREE_CODE (decl) == VAR_DECL
1799 || TREE_CODE (decl) == FUNCTION_DECL);
1800 /* This function should only be called at the end of the translation
1801 unit. We cannot be sure of whether or not something will be
1802 COMDAT until that point. */
1803 gcc_assert (at_eof);
1805 /* All entities with external linkage that are not COMDAT should be
1806 emitted; they may be referred to from other object files. */
1807 if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1809 /* If this entity was used, let the back end see it; it will decide
1810 whether or not to emit it into the object file. */
1811 if (TREE_USED (decl))
1813 /* Functions marked "dllexport" must be emitted so that they are
1814 visible to other DLLs. */
1815 if (flag_keep_inline_dllexport
1816 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
1818 /* Otherwise, DECL does not need to be emitted -- yet. A subsequent
1819 reference to DECL might cause it to be emitted later. */
1823 /* If necessary, write out the vtables for the dynamic class CTYPE.
1824 Returns true if any vtables were emitted. */
1827 maybe_emit_vtables (tree ctype)
1832 struct varpool_node *current = NULL, *last = NULL, *first = NULL;
1834 /* If the vtables for this class have already been emitted there is
1835 nothing more to do. */
1836 primary_vtbl = CLASSTYPE_VTABLES (ctype);
1837 if (var_finalized_p (primary_vtbl))
1839 /* Ignore dummy vtables made by get_vtable_decl. */
1840 if (TREE_TYPE (primary_vtbl) == void_type_node)
1843 /* On some targets, we cannot determine the key method until the end
1844 of the translation unit -- which is when this function is
1846 if (!targetm.cxx.key_method_may_be_inline ())
1847 determine_key_method (ctype);
1849 /* See if any of the vtables are needed. */
1850 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
1852 import_export_decl (vtbl);
1853 if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
1858 /* If the references to this class' vtables are optimized away,
1859 still emit the appropriate debugging information. See
1861 if (DECL_COMDAT (primary_vtbl)
1862 && CLASSTYPE_DEBUG_REQUESTED (ctype))
1863 note_debug_info_needed (ctype);
1867 /* The ABI requires that we emit all of the vtables if we emit any
1869 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
1871 /* Mark entities references from the virtual table as used. */
1872 mark_vtable_entries (vtbl);
1874 if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1876 VEC(tree,gc)* cleanups = NULL;
1877 tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), &cleanups,
1880 /* It had better be all done at compile-time. */
1881 gcc_assert (!expr && !cleanups);
1885 DECL_EXTERNAL (vtbl) = 0;
1886 rest_of_decl_compilation (vtbl, 1, 1);
1888 /* Because we're only doing syntax-checking, we'll never end up
1889 actually marking the variable as written. */
1890 if (flag_syntax_only)
1891 TREE_ASM_WRITTEN (vtbl) = 1;
1892 else if (DECL_ONE_ONLY (vtbl))
1894 current = varpool_node (vtbl);
1896 last->symbol.same_comdat_group = (symtab_node) current;
1904 last->symbol.same_comdat_group = (symtab_node)first;
1906 /* Since we're writing out the vtable here, also write the debug
1908 note_debug_info_needed (ctype);
1913 /* A special return value from type_visibility meaning internal
1916 enum { VISIBILITY_ANON = VISIBILITY_INTERNAL+1 };
1918 /* walk_tree helper function for type_visibility. */
1921 min_vis_r (tree *tp, int *walk_subtrees, void *data)
1923 int *vis_p = (int *)data;
1928 else if (CLASS_TYPE_P (*tp))
1930 if (!TREE_PUBLIC (TYPE_MAIN_DECL (*tp)))
1932 *vis_p = VISIBILITY_ANON;
1935 else if (CLASSTYPE_VISIBILITY (*tp) > *vis_p)
1936 *vis_p = CLASSTYPE_VISIBILITY (*tp);
1941 /* Returns the visibility of TYPE, which is the minimum visibility of its
1945 type_visibility (tree type)
1947 int vis = VISIBILITY_DEFAULT;
1948 cp_walk_tree_without_duplicates (&type, min_vis_r, &vis);
1952 /* Limit the visibility of DECL to VISIBILITY, if not explicitly
1953 specified (or if VISIBILITY is static). If TMPL is true, this
1954 constraint is for a template argument, and takes precedence
1955 over explicitly-specified visibility on the template. */
1958 constrain_visibility (tree decl, int visibility, bool tmpl)
1960 if (visibility == VISIBILITY_ANON)
1962 /* extern "C" declarations aren't affected by the anonymous
1964 if (!DECL_EXTERN_C_P (decl))
1966 TREE_PUBLIC (decl) = 0;
1967 DECL_WEAK (decl) = 0;
1968 DECL_COMMON (decl) = 0;
1969 DECL_COMDAT_GROUP (decl) = NULL_TREE;
1970 DECL_INTERFACE_KNOWN (decl) = 1;
1971 if (DECL_LANG_SPECIFIC (decl))
1972 DECL_NOT_REALLY_EXTERN (decl) = 1;
1975 else if (visibility > DECL_VISIBILITY (decl)
1976 && (tmpl || !DECL_VISIBILITY_SPECIFIED (decl)))
1978 DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility;
1979 /* This visibility was not specified. */
1980 DECL_VISIBILITY_SPECIFIED (decl) = false;
1984 /* Constrain the visibility of DECL based on the visibility of its template
1988 constrain_visibility_for_template (tree decl, tree targs)
1990 /* If this is a template instantiation, check the innermost
1991 template args for visibility constraints. The outer template
1992 args are covered by the class check. */
1993 tree args = INNERMOST_TEMPLATE_ARGS (targs);
1995 for (i = TREE_VEC_LENGTH (args); i > 0; --i)
1999 tree arg = TREE_VEC_ELT (args, i-1);
2001 vis = type_visibility (arg);
2002 else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
2005 if (TREE_CODE (arg) == ADDR_EXPR)
2006 arg = TREE_OPERAND (arg, 0);
2007 if (TREE_CODE (arg) == VAR_DECL
2008 || TREE_CODE (arg) == FUNCTION_DECL)
2010 if (! TREE_PUBLIC (arg))
2011 vis = VISIBILITY_ANON;
2013 vis = DECL_VISIBILITY (arg);
2017 constrain_visibility (decl, vis, true);
2021 /* Like c_determine_visibility, but with additional C++-specific
2024 Function-scope entities can rely on the function's visibility because
2025 it is set in start_preparsed_function.
2027 Class-scope entities cannot rely on the class's visibility until the end
2028 of the enclosing class definition.
2030 Note that because namespaces have multiple independent definitions,
2031 namespace visibility is handled elsewhere using the #pragma visibility
2032 machinery rather than by decorating the namespace declaration.
2034 The goal is for constraints from the type to give a diagnostic, and
2035 other constraints to be applied silently. */
2038 determine_visibility (tree decl)
2040 tree class_type = NULL_TREE;
2042 bool orig_visibility_specified;
2043 enum symbol_visibility orig_visibility;
2045 /* Remember that all decls get VISIBILITY_DEFAULT when built. */
2047 /* Only relevant for names with external linkage. */
2048 if (!TREE_PUBLIC (decl))
2051 /* Cloned constructors and destructors get the same visibility as
2052 the underlying function. That should be set up in
2053 maybe_clone_body. */
2054 gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
2056 orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl);
2057 orig_visibility = DECL_VISIBILITY (decl);
2059 if (TREE_CODE (decl) == TYPE_DECL)
2061 if (CLASS_TYPE_P (TREE_TYPE (decl)))
2062 use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
2063 else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
2068 else if (DECL_LANG_SPECIFIC (decl))
2069 use_template = DECL_USE_TEMPLATE (decl);
2073 /* If DECL is a member of a class, visibility specifiers on the
2074 class can influence the visibility of the DECL. */
2075 if (DECL_CLASS_SCOPE_P (decl))
2076 class_type = DECL_CONTEXT (decl);
2079 /* Not a class member. */
2081 /* Virtual tables have DECL_CONTEXT set to their associated class,
2082 so they are automatically handled above. */
2083 gcc_assert (TREE_CODE (decl) != VAR_DECL
2084 || !DECL_VTABLE_OR_VTT_P (decl));
2086 if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
2088 /* Local statics and classes get the visibility of their
2089 containing function by default, except that
2090 -fvisibility-inlines-hidden doesn't affect them. */
2091 tree fn = DECL_CONTEXT (decl);
2092 if (DECL_VISIBILITY_SPECIFIED (fn))
2094 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
2095 DECL_VISIBILITY_SPECIFIED (decl) =
2096 DECL_VISIBILITY_SPECIFIED (fn);
2100 if (DECL_CLASS_SCOPE_P (fn))
2101 determine_visibility_from_class (decl, DECL_CONTEXT (fn));
2102 else if (determine_hidden_inline (fn))
2104 DECL_VISIBILITY (decl) = default_visibility;
2105 DECL_VISIBILITY_SPECIFIED (decl) =
2106 visibility_options.inpragma;
2110 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
2111 DECL_VISIBILITY_SPECIFIED (decl) =
2112 DECL_VISIBILITY_SPECIFIED (fn);
2116 /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
2117 but have no TEMPLATE_INFO, so don't try to check it. */
2120 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl)
2121 && flag_visibility_ms_compat)
2123 /* Under -fvisibility-ms-compat, types are visible by default,
2124 even though their contents aren't. */
2125 tree underlying_type = TREE_TYPE (DECL_NAME (decl));
2126 int underlying_vis = type_visibility (underlying_type);
2127 if (underlying_vis == VISIBILITY_ANON
2128 || (CLASS_TYPE_P (underlying_type)
2129 && CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type)))
2130 constrain_visibility (decl, underlying_vis, false);
2132 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
2134 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2136 /* tinfo visibility is based on the type it's for. */
2137 constrain_visibility
2138 (decl, type_visibility (TREE_TYPE (DECL_NAME (decl))), false);
2140 /* Give the target a chance to override the visibility associated
2142 if (TREE_PUBLIC (decl)
2143 && !DECL_REALLY_EXTERN (decl)
2144 && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl)))
2145 && !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl))))
2146 targetm.cxx.determine_class_data_visibility (decl);
2148 else if (use_template)
2149 /* Template instantiations and specializations get visibility based
2150 on their template unless they override it with an attribute. */;
2151 else if (! DECL_VISIBILITY_SPECIFIED (decl))
2153 if (determine_hidden_inline (decl))
2154 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2157 /* Set default visibility to whatever the user supplied with
2158 #pragma GCC visibility or a namespace visibility attribute. */
2159 DECL_VISIBILITY (decl) = default_visibility;
2160 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
2167 /* If the specialization doesn't specify visibility, use the
2168 visibility from the template. */
2169 tree tinfo = (TREE_CODE (decl) == TYPE_DECL
2170 ? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2171 : DECL_TEMPLATE_INFO (decl));
2172 tree args = TI_ARGS (tinfo);
2173 tree attribs = (TREE_CODE (decl) == TYPE_DECL
2174 ? TYPE_ATTRIBUTES (TREE_TYPE (decl))
2175 : DECL_ATTRIBUTES (decl));
2177 if (args != error_mark_node)
2179 tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
2181 if (!DECL_VISIBILITY_SPECIFIED (decl))
2183 if (!DECL_VISIBILITY_SPECIFIED (pattern)
2184 && determine_hidden_inline (decl))
2185 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2188 DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
2189 DECL_VISIBILITY_SPECIFIED (decl)
2190 = DECL_VISIBILITY_SPECIFIED (pattern);
2195 /* Template argument visibility outweighs #pragma or namespace
2196 visibility, but not an explicit attribute. */
2197 && !lookup_attribute ("visibility", attribs))
2199 int depth = TMPL_ARGS_DEPTH (args);
2200 int class_depth = 0;
2201 if (class_type && CLASSTYPE_TEMPLATE_INFO (class_type))
2202 class_depth = TMPL_ARGS_DEPTH (CLASSTYPE_TI_ARGS (class_type));
2203 if (DECL_VISIBILITY_SPECIFIED (decl))
2205 /* A class template member with explicit visibility
2206 overrides the class visibility, so we need to apply
2207 all the levels of template args directly. */
2209 for (i = 1; i <= depth; ++i)
2211 tree lev = TMPL_ARGS_LEVEL (args, i);
2212 constrain_visibility_for_template (decl, lev);
2215 else if (depth > class_depth)
2216 /* Limit visibility based on its template arguments. */
2217 constrain_visibility_for_template (decl, args);
2223 determine_visibility_from_class (decl, class_type);
2225 if (decl_anon_ns_mem_p (decl))
2226 /* Names in an anonymous namespace get internal linkage.
2227 This might change once we implement export. */
2228 constrain_visibility (decl, VISIBILITY_ANON, false);
2229 else if (TREE_CODE (decl) != TYPE_DECL)
2231 /* Propagate anonymity from type to decl. */
2232 int tvis = type_visibility (TREE_TYPE (decl));
2233 if (tvis == VISIBILITY_ANON
2234 || ! DECL_VISIBILITY_SPECIFIED (decl))
2235 constrain_visibility (decl, tvis, false);
2237 else if (no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/true))
2238 /* DR 757: A type without linkage shall not be used as the type of a
2239 variable or function with linkage, unless
2240 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
2241 o the variable or function is not used (3.2 [basic.def.odr]) or is
2242 defined in the same translation unit.
2244 Since non-extern "C" decls need to be defined in the same
2245 translation unit, we can make the type internal. */
2246 constrain_visibility (decl, VISIBILITY_ANON, false);
2248 /* If visibility changed and DECL already has DECL_RTL, ensure
2249 symbol flags are updated. */
2250 if ((DECL_VISIBILITY (decl) != orig_visibility
2251 || DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified)
2252 && ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
2253 || TREE_CODE (decl) == FUNCTION_DECL)
2254 && DECL_RTL_SET_P (decl))
2255 make_decl_rtl (decl);
2258 /* By default, static data members and function members receive
2259 the visibility of their containing class. */
2262 determine_visibility_from_class (tree decl, tree class_type)
2264 if (DECL_VISIBILITY_SPECIFIED (decl))
2267 if (determine_hidden_inline (decl))
2268 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2271 /* Default to the class visibility. */
2272 DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
2273 DECL_VISIBILITY_SPECIFIED (decl)
2274 = CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
2277 /* Give the target a chance to override the visibility associated
2279 if (TREE_CODE (decl) == VAR_DECL
2280 && (DECL_TINFO_P (decl)
2281 || (DECL_VTABLE_OR_VTT_P (decl)
2282 /* Construction virtual tables are not exported because
2283 they cannot be referred to from other object files;
2284 their name is not standardized by the ABI. */
2285 && !DECL_CONSTRUCTION_VTABLE_P (decl)))
2286 && TREE_PUBLIC (decl)
2287 && !DECL_REALLY_EXTERN (decl)
2288 && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
2289 targetm.cxx.determine_class_data_visibility (decl);
2292 /* Returns true iff DECL is an inline that should get hidden visibility
2293 because of -fvisibility-inlines-hidden. */
2296 determine_hidden_inline (tree decl)
2298 return (visibility_options.inlines_hidden
2299 /* Don't do this for inline templates; specializations might not be
2300 inline, and we don't want them to inherit the hidden
2301 visibility. We'll set it here for all inline instantiations. */
2302 && !processing_template_decl
2303 && TREE_CODE (decl) == FUNCTION_DECL
2304 && DECL_DECLARED_INLINE_P (decl)
2305 && (! DECL_LANG_SPECIFIC (decl)
2306 || ! DECL_EXPLICIT_INSTANTIATION (decl)));
2309 /* Constrain the visibility of a class TYPE based on the visibility of its
2310 field types. Warn if any fields require lesser visibility. */
2313 constrain_class_visibility (tree type)
2319 int vis = type_visibility (type);
2321 if (vis == VISIBILITY_ANON
2322 || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
2325 /* Don't warn about visibility if the class has explicit visibility. */
2326 if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
2327 vis = VISIBILITY_INTERNAL;
2329 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
2330 if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
2332 tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
2333 int subvis = type_visibility (ftype);
2335 if (subvis == VISIBILITY_ANON)
2337 if (!in_main_input_context ())
2339 %qT has a field %qD whose type uses the anonymous namespace",
2342 else if (MAYBE_CLASS_TYPE_P (ftype)
2343 && vis < VISIBILITY_HIDDEN
2344 && subvis >= VISIBILITY_HIDDEN)
2345 warning (OPT_Wattributes, "\
2346 %qT declared with greater visibility than the type of its field %qD",
2350 binfo = TYPE_BINFO (type);
2351 for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
2353 int subvis = type_visibility (TREE_TYPE (t));
2355 if (subvis == VISIBILITY_ANON)
2357 if (!in_main_input_context())
2359 %qT has a base %qT whose type uses the anonymous namespace",
2360 type, TREE_TYPE (t));
2362 else if (vis < VISIBILITY_HIDDEN
2363 && subvis >= VISIBILITY_HIDDEN)
2364 warning (OPT_Wattributes, "\
2365 %qT declared with greater visibility than its base %qT",
2366 type, TREE_TYPE (t));
2370 /* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage
2371 for DECL has not already been determined, do so now by setting
2372 DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this
2373 function is called entities with vague linkage whose definitions
2374 are available must have TREE_PUBLIC set.
2376 If this function decides to place DECL in COMDAT, it will set
2377 appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
2378 the caller to decide whether or not to clear DECL_EXTERNAL. Some
2379 callers defer that decision until it is clear that DECL is actually
2383 import_export_decl (tree decl)
2388 tree class_type = NULL_TREE;
2390 if (DECL_INTERFACE_KNOWN (decl))
2393 /* We cannot determine what linkage to give to an entity with vague
2394 linkage until the end of the file. For example, a virtual table
2395 for a class will be defined if and only if the key method is
2396 defined in this translation unit. As a further example, consider
2397 that when compiling a translation unit that uses PCH file with
2398 "-frepo" it would be incorrect to make decisions about what
2399 entities to emit when building the PCH; those decisions must be
2400 delayed until the repository information has been processed. */
2401 gcc_assert (at_eof);
2402 /* Object file linkage for explicit instantiations is handled in
2403 mark_decl_instantiated. For static variables in functions with
2404 vague linkage, maybe_commonize_var is used.
2406 Therefore, the only declarations that should be provided to this
2407 function are those with external linkage that are:
2409 * implicit instantiations of function templates
2413 * implicit instantiations of static data members of class
2420 Furthermore, all entities that reach this point must have a
2421 definition available in this translation unit.
2423 The following assertions check these conditions. */
2424 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
2425 || TREE_CODE (decl) == VAR_DECL);
2426 /* Any code that creates entities with TREE_PUBLIC cleared should
2427 also set DECL_INTERFACE_KNOWN. */
2428 gcc_assert (TREE_PUBLIC (decl));
2429 if (TREE_CODE (decl) == FUNCTION_DECL)
2430 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2431 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
2432 || DECL_DECLARED_INLINE_P (decl));
2434 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2435 || DECL_VTABLE_OR_VTT_P (decl)
2436 || DECL_TINFO_P (decl));
2437 /* Check that a definition of DECL is available in this translation
2439 gcc_assert (!DECL_REALLY_EXTERN (decl));
2441 /* Assume that DECL will not have COMDAT linkage. */
2443 /* Assume that DECL will not be imported into this translation
2447 /* See if the repository tells us whether or not to emit DECL in
2448 this translation unit. */
2449 emit_p = repo_emit_p (decl);
2452 else if (emit_p == 1)
2454 /* The repository indicates that this entity should be defined
2455 here. Make sure the back end honors that request. */
2456 if (TREE_CODE (decl) == VAR_DECL)
2458 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
2459 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2462 FOR_EACH_CLONE (clone, decl)
2463 mark_needed (clone);
2467 /* Output the definition as an ordinary strong definition. */
2468 DECL_EXTERNAL (decl) = 0;
2469 DECL_INTERFACE_KNOWN (decl) = 1;
2474 /* We have already decided what to do with this DECL; there is no
2475 need to check anything further. */
2477 else if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
2479 class_type = DECL_CONTEXT (decl);
2480 import_export_class (class_type);
2481 if (TYPE_FOR_JAVA (class_type))
2483 else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
2484 && CLASSTYPE_INTERFACE_ONLY (class_type))
2486 else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
2487 && !CLASSTYPE_USE_TEMPLATE (class_type)
2488 && CLASSTYPE_KEY_METHOD (class_type)
2489 && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
2490 /* The ABI requires that all virtual tables be emitted with
2491 COMDAT linkage. However, on systems where COMDAT symbols
2492 don't show up in the table of contents for a static
2493 archive, or on systems without weak symbols (where we
2494 approximate COMDAT linkage by using internal linkage), the
2495 linker will report errors about undefined symbols because
2496 it will not see the virtual table definition. Therefore,
2497 in the case that we know that the virtual table will be
2498 emitted in only one translation unit, we make the virtual
2499 table an ordinary definition with external linkage. */
2500 DECL_EXTERNAL (decl) = 0;
2501 else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
2503 /* CLASS_TYPE is being exported from this translation unit,
2504 so DECL should be defined here. */
2505 if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
2506 /* If a class is declared in a header with the "extern
2507 template" extension, then it will not be instantiated,
2508 even in translation units that would normally require
2509 it. Often such classes are explicitly instantiated in
2510 one translation unit. Therefore, the explicit
2511 instantiation must be made visible to other translation
2513 DECL_EXTERNAL (decl) = 0;
2516 /* The generic C++ ABI says that class data is always
2517 COMDAT, even if there is a key function. Some
2518 variants (e.g., the ARM EABI) says that class data
2519 only has COMDAT linkage if the class data might be
2520 emitted in more than one translation unit. When the
2521 key method can be inline and is inline, we still have
2522 to arrange for comdat even though
2523 class_data_always_comdat is false. */
2524 if (!CLASSTYPE_KEY_METHOD (class_type)
2525 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))
2526 || targetm.cxx.class_data_always_comdat ())
2528 /* The ABI requires COMDAT linkage. Normally, we
2529 only emit COMDAT things when they are needed;
2530 make sure that we realize that this entity is
2537 else if (!flag_implicit_templates
2538 && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
2543 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2545 tree type = TREE_TYPE (DECL_NAME (decl));
2546 if (CLASS_TYPE_P (type))
2549 import_export_class (type);
2550 if (CLASSTYPE_INTERFACE_KNOWN (type)
2551 && TYPE_POLYMORPHIC_P (type)
2552 && CLASSTYPE_INTERFACE_ONLY (type)
2553 /* If -fno-rtti was specified, then we cannot be sure
2554 that RTTI information will be emitted with the
2555 virtual table of the class, so we must emit it
2556 wherever it is used. */
2561 if (CLASSTYPE_INTERFACE_KNOWN (type)
2562 && !CLASSTYPE_INTERFACE_ONLY (type))
2564 comdat_p = (targetm.cxx.class_data_always_comdat ()
2565 || (CLASSTYPE_KEY_METHOD (type)
2566 && DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type))));
2571 DECL_EXTERNAL (decl) = 0;
2581 else if (DECL_TEMPLATE_INSTANTIATION (decl)
2582 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2584 /* DECL is an implicit instantiation of a function or static
2586 if ((flag_implicit_templates
2587 && !flag_use_repository)
2588 || (flag_implicit_inline_templates
2589 && TREE_CODE (decl) == FUNCTION_DECL
2590 && DECL_DECLARED_INLINE_P (decl)))
2593 /* If we are not implicitly generating templates, then mark
2594 this entity as undefined in this translation unit. */
2597 else if (DECL_FUNCTION_MEMBER_P (decl))
2599 if (!DECL_DECLARED_INLINE_P (decl))
2601 tree ctype = DECL_CONTEXT (decl);
2602 import_export_class (ctype);
2603 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
2605 DECL_NOT_REALLY_EXTERN (decl)
2606 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2607 || (DECL_DECLARED_INLINE_P (decl)
2608 && ! flag_implement_inlines
2609 && !DECL_VINDEX (decl)));
2611 if (!DECL_NOT_REALLY_EXTERN (decl))
2612 DECL_EXTERNAL (decl) = 1;
2614 /* Always make artificials weak. */
2615 if (DECL_ARTIFICIAL (decl) && flag_weak)
2618 maybe_make_one_only (decl);
2629 /* If we are importing DECL into this translation unit, mark is
2630 an undefined here. */
2631 DECL_EXTERNAL (decl) = 1;
2632 DECL_NOT_REALLY_EXTERN (decl) = 0;
2636 /* If we decided to put DECL in COMDAT, mark it accordingly at
2638 comdat_linkage (decl);
2641 DECL_INTERFACE_KNOWN (decl) = 1;
2644 /* Return an expression that performs the destruction of DECL, which
2645 must be a VAR_DECL whose type has a non-trivial destructor, or is
2646 an array whose (innermost) elements have a non-trivial destructor. */
2649 build_cleanup (tree decl)
2652 tree type = TREE_TYPE (decl);
2654 /* This function should only be called for declarations that really
2655 require cleanups. */
2656 gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type));
2658 /* Treat all objects with destructors as used; the destructor may do
2659 something substantive. */
2662 if (TREE_CODE (type) == ARRAY_TYPE)
2665 temp = build_address (decl);
2666 temp = build_delete (TREE_TYPE (temp), temp,
2667 sfk_complete_destructor,
2668 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
2669 tf_warning_or_error);
2673 /* Returns the initialization guard variable for the variable DECL,
2674 which has static storage duration. */
2677 get_guard (tree decl)
2682 sname = mangle_guard_variable (decl);
2683 guard = IDENTIFIER_GLOBAL_VALUE (sname);
2688 /* We use a type that is big enough to contain a mutex as well
2689 as an integer counter. */
2690 guard_type = targetm.cxx.guard_type ();
2691 guard = build_decl (DECL_SOURCE_LOCATION (decl),
2692 VAR_DECL, sname, guard_type);
2694 /* The guard should have the same linkage as what it guards. */
2695 TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
2696 TREE_STATIC (guard) = TREE_STATIC (decl);
2697 DECL_COMMON (guard) = DECL_COMMON (decl);
2698 DECL_COMDAT (guard) = DECL_COMDAT (decl);
2699 if (DECL_ONE_ONLY (decl))
2700 make_decl_one_only (guard, cxx_comdat_group (guard));
2701 if (TREE_PUBLIC (decl))
2702 DECL_WEAK (guard) = DECL_WEAK (decl);
2703 DECL_VISIBILITY (guard) = DECL_VISIBILITY (decl);
2704 DECL_VISIBILITY_SPECIFIED (guard) = DECL_VISIBILITY_SPECIFIED (decl);
2706 DECL_ARTIFICIAL (guard) = 1;
2707 DECL_IGNORED_P (guard) = 1;
2708 TREE_USED (guard) = 1;
2709 pushdecl_top_level_and_finish (guard, NULL_TREE);
2714 /* Return those bits of the GUARD variable that should be set when the
2715 guarded entity is actually initialized. */
2718 get_guard_bits (tree guard)
2720 if (!targetm.cxx.guard_mask_bit ())
2722 /* We only set the first byte of the guard, in order to leave room
2723 for a mutex in the high-order bits. */
2724 guard = build1 (ADDR_EXPR,
2725 build_pointer_type (TREE_TYPE (guard)),
2727 guard = build1 (NOP_EXPR,
2728 build_pointer_type (char_type_node),
2730 guard = build1 (INDIRECT_REF, char_type_node, guard);
2736 /* Return an expression which determines whether or not the GUARD
2737 variable has already been initialized. */
2740 get_guard_cond (tree guard)
2744 /* Check to see if the GUARD is zero. */
2745 guard = get_guard_bits (guard);
2747 /* Mask off all but the low bit. */
2748 if (targetm.cxx.guard_mask_bit ())
2750 guard_value = integer_one_node;
2751 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2752 guard_value = convert (TREE_TYPE (guard), guard_value);
2753 guard = cp_build_binary_op (input_location,
2754 BIT_AND_EXPR, guard, guard_value,
2755 tf_warning_or_error);
2758 guard_value = integer_zero_node;
2759 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2760 guard_value = convert (TREE_TYPE (guard), guard_value);
2761 return cp_build_binary_op (input_location,
2762 EQ_EXPR, guard, guard_value,
2763 tf_warning_or_error);
2766 /* Return an expression which sets the GUARD variable, indicating that
2767 the variable being guarded has been initialized. */
2770 set_guard (tree guard)
2774 /* Set the GUARD to one. */
2775 guard = get_guard_bits (guard);
2776 guard_init = integer_one_node;
2777 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
2778 guard_init = convert (TREE_TYPE (guard), guard_init);
2779 return cp_build_modify_expr (guard, NOP_EXPR, guard_init,
2780 tf_warning_or_error);
2783 /* Start the process of running a particular set of global constructors
2784 or destructors. Subroutine of do_[cd]tors. */
2787 start_objects (int method_type, int initp)
2793 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
2795 if (initp != DEFAULT_INIT_PRIORITY)
2805 sprintf (type, "sub_%c%c%.5u", method_type, joiner, initp);
2808 sprintf (type, "sub_%c", method_type);
2810 fndecl = build_lang_decl (FUNCTION_DECL,
2811 get_file_function_name (type),
2812 build_function_type_list (void_type_node,
2814 start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
2816 TREE_PUBLIC (current_function_decl) = 0;
2818 /* Mark as artificial because it's not explicitly in the user's
2820 DECL_ARTIFICIAL (current_function_decl) = 1;
2822 /* Mark this declaration as used to avoid spurious warnings. */
2823 TREE_USED (current_function_decl) = 1;
2825 /* Mark this function as a global constructor or destructor. */
2826 if (method_type == 'I')
2827 DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
2829 DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
2831 body = begin_compound_stmt (BCS_FN_BODY);
2836 /* Finish the process of running a particular set of global constructors
2837 or destructors. Subroutine of do_[cd]tors. */
2840 finish_objects (int method_type, int initp, tree body)
2845 finish_compound_stmt (body);
2846 fn = finish_function (0);
2848 if (method_type == 'I')
2850 DECL_STATIC_CONSTRUCTOR (fn) = 1;
2851 decl_init_priority_insert (fn, initp);
2855 DECL_STATIC_DESTRUCTOR (fn) = 1;
2856 decl_fini_priority_insert (fn, initp);
2859 expand_or_defer_fn (fn);
2862 /* The names of the parameters to the function created to handle
2863 initializations and destructions for objects with static storage
2865 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2866 #define PRIORITY_IDENTIFIER "__priority"
2868 /* The name of the function we create to handle initializations and
2869 destructions for objects with static storage duration. */
2870 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2872 /* The declaration for the __INITIALIZE_P argument. */
2873 static GTY(()) tree initialize_p_decl;
2875 /* The declaration for the __PRIORITY argument. */
2876 static GTY(()) tree priority_decl;
2878 /* The declaration for the static storage duration function. */
2879 static GTY(()) tree ssdf_decl;
2881 /* All the static storage duration functions created in this
2882 translation unit. */
2883 static GTY(()) VEC(tree,gc) *ssdf_decls;
2885 /* A map from priority levels to information about that priority
2886 level. There may be many such levels, so efficient lookup is
2888 static splay_tree priority_info_map;
2890 /* Begins the generation of the function that will handle all
2891 initialization and destruction of objects with static storage
2892 duration. The function generated takes two parameters of type
2893 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2894 nonzero, it performs initializations. Otherwise, it performs
2895 destructions. It only performs those initializations or
2896 destructions with the indicated __PRIORITY. The generated function
2899 It is assumed that this function will only be called once per
2900 translation unit. */
2903 start_static_storage_duration_function (unsigned count)
2907 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2909 /* Create the identifier for this function. It will be of the form
2910 SSDF_IDENTIFIER_<number>. */
2911 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2913 type = build_function_type_list (void_type_node,
2914 integer_type_node, integer_type_node,
2917 /* Create the FUNCTION_DECL itself. */
2918 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2919 get_identifier (id),
2921 TREE_PUBLIC (ssdf_decl) = 0;
2922 DECL_ARTIFICIAL (ssdf_decl) = 1;
2924 /* Put this function in the list of functions to be called from the
2925 static constructors and destructors. */
2928 ssdf_decls = VEC_alloc (tree, gc, 32);
2930 /* Take this opportunity to initialize the map from priority
2931 numbers to information about that priority level. */
2932 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2933 /*delete_key_fn=*/0,
2934 /*delete_value_fn=*/
2935 (splay_tree_delete_value_fn) &free);
2937 /* We always need to generate functions for the
2938 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2939 priorities later, we'll be sure to find the
2940 DEFAULT_INIT_PRIORITY. */
2941 get_priority_info (DEFAULT_INIT_PRIORITY);
2944 VEC_safe_push (tree, gc, ssdf_decls, ssdf_decl);
2946 /* Create the argument list. */
2947 initialize_p_decl = cp_build_parm_decl
2948 (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2949 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2950 TREE_USED (initialize_p_decl) = 1;
2951 priority_decl = cp_build_parm_decl
2952 (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2953 DECL_CONTEXT (priority_decl) = ssdf_decl;
2954 TREE_USED (priority_decl) = 1;
2956 DECL_CHAIN (initialize_p_decl) = priority_decl;
2957 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2959 /* Put the function in the global scope. */
2960 pushdecl (ssdf_decl);
2962 /* Start the function itself. This is equivalent to declaring the
2965 static void __ssdf (int __initialize_p, init __priority_p);
2967 It is static because we only need to call this function from the
2968 various constructor and destructor functions for this module. */
2969 start_preparsed_function (ssdf_decl,
2970 /*attrs=*/NULL_TREE,
2973 /* Set up the scope of the outermost block in the function. */
2974 body = begin_compound_stmt (BCS_FN_BODY);
2979 /* Finish the generation of the function which performs initialization
2980 and destruction of objects with static storage duration. After
2981 this point, no more such objects can be created. */
2984 finish_static_storage_duration_function (tree body)
2986 /* Close out the function. */
2987 finish_compound_stmt (body);
2988 expand_or_defer_fn (finish_function (0));
2991 /* Return the information about the indicated PRIORITY level. If no
2992 code to handle this level has yet been generated, generate the
2993 appropriate prologue. */
2995 static priority_info
2996 get_priority_info (int priority)
3001 n = splay_tree_lookup (priority_info_map,
3002 (splay_tree_key) priority);
3005 /* Create a new priority information structure, and insert it
3007 pi = XNEW (struct priority_info_s);
3008 pi->initializations_p = 0;
3009 pi->destructions_p = 0;
3010 splay_tree_insert (priority_info_map,
3011 (splay_tree_key) priority,
3012 (splay_tree_value) pi);
3015 pi = (priority_info) n->value;
3020 /* The effective initialization priority of a DECL. */
3022 #define DECL_EFFECTIVE_INIT_PRIORITY(decl) \
3023 ((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \
3024 ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl))
3026 /* Whether a DECL needs a guard to protect it against multiple
3029 #define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl) \
3030 || DECL_ONE_ONLY (decl) \
3031 || DECL_WEAK (decl)))
3033 /* Called from one_static_initialization_or_destruction(),
3035 Walks the initializer list of a global variable and looks for
3036 temporary variables (DECL_NAME() == NULL and DECL_ARTIFICIAL != 0)
3037 and that have their DECL_CONTEXT() == NULL.
3038 For each such temporary variable, set their DECL_CONTEXT() to
3039 the current function. This is necessary because otherwise
3040 some optimizers (enabled by -O2 -fprofile-arcs) might crash
3041 when trying to refer to a temporary variable that does not have
3042 it's DECL_CONTECT() properly set. */
3044 fix_temporary_vars_context_r (tree *node,
3045 int *unused ATTRIBUTE_UNUSED,
3046 void *unused1 ATTRIBUTE_UNUSED)
3048 gcc_assert (current_function_decl);
3050 if (TREE_CODE (*node) == BIND_EXPR)
3054 for (var = BIND_EXPR_VARS (*node); var; var = DECL_CHAIN (var))
3055 if (TREE_CODE (var) == VAR_DECL
3057 && DECL_ARTIFICIAL (var)
3058 && !DECL_CONTEXT (var))
3059 DECL_CONTEXT (var) = current_function_decl;
3065 /* Set up to handle the initialization or destruction of DECL. If
3066 INITP is nonzero, we are initializing the variable. Otherwise, we
3067 are destroying it. */
3070 one_static_initialization_or_destruction (tree decl, tree init, bool initp)
3072 tree guard_if_stmt = NULL_TREE;
3075 /* If we are supposed to destruct and there's a trivial destructor,
3076 nothing has to be done. */
3078 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3081 /* Trick the compiler into thinking we are at the file and line
3082 where DECL was declared so that error-messages make sense, and so
3083 that the debugger will show somewhat sensible file and line
3085 input_location = DECL_SOURCE_LOCATION (decl);
3087 /* Make sure temporary variables in the initialiser all have
3088 their DECL_CONTEXT() set to a value different from NULL_TREE.
3089 This can happen when global variables initialisers are built.
3090 In that case, the DECL_CONTEXT() of the global variables _AND_ of all
3091 the temporary variables that might have been generated in the
3092 accompagning initialisers is NULL_TREE, meaning the variables have been
3093 declared in the global namespace.
3094 What we want to do here is to fix that and make sure the DECL_CONTEXT()
3095 of the temporaries are set to the current function decl. */
3096 cp_walk_tree_without_duplicates (&init,
3097 fix_temporary_vars_context_r,
3104 Access control for implicit calls to the constructors,
3105 the conversion functions, or the destructor called to
3106 create and destroy a static data member is performed as
3107 if these calls appeared in the scope of the member's
3110 we pretend we are in a static member function of the class of
3111 which the DECL is a member. */
3112 if (member_p (decl))
3114 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
3115 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
3118 /* Assume we don't need a guard. */
3120 /* We need a guard if this is an object with external linkage that
3121 might be initialized in more than one place. (For example, a
3122 static data member of a template, when the data member requires
3124 if (NEEDS_GUARD_P (decl))
3128 guard = get_guard (decl);
3130 /* When using __cxa_atexit, we just check the GUARD as we would
3131 for a local static. */
3132 if (flag_use_cxa_atexit)
3134 /* When using __cxa_atexit, we never try to destroy
3135 anything from a static destructor. */
3137 guard_cond = get_guard_cond (guard);
3139 /* If we don't have __cxa_atexit, then we will be running
3140 destructors from .fini sections, or their equivalents. So,
3141 we need to know how many times we've tried to initialize this
3142 object. We do initializations only if the GUARD is zero,
3143 i.e., if we are the first to initialize the variable. We do
3144 destructions only if the GUARD is one, i.e., if we are the
3145 last to destroy the variable. */
3148 = cp_build_binary_op (input_location,
3150 cp_build_unary_op (PREINCREMENT_EXPR,
3153 tf_warning_or_error),
3155 tf_warning_or_error);
3158 = cp_build_binary_op (input_location,
3160 cp_build_unary_op (PREDECREMENT_EXPR,
3163 tf_warning_or_error),
3165 tf_warning_or_error);
3167 guard_if_stmt = begin_if_stmt ();
3168 finish_if_stmt_cond (guard_cond, guard_if_stmt);
3172 /* If we're using __cxa_atexit, we have not already set the GUARD,
3173 so we must do so now. */
3174 if (guard && initp && flag_use_cxa_atexit)
3175 finish_expr_stmt (set_guard (guard));
3177 /* Perform the initialization or destruction. */
3181 finish_expr_stmt (init);
3183 /* If we're using __cxa_atexit, register a function that calls the
3184 destructor for the object. */
3185 if (flag_use_cxa_atexit)
3186 finish_expr_stmt (register_dtor_fn (decl));
3189 finish_expr_stmt (build_cleanup (decl));
3191 /* Finish the guard if-stmt, if necessary. */
3194 finish_then_clause (guard_if_stmt);
3195 finish_if_stmt (guard_if_stmt);
3198 /* Now that we're done with DECL we don't need to pretend to be a
3199 member of its class any longer. */
3200 DECL_CONTEXT (current_function_decl) = NULL_TREE;
3201 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
3204 /* Generate code to do the initialization or destruction of the decls in VARS,
3205 a TREE_LIST of VAR_DECL with static storage duration.
3206 Whether initialization or destruction is performed is specified by INITP. */
3209 do_static_initialization_or_destruction (tree vars, bool initp)
3211 tree node, init_if_stmt, cond;
3213 /* Build the outer if-stmt to check for initialization or destruction. */
3214 init_if_stmt = begin_if_stmt ();
3215 cond = initp ? integer_one_node : integer_zero_node;
3216 cond = cp_build_binary_op (input_location,
3220 tf_warning_or_error);
3221 finish_if_stmt_cond (cond, init_if_stmt);
3225 tree decl = TREE_VALUE (node);
3226 tree priority_if_stmt;
3230 /* If we don't need a destructor, there's nothing to do. Avoid
3231 creating a possibly empty if-stmt. */
3232 if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3234 node = TREE_CHAIN (node);
3238 /* Remember that we had an initialization or finalization at this
3240 priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
3241 pi = get_priority_info (priority);
3243 pi->initializations_p = 1;
3245 pi->destructions_p = 1;
3247 /* Conditionalize this initialization on being in the right priority
3248 and being initializing/finalizing appropriately. */
3249 priority_if_stmt = begin_if_stmt ();
3250 cond = cp_build_binary_op (input_location,
3253 build_int_cst (NULL_TREE, priority),
3254 tf_warning_or_error);
3255 finish_if_stmt_cond (cond, priority_if_stmt);
3257 /* Process initializers with same priority. */
3259 && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
3260 node = TREE_CHAIN (node))
3261 /* Do one initialization or destruction. */
3262 one_static_initialization_or_destruction (TREE_VALUE (node),
3263 TREE_PURPOSE (node), initp);
3265 /* Finish up the priority if-stmt body. */
3266 finish_then_clause (priority_if_stmt);
3267 finish_if_stmt (priority_if_stmt);
3271 /* Finish up the init/destruct if-stmt body. */
3272 finish_then_clause (init_if_stmt);
3273 finish_if_stmt (init_if_stmt);
3276 /* VARS is a list of variables with static storage duration which may
3277 need initialization and/or finalization. Remove those variables
3278 that don't really need to be initialized or finalized, and return
3279 the resulting list. The order in which the variables appear in
3280 VARS is in reverse order of the order in which they should actually
3281 be initialized. The list we return is in the unreversed order;
3282 i.e., the first variable should be initialized first. */
3285 prune_vars_needing_no_initialization (tree *vars)
3288 tree result = NULL_TREE;
3293 tree decl = TREE_VALUE (t);
3294 tree init = TREE_PURPOSE (t);
3296 /* Deal gracefully with error. */
3297 if (decl == error_mark_node)
3299 var = &TREE_CHAIN (t);
3303 /* The only things that can be initialized are variables. */
3304 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3306 /* If this object is not defined, we don't need to do anything
3308 if (DECL_EXTERNAL (decl))
3310 var = &TREE_CHAIN (t);
3314 /* Also, if the initializer already contains errors, we can bail
3316 if (init && TREE_CODE (init) == TREE_LIST
3317 && value_member (error_mark_node, init))
3319 var = &TREE_CHAIN (t);
3323 /* This variable is going to need initialization and/or
3324 finalization, so we add it to the list. */
3325 *var = TREE_CHAIN (t);
3326 TREE_CHAIN (t) = result;
3333 /* Make sure we have told the back end about all the variables in
3337 write_out_vars (tree vars)
3341 for (v = vars; v; v = TREE_CHAIN (v))
3343 tree var = TREE_VALUE (v);
3344 if (!var_finalized_p (var))
3346 import_export_decl (var);
3347 rest_of_decl_compilation (var, 1, 1);
3352 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
3353 (otherwise) that will initialize all global objects with static
3354 storage duration having the indicated PRIORITY. */
3357 generate_ctor_or_dtor_function (bool constructor_p, int priority,
3365 input_location = *locus;
3367 /* Was: locus->line++; */
3369 /* We use `I' to indicate initialization and `D' to indicate
3371 function_key = constructor_p ? 'I' : 'D';
3373 /* We emit the function lazily, to avoid generating empty
3374 global constructors and destructors. */
3377 /* For Objective-C++, we may need to initialize metadata found in this module.
3378 This must be done _before_ any other static initializations. */
3379 if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
3380 && constructor_p && objc_static_init_needed_p ())
3382 body = start_objects (function_key, priority);
3383 objc_generate_static_init_call (NULL_TREE);
3386 /* Call the static storage duration function with appropriate
3388 FOR_EACH_VEC_ELT (tree, ssdf_decls, i, fndecl)
3390 /* Calls to pure or const functions will expand to nothing. */
3391 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
3396 body = start_objects (function_key, priority);
3398 call = cp_build_function_call_nary (fndecl, tf_warning_or_error,
3399 build_int_cst (NULL_TREE,
3401 build_int_cst (NULL_TREE,
3404 finish_expr_stmt (call);
3408 /* Close out the function. */
3410 finish_objects (function_key, priority, body);
3413 /* Generate constructor and destructor functions for the priority
3417 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
3419 location_t *locus = (location_t *) data;
3420 int priority = (int) n->key;
3421 priority_info pi = (priority_info) n->value;
3423 /* Generate the functions themselves, but only if they are really
3425 if (pi->initializations_p)
3426 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
3427 if (pi->destructions_p)
3428 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
3430 /* Keep iterating. */
3434 /* Java requires that we be able to reference a local address for a
3435 method, and not be confused by PLT entries. If hidden aliases are
3436 supported, collect and return all the functions for which we should
3437 emit a hidden alias. */
3439 static struct pointer_set_t *
3440 collect_candidates_for_java_method_aliases (void)
3442 struct cgraph_node *node;
3443 struct pointer_set_t *candidates = NULL;
3445 #ifndef HAVE_GAS_HIDDEN
3449 FOR_EACH_FUNCTION (node)
3451 tree fndecl = node->symbol.decl;
3453 if (DECL_CONTEXT (fndecl)
3454 && TYPE_P (DECL_CONTEXT (fndecl))
3455 && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
3456 && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
3458 if (candidates == NULL)
3459 candidates = pointer_set_create ();
3460 pointer_set_insert (candidates, fndecl);
3468 /* Java requires that we be able to reference a local address for a
3469 method, and not be confused by PLT entries. If hidden aliases are
3470 supported, emit one for each java function that we've emitted.
3471 CANDIDATES is the set of FUNCTION_DECLs that were gathered
3472 by collect_candidates_for_java_method_aliases. */
3475 build_java_method_aliases (struct pointer_set_t *candidates)
3477 struct cgraph_node *node;
3479 #ifndef HAVE_GAS_HIDDEN
3483 FOR_EACH_FUNCTION (node)
3485 tree fndecl = node->symbol.decl;
3487 if (TREE_ASM_WRITTEN (fndecl)
3488 && pointer_set_contains (candidates, fndecl))
3490 /* Mangle the name in a predictable way; we need to reference
3491 this from a java compiled object file. */
3492 tree oid, nid, alias;
3496 oid = DECL_ASSEMBLER_NAME (fndecl);
3497 oname = IDENTIFIER_POINTER (oid);
3498 gcc_assert (oname[0] == '_' && oname[1] == 'Z');
3499 nname = ACONCAT (("_ZGA", oname+2, NULL));
3500 nid = get_identifier (nname);
3502 alias = make_alias_for (fndecl, nid);
3503 TREE_PUBLIC (alias) = 1;
3504 DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
3506 assemble_alias (alias, oid);
3511 /* Return C++ property of T, based on given operation OP. */
3514 cpp_check (tree t, cpp_operation op)
3519 return DECL_PURE_VIRTUAL_P (t);
3520 case IS_CONSTRUCTOR:
3521 return DECL_CONSTRUCTOR_P (t);
3523 return DECL_DESTRUCTOR_P (t);
3524 case IS_COPY_CONSTRUCTOR:
3525 return DECL_COPY_CONSTRUCTOR_P (t);
3527 return TREE_CODE (t) == TEMPLATE_DECL;
3533 /* Collect source file references recursively, starting from NAMESPC. */
3536 collect_source_refs (tree namespc)
3543 /* Iterate over names in this name space. */
3544 for (t = NAMESPACE_LEVEL (namespc)->names; t; t = TREE_CHAIN (t))
3545 if (!DECL_IS_BUILTIN (t) )
3546 collect_source_ref (DECL_SOURCE_FILE (t));
3548 /* Dump siblings, if any */
3549 collect_source_refs (TREE_CHAIN (namespc));
3551 /* Dump children, if any */
3552 collect_source_refs (NAMESPACE_LEVEL (namespc)->namespaces);
3555 /* Collect decls relevant to SOURCE_FILE from all namespaces recursively,
3556 starting from NAMESPC. */
3559 collect_ada_namespace (tree namespc, const char *source_file)
3564 /* Collect decls from this namespace */
3565 collect_ada_nodes (NAMESPACE_LEVEL (namespc)->names, source_file);
3567 /* Collect siblings, if any */
3568 collect_ada_namespace (TREE_CHAIN (namespc), source_file);
3570 /* Collect children, if any */
3571 collect_ada_namespace (NAMESPACE_LEVEL (namespc)->namespaces, source_file);
3574 /* Returns true iff there is a definition available for variable or
3578 decl_defined_p (tree decl)
3580 if (TREE_CODE (decl) == FUNCTION_DECL)
3581 return (DECL_INITIAL (decl) != NULL_TREE);
3584 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3585 return !DECL_EXTERNAL (decl);
3589 /* Nonzero for a VAR_DECL whose value can be used in a constant expression.
3593 An integral constant-expression can only involve ... const
3594 variables of integral or enumeration types initialized with
3595 constant expressions ...
3597 C++0x also allows constexpr variables and temporaries initialized
3598 with constant expressions. We handle the former here, but the latter
3599 are just folded away in cxx_eval_constant_expression.
3601 The standard does not require that the expression be non-volatile.
3602 G++ implements the proposed correction in DR 457. */
3605 decl_constant_var_p (tree decl)
3607 if (!decl_maybe_constant_var_p (decl))
3610 /* We don't know if a template static data member is initialized with
3611 a constant expression until we instantiate its initializer. Even
3612 in the case of a constexpr variable, we can't treat it as a
3613 constant until its initializer is complete in case it's used in
3614 its own initializer. */
3616 return DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl);
3619 /* Returns true if DECL could be a symbolic constant variable, depending on
3623 decl_maybe_constant_var_p (tree decl)
3625 tree type = TREE_TYPE (decl);
3626 if (TREE_CODE (decl) != VAR_DECL)
3628 if (DECL_DECLARED_CONSTEXPR_P (decl))
3630 return (CP_TYPE_CONST_NON_VOLATILE_P (type)
3631 && INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3634 /* Complain that DECL uses a type with no linkage but is never defined. */
3637 no_linkage_error (tree decl)
3639 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
3640 if (TYPE_ANONYMOUS_P (t))
3642 permerror (0, "%q+#D, declared using anonymous type, "
3643 "is used but never defined", decl);
3644 if (is_typedef_decl (TYPE_NAME (t)))
3645 permerror (0, "%q+#D does not refer to the unqualified type, "
3646 "so it is not used for linkage", TYPE_NAME (t));
3649 permerror (0, "%q+#D, declared using local type %qT, "
3650 "is used but never defined", decl, t);
3653 /* Collect declarations from all namespaces relevant to SOURCE_FILE. */
3656 collect_all_refs (const char *source_file)
3658 collect_ada_namespace (global_namespace, source_file);
3661 /* Clear DECL_EXTERNAL for NODE. */
3664 clear_decl_external (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
3666 DECL_EXTERNAL (node->symbol.decl) = 0;
3670 /* This routine is called at the end of compilation.
3671 Its job is to create all the code needed to initialize and
3672 destroy the global aggregates. We do the destruction
3673 first, since that way we only need to reverse the decls once. */
3676 cp_write_global_declarations (void)
3682 unsigned ssdf_count = 0;
3685 struct pointer_set_t *candidates;
3687 locus = input_location;
3690 /* Bad parse errors. Just forget about it. */
3691 if (! global_bindings_p () || current_class_type
3692 || !VEC_empty (tree,decl_namespace_list))
3696 c_common_write_pch ();
3698 cgraph_process_same_body_aliases ();
3700 /* Handle -fdump-ada-spec[-slim] */
3701 if (dump_enabled_p (TDI_ada))
3703 if (get_dump_file_info (TDI_ada)->flags & TDF_SLIM)
3704 collect_source_ref (main_input_filename);
3706 collect_source_refs (global_namespace);
3708 dump_ada_specs (collect_all_refs, cpp_check);
3711 /* FIXME - huh? was input_line -= 1;*/
3713 timevar_start (TV_PHASE_DEFERRED);
3715 /* We now have to write out all the stuff we put off writing out.
3718 o Template specializations that we have not yet instantiated,
3719 but which are needed.
3720 o Initialization and destruction for non-local objects with
3721 static storage duration. (Local objects with static storage
3722 duration are initialized when their scope is first entered,
3723 and are cleaned up via atexit.)
3724 o Virtual function tables.
3726 All of these may cause others to be needed. For example,
3727 instantiating one function may cause another to be needed, and
3728 generating the initializer for an object may cause templates to be
3729 instantiated, etc., etc. */
3731 emit_support_tinfos ();
3740 /* If there are templates that we've put off instantiating, do
3742 instantiate_pending_templates (retries);
3745 /* Write out virtual tables as required. Note that writing out
3746 the virtual table for a template class may cause the
3747 instantiation of members of that class. If we write out
3748 vtables then we remove the class from our list so we don't
3749 have to look at it again. */
3751 while (keyed_classes != NULL_TREE
3752 && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
3755 keyed_classes = TREE_CHAIN (keyed_classes);
3761 tree next = TREE_CHAIN (t);
3765 if (maybe_emit_vtables (TREE_VALUE (next)))
3768 TREE_CHAIN (t) = TREE_CHAIN (next);
3773 next = TREE_CHAIN (t);
3777 /* Write out needed type info variables. We have to be careful
3778 looping through unemitted decls, because emit_tinfo_decl may
3779 cause other variables to be needed. New elements will be
3780 appended, and we remove from the vector those that actually
3782 for (i = VEC_length (tree, unemitted_tinfo_decls);
3783 VEC_iterate (tree, unemitted_tinfo_decls, --i, t);)
3784 if (emit_tinfo_decl (t))
3787 VEC_unordered_remove (tree, unemitted_tinfo_decls, i);
3790 /* The list of objects with static storage duration is built up
3791 in reverse order. We clear STATIC_AGGREGATES so that any new
3792 aggregates added during the initialization of these will be
3793 initialized in the correct order when we next come around the
3795 vars = prune_vars_needing_no_initialization (&static_aggregates);
3799 /* We need to start a new initialization function each time
3800 through the loop. That's because we need to know which
3801 vtables have been referenced, and TREE_SYMBOL_REFERENCED
3802 isn't computed until a function is finished, and written
3803 out. That's a deficiency in the back end. When this is
3804 fixed, these initialization functions could all become
3805 inline, with resulting performance improvements. */
3808 /* Set the line and file, so that it is obviously not from
3810 input_location = locus;
3811 ssdf_body = start_static_storage_duration_function (ssdf_count);
3813 /* Make sure the back end knows about all the variables. */
3814 write_out_vars (vars);
3816 /* First generate code to do all the initializations. */
3818 do_static_initialization_or_destruction (vars, /*initp=*/true);
3820 /* Then, generate code to do all the destructions. Do these
3821 in reverse order so that the most recently constructed
3822 variable is the first destroyed. If we're using
3823 __cxa_atexit, then we don't need to do this; functions
3824 were registered at initialization time to destroy the
3826 if (!flag_use_cxa_atexit && vars)
3828 vars = nreverse (vars);
3829 do_static_initialization_or_destruction (vars, /*initp=*/false);
3834 /* Finish up the static storage duration function for this
3836 input_location = locus;
3837 finish_static_storage_duration_function (ssdf_body);
3839 /* All those initializations and finalizations might cause
3840 us to need more inline functions, more template
3841 instantiations, etc. */
3844 /* ??? was: locus.line++; */
3847 /* Go through the set of inline functions whose bodies have not
3848 been emitted yet. If out-of-line copies of these functions
3849 are required, emit them. */
3850 FOR_EACH_VEC_ELT (tree, deferred_fns, i, decl)
3852 /* Does it need synthesizing? */
3853 if (DECL_DEFAULTED_FN (decl) && ! DECL_INITIAL (decl)
3854 && (! DECL_REALLY_EXTERN (decl) || possibly_inlined_p (decl)))
3856 /* Even though we're already at the top-level, we push
3857 there again. That way, when we pop back a few lines
3858 hence, all of our state is restored. Otherwise,
3859 finish_function doesn't clean things up, and we end
3860 up with CURRENT_FUNCTION_DECL set. */
3861 push_to_top_level ();
3862 /* The decl's location will mark where it was first
3863 needed. Save that so synthesize method can indicate
3864 where it was needed from, in case of error */
3865 input_location = DECL_SOURCE_LOCATION (decl);
3866 synthesize_method (decl);
3867 pop_from_top_level ();
3871 if (!DECL_SAVED_TREE (decl))
3874 /* We lie to the back end, pretending that some functions
3875 are not defined when they really are. This keeps these
3876 functions from being put out unnecessarily. But, we must
3877 stop lying when the functions are referenced, or if they
3878 are not comdat since they need to be put out now. If
3879 DECL_INTERFACE_KNOWN, then we have already set
3880 DECL_EXTERNAL appropriately, so there's no need to check
3881 again, and we do not want to clear DECL_EXTERNAL if a
3882 previous call to import_export_decl set it.
3884 This is done in a separate for cycle, because if some
3885 deferred function is contained in another deferred
3886 function later in deferred_fns varray,
3887 rest_of_compilation would skip this function and we
3888 really cannot expand the same function twice. */
3889 import_export_decl (decl);
3890 if (DECL_NOT_REALLY_EXTERN (decl)
3891 && DECL_INITIAL (decl)
3892 && decl_needed_p (decl))
3894 struct cgraph_node *node, *next;
3896 node = cgraph_get_node (decl);
3897 if (node->same_body_alias)
3898 node = cgraph_alias_aliased_node (node);
3900 cgraph_for_node_and_aliases (node, clear_decl_external,
3902 /* If we mark !DECL_EXTERNAL one of the symbols in some comdat
3903 group, we need to mark all symbols in the same comdat group
3905 if (node->symbol.same_comdat_group)
3906 for (next = cgraph (node->symbol.same_comdat_group);
3908 next = cgraph (next->symbol.same_comdat_group))
3909 cgraph_for_node_and_aliases (next, clear_decl_external,
3913 /* If we're going to need to write this function out, and
3914 there's already a body for it, create RTL for it now.
3915 (There might be no body if this is a method we haven't
3916 gotten around to synthesizing yet.) */
3917 if (!DECL_EXTERNAL (decl)
3918 && decl_needed_p (decl)
3919 && !TREE_ASM_WRITTEN (decl)
3920 && !cgraph_get_node (decl)->local.finalized)
3922 /* We will output the function; no longer consider it in this
3924 DECL_DEFER_OUTPUT (decl) = 0;
3925 /* Generate RTL for this function now that we know we
3927 expand_or_defer_fn (decl);
3928 /* If we're compiling -fsyntax-only pretend that this
3929 function has been written out so that we don't try to
3931 if (flag_syntax_only)
3932 TREE_ASM_WRITTEN (decl) = 1;
3937 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
3940 /* Static data members are just like namespace-scope globals. */
3941 FOR_EACH_VEC_ELT (tree, pending_statics, i, decl)
3943 if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl)
3944 /* Don't write it out if we haven't seen a definition. */
3945 || DECL_IN_AGGR_P (decl))
3947 import_export_decl (decl);
3948 /* If this static data member is needed, provide it to the
3950 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
3951 DECL_EXTERNAL (decl) = 0;
3953 if (VEC_length (tree, pending_statics) != 0
3954 && wrapup_global_declarations (VEC_address (tree, pending_statics),
3955 VEC_length (tree, pending_statics)))
3962 /* All used inline functions must have a definition at this point. */
3963 FOR_EACH_VEC_ELT (tree, deferred_fns, i, decl)
3965 if (/* Check online inline functions that were actually used. */
3966 DECL_ODR_USED (decl) && DECL_DECLARED_INLINE_P (decl)
3967 /* If the definition actually was available here, then the
3968 fact that the function was not defined merely represents
3969 that for some reason (use of a template repository,
3970 #pragma interface, etc.) we decided not to emit the
3972 && !DECL_INITIAL (decl)
3973 /* Don't complain if the template was defined. */
3974 && !(DECL_TEMPLATE_INSTANTIATION (decl)
3975 && DECL_INITIAL (DECL_TEMPLATE_RESULT
3976 (template_for_substitution (decl)))))
3978 warning (0, "inline function %q+D used but never defined", decl);
3979 /* Avoid a duplicate warning from check_global_declaration_1. */
3980 TREE_NO_WARNING (decl) = 1;
3984 /* So must decls that use a type with no linkage. */
3985 FOR_EACH_VEC_ELT (tree, no_linkage_decls, i, decl)
3986 if (!decl_defined_p (decl))
3987 no_linkage_error (decl);
3989 /* Then, do the Objective-C stuff. This is where all the
3990 Objective-C module stuff gets generated (symtab,
3991 class/protocol/selector lists etc). This must be done after C++
3992 templates, destructors etc. so that selectors used in C++
3993 templates are properly allocated. */
3994 if (c_dialect_objc ())
3995 objc_write_global_declarations ();
3997 /* We give C linkage to static constructors and destructors. */
3998 push_lang_context (lang_name_c);
4000 /* Generate initialization and destruction functions for all
4001 priorities for which they are required. */
4002 if (priority_info_map)
4003 splay_tree_foreach (priority_info_map,
4004 generate_ctor_and_dtor_functions_for_priority,
4006 else if (c_dialect_objc () && objc_static_init_needed_p ())
4007 /* If this is obj-c++ and we need a static init, call
4008 generate_ctor_or_dtor_function. */
4009 generate_ctor_or_dtor_function (/*constructor_p=*/true,
4010 DEFAULT_INIT_PRIORITY, &locus);
4012 /* We're done with the splay-tree now. */
4013 if (priority_info_map)
4014 splay_tree_delete (priority_info_map);
4016 /* Generate any missing aliases. */
4017 maybe_apply_pending_pragma_weaks ();
4019 /* We're done with static constructors, so we can go back to "C++"
4021 pop_lang_context ();
4023 /* Collect candidates for Java hidden aliases. */
4024 candidates = collect_candidates_for_java_method_aliases ();
4026 timevar_stop (TV_PHASE_DEFERRED);
4027 timevar_start (TV_PHASE_CGRAPH);
4029 cgraph_finalize_compilation_unit ();
4031 timevar_stop (TV_PHASE_CGRAPH);
4032 timevar_start (TV_PHASE_CHECK_DBGINFO);
4034 /* Now, issue warnings about static, but not defined, functions,
4035 etc., and emit debugging information. */
4036 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
4037 if (VEC_length (tree, pending_statics) != 0)
4039 check_global_declarations (VEC_address (tree, pending_statics),
4040 VEC_length (tree, pending_statics));
4041 emit_debug_global_declarations (VEC_address (tree, pending_statics),
4042 VEC_length (tree, pending_statics));
4045 perform_deferred_noexcept_checks ();
4047 /* Generate hidden aliases for Java. */
4050 build_java_method_aliases (candidates);
4051 pointer_set_destroy (candidates);
4056 /* The entire file is now complete. If requested, dump everything
4060 FILE *stream = dump_begin (TDI_tu, &flags);
4064 dump_node (global_namespace, flags & ~TDF_SLIM, stream);
4065 dump_end (TDI_tu, stream);
4069 if (flag_detailed_statistics)
4071 dump_tree_statistics ();
4072 dump_time_statistics ();
4074 input_location = locus;
4076 #ifdef ENABLE_CHECKING
4077 validate_conversion_obstack ();
4078 #endif /* ENABLE_CHECKING */
4080 timevar_stop (TV_PHASE_CHECK_DBGINFO);
4083 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
4084 function to call in parse-tree form; it has not yet been
4085 semantically analyzed. ARGS are the arguments to the function.
4086 They have already been semantically analyzed. This may change
4090 build_offset_ref_call_from_tree (tree fn, VEC(tree,gc) **args)
4093 VEC(tree,gc) *orig_args = NULL;
4098 object = TREE_OPERAND (fn, 0);
4100 if (processing_template_decl)
4102 gcc_assert (TREE_CODE (fn) == DOTSTAR_EXPR
4103 || TREE_CODE (fn) == MEMBER_REF);
4104 if (type_dependent_expression_p (fn)
4105 || any_type_dependent_arguments_p (*args))
4106 return build_nt_call_vec (fn, *args);
4108 orig_args = make_tree_vector_copy (*args);
4110 /* Transform the arguments and add the implicit "this"
4111 parameter. That must be done before the FN is transformed
4112 because we depend on the form of FN. */
4113 make_args_non_dependent (*args);
4114 object = build_non_dependent_expr (object);
4115 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4117 if (TREE_CODE (fn) == DOTSTAR_EXPR)
4118 object = cp_build_addr_expr (object, tf_warning_or_error);
4119 VEC_safe_insert (tree, gc, *args, 0, object);
4121 /* Now that the arguments are done, transform FN. */
4122 fn = build_non_dependent_expr (fn);
4125 /* A qualified name corresponding to a bound pointer-to-member is
4126 represented as an OFFSET_REF:
4128 struct B { void g(); };
4130 void B::g() { (this->*p)(); } */
4131 if (TREE_CODE (fn) == OFFSET_REF)
4133 tree object_addr = cp_build_addr_expr (object, tf_warning_or_error);
4134 fn = TREE_OPERAND (fn, 1);
4135 fn = get_member_function_from_ptrfunc (&object_addr, fn,
4136 tf_warning_or_error);
4137 VEC_safe_insert (tree, gc, *args, 0, object_addr);
4140 if (CLASS_TYPE_P (TREE_TYPE (fn)))
4141 expr = build_op_call (fn, args, tf_warning_or_error);
4143 expr = cp_build_function_call_vec (fn, args, tf_warning_or_error);
4144 if (processing_template_decl && expr != error_mark_node)
4145 expr = build_min_non_dep_call_vec (expr, orig_fn, orig_args);
4147 if (orig_args != NULL)
4148 release_tree_vector (orig_args);
4155 check_default_args (tree x)
4157 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
4158 bool saw_def = false;
4159 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
4160 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
4162 if (TREE_PURPOSE (arg))
4166 error ("default argument missing for parameter %P of %q+#D", i, x);
4167 TREE_PURPOSE (arg) = error_mark_node;
4172 /* Return true if function DECL can be inlined. This is used to force
4173 instantiation of methods that might be interesting for inlining. */
4175 possibly_inlined_p (tree decl)
4177 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
4178 if (DECL_UNINLINABLE (decl))
4180 if (!optimize || pragma_java_exceptions)
4181 return DECL_DECLARED_INLINE_P (decl);
4182 /* When optimizing, we might inline everything when flatten
4183 attribute or heuristics inlining for size or autoinlining
4188 /* Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
4189 If DECL is a specialization or implicitly declared class member,
4190 generate the actual definition. Return false if something goes
4191 wrong, true otherwise. */
4194 mark_used (tree decl)
4196 /* If DECL is a BASELINK for a single function, then treat it just
4197 like the DECL for the function. Otherwise, if the BASELINK is
4198 for an overloaded function, we don't know which function was
4199 actually used until after overload resolution. */
4200 if (BASELINK_P (decl))
4202 decl = BASELINK_FUNCTIONS (decl);
4203 if (really_overloaded_fn (decl))
4205 decl = OVL_CURRENT (decl);
4208 /* Set TREE_USED for the benefit of -Wunused. */
4209 TREE_USED (decl) = 1;
4210 if (DECL_CLONED_FUNCTION_P (decl))
4211 TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4213 if (TREE_CODE (decl) == FUNCTION_DECL
4214 && DECL_DELETED_FN (decl))
4216 if (DECL_ARTIFICIAL (decl))
4218 if (DECL_OVERLOADED_OPERATOR_P (decl) == TYPE_EXPR
4219 && LAMBDA_TYPE_P (DECL_CONTEXT (decl)))
4221 /* We mark a lambda conversion op as deleted if we can't
4222 generate it properly; see maybe_add_lambda_conv_op. */
4223 sorry ("converting lambda which uses %<...%> to "
4224 "function pointer");
4228 error ("use of deleted function %qD", decl);
4229 if (!maybe_explain_implicit_delete (decl))
4230 error_at (DECL_SOURCE_LOCATION (decl), "declared here");
4234 /* We can only check DECL_ODR_USED on variables or functions with
4235 DECL_LANG_SPECIFIC set, and these are also the only decls that we
4236 might need special handling for. */
4237 if ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4238 || DECL_LANG_SPECIFIC (decl) == NULL
4239 || DECL_THUNK_P (decl))
4241 if (!processing_template_decl && type_uses_auto (TREE_TYPE (decl)))
4242 error ("use of %qD before deduction of %<auto%>", decl);
4246 /* We only want to do this processing once. We don't need to keep trying
4247 to instantiate inline templates, because unit-at-a-time will make sure
4248 we get them compiled before functions that want to inline them. */
4249 if (DECL_ODR_USED (decl))
4252 /* If within finish_function, defer the rest until that function
4253 finishes, otherwise it might recurse. */
4254 if (defer_mark_used_calls)
4256 VEC_safe_push (tree, gc, deferred_mark_used_calls, decl);
4260 if (TREE_CODE (decl) == FUNCTION_DECL)
4261 maybe_instantiate_noexcept (decl);
4263 /* Normally, we can wait until instantiation-time to synthesize DECL.
4264 However, if DECL is a static data member initialized with a constant
4265 or a constexpr function, we need it right now because a reference to
4266 such a data member or a call to such function is not value-dependent.
4267 For a function that uses auto in the return type, we need to instantiate
4268 it to find out its type. */
4269 if ((decl_maybe_constant_var_p (decl)
4270 || (TREE_CODE (decl) == FUNCTION_DECL
4271 && (DECL_DECLARED_CONSTEXPR_P (decl)
4272 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl))))))
4273 && DECL_LANG_SPECIFIC (decl)
4274 && DECL_TEMPLATE_INFO (decl)
4275 && !uses_template_parms (DECL_TI_ARGS (decl)))
4277 /* Instantiating a function will result in garbage collection. We
4278 must treat this situation as if we were within the body of a
4279 function so as to avoid collecting live data only referenced from
4280 the stack (such as overload resolution candidates). */
4282 instantiate_decl (decl, /*defer_ok=*/false,
4283 /*expl_inst_class_mem_p=*/false);
4287 if (type_uses_auto (TREE_TYPE (decl)))
4288 error ("use of %qD before deduction of %<auto%>", decl);
4290 /* If we don't need a value, then we don't need to synthesize DECL. */
4291 if (cp_unevaluated_operand != 0)
4294 if (processing_template_decl)
4297 /* Check this too in case we're within fold_non_dependent_expr. */
4298 if (DECL_TEMPLATE_INFO (decl)
4299 && uses_template_parms (DECL_TI_ARGS (decl)))
4302 DECL_ODR_USED (decl) = 1;
4303 if (DECL_CLONED_FUNCTION_P (decl))
4304 DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4306 /* DR 757: A type without linkage shall not be used as the type of a
4307 variable or function with linkage, unless
4308 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
4309 o the variable or function is not used (3.2 [basic.def.odr]) or is
4310 defined in the same translation unit. */
4311 if (cxx_dialect > cxx98
4312 && decl_linkage (decl) != lk_none
4313 && !DECL_EXTERN_C_P (decl)
4314 && !DECL_ARTIFICIAL (decl)
4315 && !decl_defined_p (decl)
4316 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
4318 if (is_local_extern (decl))
4319 /* There's no way to define a local extern, and adding it to
4320 the vector interferes with GC, so give an error now. */
4321 no_linkage_error (decl);
4323 VEC_safe_push (tree, gc, no_linkage_decls, decl);
4326 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
4327 && !DECL_INITIAL (decl) && !DECL_ARTIFICIAL (decl))
4328 /* Remember it, so we can check it was defined. */
4329 note_vague_linkage_fn (decl);
4331 /* Is it a synthesized method that needs to be synthesized? */
4332 if (TREE_CODE (decl) == FUNCTION_DECL
4333 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
4334 && DECL_DEFAULTED_FN (decl)
4335 /* A function defaulted outside the class is synthesized either by
4336 cp_finish_decl or instantiate_decl. */
4337 && !DECL_DEFAULTED_OUTSIDE_CLASS_P (decl)
4338 && ! DECL_INITIAL (decl))
4340 /* Defer virtual destructors so that thunks get the right
4342 if (DECL_VIRTUAL_P (decl) && !at_eof)
4344 note_vague_linkage_fn (decl);
4348 /* Remember the current location for a function we will end up
4349 synthesizing. Then we can inform the user where it was
4350 required in the case of error. */
4351 DECL_SOURCE_LOCATION (decl) = input_location;
4353 /* Synthesizing an implicitly defined member function will result in
4354 garbage collection. We must treat this situation as if we were
4355 within the body of a function so as to avoid collecting live data
4356 on the stack (such as overload resolution candidates).
4358 We could just let cp_write_global_declarations handle synthesizing
4359 this function by adding it to deferred_fns, but doing
4360 it at the use site produces better error messages. */
4362 synthesize_method (decl);
4364 /* If this is a synthesized method we don't need to
4365 do the instantiation test below. */
4367 else if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4368 && DECL_TEMPLATE_INFO (decl)
4369 && (!DECL_EXPLICIT_INSTANTIATION (decl)
4370 || always_instantiate_p (decl)))
4371 /* If this is a function or variable that is an instance of some
4372 template, we now know that we will need to actually do the
4373 instantiation. We check that DECL is not an explicit
4374 instantiation because that is not checked in instantiate_decl.
4376 We put off instantiating functions in order to improve compile
4377 times. Maintaining a stack of active functions is expensive,
4378 and the inliner knows to instantiate any functions it might
4379 need. Therefore, we always try to defer instantiation. */
4382 instantiate_decl (decl, /*defer_ok=*/true,
4383 /*expl_inst_class_mem_p=*/false);
4390 #include "gt-cp-decl2.h"